Vector Operations: Add, Subtract, and Scalar Multiply

What is a Vector?

At its core, a vector is a quantity that has both magnitude (length or size) and direction. Think about giving someone directions: "walk 100 meters north." You've just described a vector.

In game development, we use vectors to represent several key properties:

• Position: Where an object is in the world (e.g., (x, y, z) coordinates).
• Velocity: How an object's position is changing over time (e.g., moving 2 meters per second along the x-axis).
• Direction: Which way an object is facing or moving, independent of its speed.

To get a practical sense of this, let's start with a short article that frames vectors in the context of games.

As the article explains, a vector is mathematically just a list of numbers, which we call components. For 2D graphics, we use two components [x, y], and for 3D, we use three: [x, y, z]. Each component represents a signed displacement along its corresponding axis.

A crucial concept is that a vector itself does not have a position. It only describes a displacement. Imagine an arrow floating in space. Its length and the direction it points are what matter, not where its tail is located. This is why the same vector, say [3, 5, 2], can represent the velocity of a spaceship or the displacement from your character to a treasure chest.

To dig a bit deeper into this distinction, the following reading offers a more formal definition.

Core Vector Operations

Now that we have a solid idea of what vectors are, let's learn how to manipulate them. These operations are simple component-wise calculations, but their geometric interpretations are what make them so powerful.

The following video gives a fantastic, quick overview of these operations with game-centric examples.

Let's break down each operation with its rule, geometric meaning, and a key application.

1. Vector Addition

• The Rule: To add two vectors, add their corresponding components.

  $$\mathbf{a}+\mathbf{b}=\left[\begin{array}{c}{a}_x\\ a_y\\ a_z\end{array}\right]+\left[\begin{array}{c}{b}_x\\ b_y\\ b_z\end{array}\right]=\left[\begin{array}{c}{a}_x+b_x\\ a_y+b_y\\ a_z+b_z\end{array}\right]$$

• Geometric Interpretation: Geometrically, this is the "head-to-tail" rule. If you place the tail of vector $\mathbf{b}$ at the head of vector $\mathbf{a}$, the resulting vector $\mathbf{a}+\mathbf{b}$ goes from the tail of $\mathbf{a}$ to the head of $\mathbf{b}$.

• Key Application: Movement. This is the foundation of all movement in a game. Each frame, you update an object's position by adding its velocity vector (scaled by the time elapsed).
  new_position = current_position + velocity

The Wolfire Games blog post has a perfect illustration of this.

2. Vector Subtraction

• The Rule: To subtract two vectors, subtract their corresponding components. $$\mathbf{a}-\mathbf{b}=\left[\begin{array}{c}{a}_x\\ a_y\\ a_z\end{array}\right]-\left[\begin{array}{c}{b}_x\\ b_y\\ b_z\end{array}\right]=\left[\begin{array}{c}{a}_x-b_x\\ a_y-b_y\\ a_z-b_z\end{array}\right]$$ This is equivalent to adding the negation of a vector: $\mathbf{a}+(-\mathbf{b})$. A negated vector has the same magnitude but points in the opposite direction.

• Geometric Interpretation: The vector $\mathbf{a}-\mathbf{b}$ is the vector that points from the tip of $\mathbf{b}$ to the tip of $\mathbf{a}$.

• Key Application: Finding Direction. This is extremely useful. If you have the position of the player and an enemy, how do you make the enemy face the player? You subtract the positions!
  direction_to_player = player_position - enemy_position

3. Scalar-Vector Multiplication

A scalar is just a regular number (like 5, -0.5, or $\pi$).

• The Rule: To multiply a vector by a scalar, multiply each component of the vector by that scalar.

  $$s\mathbf{v}=s\left[\begin{array}{c}{v}_x\\ v_y\\ v_z\end{array}\right]=\left[\begin{array}{c}s\cdot v_x\\ s\cdot v_y\\ s\cdot v_z\end{array}\right]$$

• Geometric Interpretation: Multiplying by a scalar s scales the vector's magnitude (length) by a factor of |s|. If s is negative, it also reverses the vector's direction.

• Key Application: Controlling Speed and Scale. If you have a direction vector (which we'll see later is a vector of length 1), you can multiply it by a scalar speed to get a velocity vector. You can also use it to scale an object or apply forces like friction.
  velocity = direction * speed

Implementing Vectors in C

This is all great in theory, but how do we use this in our C code? In Module 1, you learned about structs for creating custom data types. A struct is the perfect tool for representing a vector.

For a 3D vector, we could define it like this:

typedef struct {
    float x;
    float y;
    float z;
} Vec3;

We typically use float for vector components because graphics hardware is highly optimized for floating-point math.

To perform our operations, we would write simple functions that take Vec3 structs as arguments and return a new Vec3 struct.

// Adds two vectors and returns the result
Vec3 vec3_add(Vec3 a, Vec3 b) {
    Vec3 result = { a.x + b.x, a.y + b.y, a.z + b.z };
    return result;
}

// Subtracts vector b from vector a and returns the result
Vec3 vec3_subtract(Vec3 a, Vec3 b) {
    Vec3 result = { a.x - b.x, a.y - b.y, a.z - b.z };
    return result;
}

// Multiplies a vector by a scalar and returns the result
Vec3 vec3_scale(Vec3 v, float scalar) {
    Vec3 result = { v.x * scalar, v.y * scalar, v.z * scalar };
    return result;
}

This is a practical application of the C skills you've just learned. We are creating a simple math library that we will build upon throughout this course.

In other languages like C++ (which you may have seen in some online tutorials), these functions are often implemented using "operator overloading," allowing for a more natural syntax like Vec3 c = a + b;. While C doesn't support this, our function-based approach is just as powerful and clear.

To see one more perspective on these concepts, you can watch the start of the following video.

Conclusion

In this lesson, we took our first step into the world of 3D mathematics. We've established a firm understanding of what vectors are and how to manipulate them with the most fundamental operations.

Key Takeaways:

• A vector is a quantity with magnitude and direction, represented as a list of components (e.g., [x, y, z]).
• In games, vectors define position, velocity, and direction.
• Vector addition (a + b) combines displacements and is used for movement.
• Vector subtraction (a - b) finds the vector that points from the tip of b to the tip of a, essential for calculating directions between objects.
• Scalar multiplication (s * v) changes a vector's length (and potentially reverses its direction), used for adjusting speed, force, and scale.
• In C, we can represent vectors with structs and implement these operations as simple functions.

These three operations are the bedrock upon which we will build everything else. Make sure you are comfortable with them, as we will use them in almost every future lesson.

In our next lesson, we will explore two new, and incredibly powerful, types of vector multiplication: the dot product and the cross product. These will allow us to answer more complex geometric questions and are essential for lighting, collision detection, and much more.