Original subtitles

Coordinate spaces are the foundation of any procedural texture, so it's important to understand

what they represent, and how to work with them.

Let's quickly review coordinates in Blender.

An object has a position defined by a vector.

This vector is the position of the object's origin, as indicated by the orange dot.

Moving the object around changes these coordinates.

Remember that the coordinates represent how far along each axis a point is, in this case

the object's origin.

Now, if we switch to edit mode, and select a single vertex, we can see it's coordinate

as well.

And now, if we look at the same object motion from before, we see that the vertex's coordinates

don't change.

That's because the vertex coordinates are given in the object's own local coordinate

space, rather than the world's coordinate space.

While the origin of the world is where the X and Y axis lines intersect, the object's

coordinate space is based around the object's own origin.

It also has its own axis directions and unit lengths, defined by the object's rotation

and scale.

We can visualize this by enabling the axis display in the object properties.

Now if we rotate and scale the object, we can see the axis directions, and the unit

size for each axis, indicated by the axis length.

This understanding of how coordinates can exist in different spaces, already takes us

most of the way to understanding coordinate spaces for material nodes.

Let's take a look at what we get from the coordinate space inputs in the node editor.

When we render an object, we are working with each individual ray hitting that object, so

let's look at an example.

Here we have a point on the object, and when we take the coordinates, Blender gives us

the X, Y, and Z values for the vector spanning from the coordinate space's origin to our

point.

Now we have the coordinates, and they are ready to use.

Often, we want to visualize them, so if we plug the vector into a color socket, the XYZ

coordinates get mapped to RGB, and we see the resulting color.

Now we have a color that represents the coordinates of that point.

If we repeat that with every ray hitting the object, we get the coordinates for every point

on the surface, which we can also visualize as colors.

Note that the colors are a limited representation of the underlying coordinate vectors, for

instance, on the lower left of the object we can see a big section that is completely

black, but all those points on the surface don't have a coordinate of zero.

Rather, those are points where the coordinates are below zero in all three axes, and negative

numbers can't really be displayed as colors, so we get a render result that is clipped

to zero.

But the actual vectors do contain the negative values, and we can work with them just fine.

Even the colors in the shader carry the actual negative values, as there is no conversion

between vectors and colors, the only limitation is that they get clipped in the final render

output, so we can't visualize them in this way.

There are a few different coordinate spaces, so let's take a look at some of the most common

ones.

Firstly, there is the Position output from the Geometry node.

While we can't find this output on the Texture Coordinate node, it is probably the most fundamental

coordinate space.

The Position coordinates are based on the scene's global coordinate space.

So the origin of this space is the origin of the scene, and the axes are aligned with

the scene axes.

This means that if we transform the object, the coordinates stay put and the object moves

through the coordinate space.

This is useful whenever we need the global coordinates, but is rarely useful for animated

objects, as the textures will shift on the surface as the object moves.

Next, let's look at the Object coordinates.

Initially, these look the same as the Position, however, the Object coordinates are aligned

to the object's transformations, just like the coordinates of the vertices in edit mode.

This difference is clear when we transform the object.

Here we see that the coordinates move along with the object.

These coordinates are probably the most useful for procedural texturing, as they stick with

the object.

And unlike the next coordinates we'll look at, Object coordinates keep the proportions

of the axes based on the object scale, so it doesn't cause texture stretching.

Lastly, we'll look at the Generated coordinates.

These are also aligned to the object's axes, just like the Object coordinates.

However, they don't care about the Object's origin, or scale.

The origin of the Generated coordinate space is set to the front-bottom-left corner of

the object's bounding box, so that corner has a value of zero in all axes.

And one unit in the coordinate space is defined as the size of the bounding box, in each axis.

This means that the rear-top-right corner of the bounding box always has a value of

one in all axes.

And as a result, all the coordinates on the object are within a zero to one range.

Keep in mind that this means that the coordinate space will have the same proportions as the

object, which means there will be texture stretching if the bounding box is not a perfect

cube.

This coordinate space is useful whenever we want to make a texture that follows the object's

proportions, or when we are texturing an object that has deforming animations such as with

