All language subtitles for 19-RandomDepthRotation

We made the wall look much more interesting
in the last chapter, by randomizing the depth

of the bricks.

But we can also randomize their rotation,
so that they are not all parallel to the plane.

This is especially nice, because it will change
the shading on the bricks as they will get

lit from different angles.

In Chapter 7, we already randomized the 2D
rotation of the bricks, so that they are not

completely horizontal, but let's now randomize
the rotation in the two remaining axes.

There are many ways to approach this, but
probably the easiest, is to just think of

what effect a brick rotation would have on
the surface.

If we just consider a rotation around the
vertical axis, the result would be that one

end of the brick sticks out of the wall more
than the other.

Looking at the height map, that's basically
just a linear gradient along the brick.

And the same goes for a rotation around the
horizontal axis, it is just a gradient along

the height of the brick.

So to randomize the rotation, we would need
to generate random linear gradients.

One way to achieve that, would be with an
actual vector rotation.

If we take a look at the centered brick coordinates
that we computed early on in the course, we

have an X value that changes horizontally,
and a Y value that changes vertically, but

actually, we also have a Z value, which indicates
depth, we just don't see it here, because

it is zero everywhere.

Now this becomes useful when we add a vector
rotation.

Rotating around the plane's Z axis just rotates
the 2D coordinates like we saw before, but

there is no change in the Z channel.

But it gets more interesting when we set the
rotation to something like the Y axis.

Now, changing the angle, we start seeing a
blue gradient, which is the Z channel being

rotated as well.

This is more clear if we look at a three dimensional
object and see how all the coordinates are

rotating.

Our plane is just a cross section of those
coordinates.

Now if we isolate the Z channel with a Separate
XYZ node, we can see that we have a gradient

that varies with the rotation amount.

Note that the side that is black is not actually
constant, it's the same as the other side,

but in the negative direction.

And if we now set the rotation to the X axis,
we get the same thing happening in the other

direction.

But to generate the random rotation, we don't
want to rotate around a specific axis.

Instead, we can set it to do an Euler rotation,
which allows us to input the angle of rotation

for each axis as a vector.

Then we see that the gradient can go in all
sorts of directions.

Let's bring this setup close to where we randomized
the depth, as we can make use of the same

White Noise node for our random input.

Then let's neaten this node connection a bit,
so that it's not overlapping everything.

To access all the random channels, we'll need
a Separate RGB again.

Then let's also make some extra space here,
and while we're at it, we can join these two

connections with a Reroute.

Then let's move these nodes over, and carry
their input over from the Value output, to

the equivalent R channel, just to keep everything
consistent.

Then we can drag our new nodes into the Frame,
and finish straightening the connection.

Now, to feed the random values into the X
and Y rotation channels of the Vector Rotate

node, we'll need a Combine XYZ node.

And then we can plug the two remaining random
channels into X and Y, and plug the output

into the Vector Rotate.

Now our gradients are randomized, but the
top left corner is always at a higher value

than the bottom right corner, and that's because
with the random values between zero and one,

we are always rotating in the positive direction,
so let's add a Vector Math node here, to subtract

0.5 from X and Y, so that they are centered
around zero.

And now we have truly random gradients.

The specific amount of rotation isn't that
important, as we can scale how much we want

to displace the height of the bricks by adding
a Math node to the gradients themselves and

multiplying the intensity of the effect.

Finally, let's move these nodes over, so that
we can add our rotation gradient onto the

brick height map.

Now if we look at the output, and increase
the rotation intensity, we see the gradients

show up on some of the bricks.

Now, if we switch to Cycles, and look at the
final output, setting the rotation intensity

to a high value, like ten, really shows the
effect.

But let's set it to a more sensible value,
like five.

Note that because we are doing this before
we combine the bricks with the mortar, the

mortar respects the brick rotation, and the
ends of the bricks that are rotated into the

wall, get buried in the mortar, which is a
pretty nice effect.

But maybe we're seeing a bit to much of this
happening all over the place, so let's compensate

by reducing the subtraction that we added
in the last chapter, so that our bricks move

back out of the wall a bit.

Now we still have the mortar over the bricks,
but it's a bit more balanced.

Now the only thing left to do, is renaming
the Frame, as it's not just about the depth

anymore, but also the rotation.