Vector Magnitude and Normalization

Vector Magnitude (Length)

A vector in Cartesian coordinates, like (x, y, z), represents a direction and a magnitude simultaneously. The magnitude is simply the vector's length—a scalar value that tells us "how much" displacement the vector represents.

So, how do we calculate it? The process is a direct application of the Pythagorean theorem, which you are likely familiar with from geometry.

• For a 2D vector (x, y), we can imagine a right-angled triangle where the sides have lengths x and y. The hypotenuse is the vector itself, and its length is $\sqrt{x^2+y^2}$.
• In 3D, we just extend this principle. The magnitude of a vector (x, y, z) is $\sqrt{x^2+y^2+z^2}$.

Let's look at a more formal definition and the standard notation.

Calculating Magnitude in C

In C, we can write a function to calculate the magnitude. We'll need the sqrtf function from the standard math library, which you can include with #include <math.h>.

#include <math.h>

// Represents a 3D vector
typedef struct {
    float x, y, z;
} Vec3;

// Calculates the magnitude (length) of a vector
float vec3_len(Vec3 v) {
    return sqrtf(v.x * v.x + v.y * v.y + v.z * v.z);
}

A Quick Optimization Tip: The sqrtf function can be computationally more expensive than simple arithmetic. In many game-related scenarios, we only need to compare lengths (e.g., "is object A closer than object B?"). In these cases, we can compare the squared magnitudes to get the same result without the cost of a square root. It's a common practice to have a function for this.

// Calculates the squared magnitude of a vector
float vec3_len_sq(Vec3 v) {
    return v.x * v.x + v.y * v.y + v.z * v.z;
}

// Example usage:
// if (vec3_len_sq(dist_to_A) < vec3_len_sq(dist_to_B)) {
//     // Object A is closer
// }

Vector Normalization

Now that we can find a vector's length, we can perform normalization. Normalizing a vector means altering it so that its length becomes 1, without changing its direction. The resulting vector is called a unit vector.

Why is this so important? A unit vector is a representation of pure direction. It has a standard "unit" of length, so we can use it in calculations without its magnitude affecting the result.

A classic example in games is handling diagonal movement.

As the video explained, normalization ensures fairness and consistency. We use it for:

• Movement vectors: To ensure constant speed in any direction.
• Surface normals: To define the direction a surface is facing for lighting calculations.
• Directional vectors: For things like camera orientation or the direction of a projectile.

The Normalization Process

The process is simple:

1. Calculate the magnitude of the original vector.
2. Divide each component of the vector by this magnitude.

The formula for normalizing a vector $\mathbf{v}$ to get the unit vector $\hat{\mathbf{v}}$ is:
$\hat{\mathbf{v}}=\frac{\mathbf{v}}{\Vert \mathbf{v}\Vert }=\left(\frac{v_x}{\Vert \mathbf{v}\Vert },\frac{v_y}{\Vert \mathbf{v}\Vert },\frac{v_z}{\Vert \mathbf{v}\Vert }\right)$

Let's get the formal definition from our reference text.

An Important Edge Case: What if we try to normalize the zero vector (0, 0, 0)? Its magnitude is 0, and dividing by zero is an undefined operation that will crash your program. A robust normalization function must check for this. If the magnitude is zero, you should simply return the zero vector.

Normalization in C

Here is a C function that implements normalization, including the check for a zero-length vector.

// Normalizes a vector to have a length of 1
Vec3 vec3_normalize(Vec3 v) {
    float len = vec3_len(v);
    
    // Check for zero length to avoid division by zero
    if (len > 0.0f) {
        float inv_len = 1.0f / len; // Use multiplication instead of division for performance
        return (Vec3){
            .x = v.x * inv_len,
            .y = v.y * inv_len,
            .z = v.z * inv_len
        };
    }
    
    // Return the zero vector if the input was also a zero vector
    return (Vec3){0.0f, 0.0f, 0.0f};
}

Practice

Let's put this into practice. Try to normalize the following vector: $\mathbf{v}=[5,-4,7]$.

Step 1: Calculate the magnitude.
$\Vert \mathbf{v}\Vert =\sqrt{5^2+(-4{)}^2+7^2}=\sqrt{25+16+49}=\sqrt{90}\approx 9.487$

Step 2: Divide each component by the magnitude.
$\hat{\mathbf{v}}=\left(\frac{5}{\sqrt{90}},\frac{-4}{\sqrt{90}},\frac{7}{\sqrt{90}}\right)\approx [0.527,-0.422,0.738]$

As an optional exercise, you can try normalizing the other vectors from Exercise 6 in the 3D Math Primer text (Section 2.15).

Conclusion

Today we've covered two simple but vital concepts. You now have the tools to handle a vector's direction and magnitude independently.

Key Takeaways:

• Vector Magnitude is its length, calculated using the Pythagorean theorem: $\Vert \mathbf{v}\Vert =\sqrt{v_x^2+v_y^2+v_z^2}$.
• Comparing squared magnitudes is often a faster way to compare distances.
• Normalization is the process of scaling a vector to have a magnitude of 1, which creates a unit vector.
• A unit vector represents a pure direction and is fundamental for consistent calculations in movement, lighting, and more.
• Always handle the zero vector case when normalizing to prevent division-by-zero errors.

In our next lesson, we will make a significant jump to a new topic: matrices. You'll learn how to perform matrix-vector and matrix-matrix multiplication. This will lay the groundwork for the next set of lessons, where we will use matrices to perform transformations like translation (moving), rotation, and scaling on our 3D objects.