All language subtitles for VectorMathBasics

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.