an armature or shape keys, we'll look at why in a moment.

It's important to know that we can transform coordinates.

The easiest way to do that, is with a Vector Mapping node.

This node allows us to translate, rotate, and scale the coordinates.

If we change the location values, we can see the coordinates moving in each axis.

When doing this, you might notice the coordinates moving backwards from what you'd expect.

That's because when the Mapping node transforms a coordinate to be further along an axis,

the point stays in place, but outputs the coordinates of a point further along the axis,

which makes the coordinate space as a whole move backwards.

But most of the time, we want to transform the actual texture on the surface of the object,

so the mapping node has a Texture mode, which inverts all the transformations, to make it

more intuitive to work with textures.

And now we can see how the location, rotation, and scale all transform the coordinates in

the way we would expect.

These transformations are very useful to move textures around, and they also allow us to

transform some coordinate spaces into other coordinate spaces.

Note that there are also some other ways to transform coordinates, which we'll cover throughout

the course.

Keep in mind that we're not transforming the actual underlying coordinates.

For instance, if we rotate the coordinates on a plane, it's not rotating the underlying

coordinates, or the texture around some pivot point, but rather calculating a rotated version

of each individual vector around the (0,0) point.

So if we feed a constant vector into the mapping, we're looking at a single solid color.

Rotating this might seem nonsensical, as there appears to be nothing to rotate.

But if we do rotate it, we see that the color changes everywhere.

That's because, again, it's not rotating the texture we're looking at, rather, at each

point, it's rotating the vector around the (0,0) point, which doesn't have to be an actual

point somewhere in the scene.

What's happening is more clear if we plot it on a Cartesian plane.

We were inputting a vector with a value of 0.8 on X and 0.3 on Y.

We can see that vector plotted here.

On the left, I also placed three bars showing the values of X, Y, and Z, though Z is irrelevant

here, as we're dealing with 2D coordinates only.

And all the way at the left, the square shows the color we get by mapping XYZ to RGB.

Now, when we rotate the vector, it's rotated around the (0,0) point.

And then we see how the X and Y vector coordinates are changing, and how this is represented

as a color.

This is the same thing that's happening with the vector at every point on the plane, no

matter if it's a coordinate from an input node, or if it's a constant vector.

In this next example, there is a node group that is tiling the Object coordinates from

before.

At this point it's not relevant this works, we just know that this node tiles whatever

coordinates you feed it.

Now, after tiling, we have this mapping node.

If we use it to rotate the coordinates, each tile rotates individually.

Each of the repeated values will generate the same result, because each vector is being

rotated individually, and it goes back to the fact that given the same inputs, a node

always gives the same outputs, and the fact that nodes don't have any awareness of what's

around, and also can't change the result of an earlier node.

After the tiling is computed, it's fixed, and nothing that happens afterwards can change

it.

If we wanted to rotate the whole thing in one piece, we'd put the mapping before the

tiling, that way the coordinates get rotated, and then tiled.

The order of operations is really important.

In many pixel based applications, you can transform the result of one operation with

another operation, and that's because the application can actually transform the pixels

themselves, but here, we're working with rays in a 3D scene, and we cannot access the results

of other rays.

This does mean that some operations can seem backwards, and incidentally, this is also

why there is no blur node, despite popular request, it's simply not possible, or at least

not in any remotely efficient way.

There is still one thing that's important to know about the different coordinate spaces.

I mentioned earlier that Generated coordinates are useful when we want to texture objects

with deforming animations.

The reason is that if we look at Object coordinates on a deforming object, we see that the coordinates

stay in place, and the mesh moves through the coordinates as it deforms.

Now here, we have Generated coordinates, that I transformed to match the Object coordinates.

This time, the coordinates deform with the object.

That's because the Generated coordinates are computed on the mesh before any shape keys

or deform modifiers are applied.

This is very useful when we want a texture to stick to a deforming object.

We can see that really well if we feed the coordinates into a Noise Texture.

With the Object coordinates the object moves through the texture.

But with the Generated coordinates, the texture sticks to the surface and deforms with it.

And that's a general overview of what texture coordinates are, how the different coordinate

spaces work, and some basic vector transformations.