Original subtitles

The Vector Math node allows us to do several operations with vectors.

Most of the operations are identical to the ones found in the Math node, and are just

performed on each channel independently.

These operations can be identified by the fact that they will have the same name as

the corresponding operation from the Math node.

The tool-tip will also generally tell you that the operation is performed entry-wise.

These operations basically provide a more optimal way to perform operations that we

would otherwise have to do with a Math node for each channel independently, by separating

and then rejoining the channels.

Unfortunately, not all operations from the Math node are available in the Vector Math

node, so sometimes we will still have to resort to this kind of inconvenient solution.

We already covered some of these operations for the Math node, so we won't be looking

at most of them again, as they are identical, except that they are applied to each channel.

But it's worth highlighting some useful things.

Notably, the Addition operation is identical to the Location parameter of the Vector Mapping

node in Point mode.

Meanwhile Subtraction, being reversed, corresponds to the Location in Texture mode.

These are the actual operations that the Mapping node is performing under the hood.

This is useful to know, for when we just want to move some coordinates around, without any

need for scaling or rotation, because then we can just use a Vector Math node, which

will keep things simpler, and save us some operations.

Similarly, multiplication and division also correspond to a mapping operation.

Namely scaling.

Multiplication is the operation for scaling in point mode, and division corresponds to

scaling in texture mode.

Unfortunately, rotation is a bit more complicated, and doesn't have a corresponding vector math

operation, though there is a vector rotation node, for when we just want to rotate vectors

without other transformations.

Other than the entry-wise math operations, the Vector Math node also has some vector-specific

operations.

Some of these are very useful when doing more advanced stuff with vectors, but we'll only

need a couple of the more basic operations.

The Scale operation is very convenient when we want to scale vectors uniformly in all

axes.

It works exactly like a Multiplication where all three axes are multiplied by the same

value, so this doesn't add any functionality that we didn't already get from the Multiply

mode, but it just adds convenience in many situations.

And lastly, the Length operation, calculates the length or magnitude of vectors.

When feeding it a texture coordinate, it corresponds to the distance from the origin, which is

a spherical gradient.

This is very useful for making round elements, and works similarly to the spherical gradient

from the gradient node, except that the vector length has the advantage of outputting an

infinite, unbounded gradient, while the gradient node has an output that is clamped between

zero and one.