Vectors and the vec3 Class

Introduction: Why Vectors Matter in Ray Tracing

Understanding Vectors: More Than Just Three Numbers

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

The vec3 Class: Structure and Basic Operations

Now let's look at how we implement vectors in C++ with the vec3 class. This class will encapsulate all the functionality we need for working with three-component vectors. Let's start by examining the basic structure of the class:

C++

class vec3 {
public:
    double e[3];

    vec3() : e{0,0,0} {}
    vec3(double e0, double e1, double e2) : e{e0, e1, e2} {}

    double x() const { return e[0]; }
    double y() const { return e[1]; }
    double z() const { return e[2]; }

    double operator[](int i) const { return e[i]; }
    double& operator[](int i) { return e[i]; }
};

class vec3 {
public:
    double e[3];

    vec3() : e{0,0,0} {}
    vec3(double e0, double e1, double e2) : e{e0, e1, e2} {}

    double x() const { return e[0]; }
    double y() const { return e[1]; }
    double z() const { return e[2]; }

    double operator[](int i) const { return e[i]; }
    double& operator[](int i) { return e[i]; }
};

At the heart of the vec3 class is a simple array: double e[3]. This array stores the three components of our vector. We use double (double-precision floating-point numbers) rather than int because vectors in 3D graphics often need to represent fractional values. A direction vector might be (0.707, 0.707, 0), which represents a 45-degree angle. A position might be (1.5, 2.3, 4.7). Using double gives us the precision we need for accurate calculations.

The class provides two constructors. The first, vec3(), is a default constructor that initializes all three components to zero. The syntax e{0,0,0} is called a member initializer list, and it's an efficient way to initialize the array. The second constructor, vec3(double e0, double e1, double e2), lets you create a vector with specific values. For example, vec3(3, 4, 5) creates a vector with components 3, 4, and 5.

The accessor methods x(), y(), and z() provide a convenient way to retrieve individual components. Instead of writing v.e[0], you can write v.x(), which is more readable and makes the intent clearer. The const keyword after these methods indicates they don't modify the vector, which is important for the compiler to enforce correctness.

The class also provides array-style access through the operator[] overload. This lets you write v[0] to get the first component, v[1] for the second, and v[2] for the third. We provide two versions: one that returns a const reference (for reading) and one that returns a non-const reference (for writing). This flexibility is useful when you need to access components by index in a loop.

Now let's look at vector addition, one of the most fundamental operations. When you add two vectors, you add their corresponding components. If you have vectors u = (1, 2, 3) and v = (4, 5, 6), then u + v = (1+4, 2+5, 3+6) = (5, 7, 9). Here's how we implement this:

C++

inline vec3 operator+(const vec3& u, const vec3& v) {
    return vec3(u.e[0]+v.e[0], u.e[1]+v.e[1], u.e[2]+v.e[2]);
}

inline vec3 operator+(const vec3& u, const vec3& v) {
    return vec3(u.e[0]+v.e[0], u.e[1]+v.e[1], u.e[2]+v.e[2]);
}

This is a free function (not a member of the class) that takes two vec3 objects by const reference and returns a new vec3 containing the sum. The inline keyword suggests to the compiler that it should try to insert the function's code directly at the call site rather than making a function call, which can improve performance for small, frequently-called functions.

Geometrically, vector addition represents combining two displacements. If you walk 3 blocks east and 4 blocks north (vector u), then walk 2 more blocks east and 1 block north (vector v), you've walked a total of 5 blocks east and 5 blocks north (vector u + v). In ray tracing, you might add a ray's origin position to its direction scaled by some distance to find where the ray is after traveling that distance.

Scalar multiplication is another essential operation. When you multiply a vector by a scalar (a single number), you scale the vector's magnitude without changing its direction. If you have vector v = (1, 2, 3) and you multiply it by 2, you get 2v = (2, 4, 6). The vector points in the same direction but is twice as long. Here's the implementation:

C++

inline vec3 operator*(double t, const vec3& v) {
    return vec3(t*v.e[0], t*v.e[1], t*v.e[2]);
}

inline vec3 operator*(const vec3& v, double t) { 
    return t * v; 
}

inline vec3 operator*(double t, const vec3& v) {
    return vec3(t*v.e[0], t*v.e[1], t*v.e[2]);
}

inline vec3 operator*(const vec3& v, double t) { 
    return t * v; 
}

We provide two versions of this operator: one for scalar * vector and one for vector * scalar. This way, you can write either 2 * v or v * 2, and both will work. The second version simply calls the first, ensuring consistent behavior.

Let's see these operations in action with a concrete example:

C++

vec3 a(1.0, 2.0, 3.0);
vec3 b(4.0, 5.0, 6.0);

vec3 sum = a + b;           // sum is (5.0, 7.0, 9.0)
vec3 scaled = 2.0 * a;      // scaled is (2.0, 4.0, 6.0)
vec3 combined = a + 3.0 * b; // combined is (13.0, 17.0, 21.0)

vec3 a(1.0, 2.0, 3.0);
vec3 b(4.0, 5.0, 6.0);

vec3 sum = a + b;           // sum is (5.0, 7.0, 9.0)
vec3 scaled = 2.0 * a;      // scaled is (2.0, 4.0, 6.0)
vec3 combined = a + 3.0 * b; // combined is (13.0, 17.0, 21.0)

In the first line, we create vector a with components (1, 2, 3). In the second line, we create vector b with components (4, 5, 6). When we add them, we get (5, 7, 9). When we scale a by 2, we get (2, 4, 6). In the last line, we combine operations: we scale b by 3 to get (12, 15, 18), then add a to get (13, 17, 21).

These basic operations might seem simple, but they're the building blocks for everything we'll do in ray tracing. Every time we calculate where a ray goes, how light bounces off a surface, or what color a pixel should be, we'll be using vector addition and scalar multiplication.

The Dot Product: Measuring Vector Alignment

Beyond addition and scaling, there's another vector operation that's absolutely crucial for ray tracing: the dot product. The dot product takes two vectors and produces a single number (a scalar) that tells you something important about the relationship between those vectors.

The mathematical formula for the dot product is straightforward. If you have vectors u = (u₀, u₁, u₂) and v = (v₀, v₁, v₂), their dot product is u · v = u₀v₀ + u₁v₁ + u₂v₂. You multiply corresponding components and add up the results. Here's the implementation:

C++

inline double dot(const vec3& u, const vec3& v) {
    return u.e[0] * v.e[0]
         + u.e[1] * v.e[1]
         + u.e[2] * v.e[2];
}

inline double dot(const vec3& u, const vec3& v) {
    return u.e[0] * v.e[0]
         + u.e[1] * v.e[1]
         + u.e[2] * v.e[2];
}

This function takes two vectors by const reference and returns a double. It's a simple calculation, but what does it mean geometrically? The dot product measures how much two vectors point in the same direction. Let's explore this with some examples.

Consider two vectors that point in exactly the same direction: u = (1, 0, 0) and v = (2, 0, 0). Both point along the positive x-axis; v is just twice as long. Their dot product is 1*2 + 0*0 + 0*0 = 2. The result is positive, which tells us the vectors point in generally the same direction.

Now consider two vectors that are perpendicular: u = (1, 0, 0) and v = (0, 1, 0). One points along the x-axis, the other along the y-axis. Their dot product is 1*0 + 0*1 + 0*0 = 0. When the dot product is zero, the vectors are perpendicular (orthogonal). This is an incredibly useful property.

Finally, consider two vectors that point in opposite directions: u = (1, 0, 0) and v = (-1, 0, 0). Their dot product is 1*(-1) + 0*0 + 0*0 = -1. A negative dot product tells us the vectors point in generally opposite directions.

More formally, the dot product is related to the angle between vectors by this formula: u · v = |u| |v| cos(θ), where |u| and |v| are the lengths (magnitudes) of the vectors and θ is the angle between them. When the vectors point in the same direction, θ = 0 and cos(0) = 1, giving a maximum positive dot product. When they're perpendicular, θ = 90° and cos(90°) = 0, giving a dot product of zero. When they point in opposite directions, θ = 180° and cos(180°) = -1, giving a negative dot product.

Why is this so important for ray tracing? Consider lighting calculations. When light hits a surface, the brightness depends on the angle between the light direction and the surface normal (the direction perpendicular to the surface). If the light hits straight on (light direction and normal are aligned), the surface is brightest. If the light hits at a glancing angle (light direction and normal are nearly perpendicular), the surface is dimmer. The dot product between the light direction and the surface normal gives us exactly this information.

Here's a concrete example of using the dot product:

C++

vec3 surface_normal(0.0, 1.0, 0.0);  // Points straight up
vec3 light_direction(0.0, -1.0, 0.0); // Points straight down

double alignment = dot(surface_normal, light_direction);
// alignment is -1.0 (vectors point in opposite directions)

vec3 surface_normal(0.0, 1.0, 0.0);  // Points straight up
vec3 light_direction(0.0, -1.0, 0.0); // Points straight down

double alignment = dot(surface_normal, light_direction);
// alignment is -1.0 (vectors point in opposite directions)

In this example, the surface normal points straight up (0, 1, 0) and the light is coming from directly above, so its direction vector points straight down (0, -1, 0). The dot product is -1, which tells us they're pointing in opposite directions. In lighting calculations, we'd typically take the absolute value or clamp negative values to zero, but the dot product gives us the raw information we need.

The dot product also appears in many other ray tracing calculations. When determining if a ray hits a sphere, you use the dot product. When calculating reflections, you use the dot product. When checking if a point is in front of or behind a plane, you use the dot product. It's one of the most frequently used operations in the entire ray tracer.

Another essential vector operation in 3D graphics is the cross product. While the dot product measures how much two vectors point in the same direction, the cross product produces a new vector that is perpendicular (at a right angle) to both input vectors. This is especially useful in ray tracing for calculating surface normals, which are needed for lighting and reflection calculations.

Here is an example, where the blue vector is the result of the cross product between A (red) and B (green)

Mathematically, if you have vectors u = (u₀, u₁, u₂) and v = (v₀, v₁, v₂), their cross product is:

text

u × v = (
    u₁ * v₂ - u₂ * v₁,
    u₂ * v₀ - u₀ * v₂,
    u₀ * v₁ - u₁ * v₀
)

u × v = (
    u₁ * v₂ - u₂ * v₁,
    u₂ * v₀ - u₀ * v₂,
    u₀ * v₁ - u₁ * v₀
)

Here's how we implement the cross product in code:

C++

inline vec3 cross(const vec3& u, const vec3& v) {
    return vec3(
        u.e[1] * v.e[2] - u.e[2] * v.e[1],
        u.e[2] * v.e[0] - u.e[0] * v.e[2],
        u.e[0] * v.e[1] - u.e[1] * v.e[0]
    );
}

inline vec3 cross(const vec3& u, const vec3& v) {
    return vec3(
        u.e[1] * v.e[2] - u.e[2] * v.e[1],
        u.e[2] * v.e[0] - u.e[0] * v.e[2],
        u.e[0] * v.e[1] - u.e[1] * v.e[0]
    );
}

The resulting vector is perpendicular to both u and v, and its length is proportional to the area of the parallelogram formed by the two vectors. In ray tracing, the cross product is often used to compute the normal vector to a surface, which is critical for determining how light interacts with that surface.

For example, if you have two vectors lying on a surface, their cross product gives you the direction that is perpendicular to that surface—exactly what you need for lighting calculations.

In many ray tracing calculations, you need a vector that points in a certain direction but has a length (magnitude) of exactly 1. Such a vector is called a unit vector. Normalizing a vector means scaling it so that its length is 1, while keeping its direction the same.

The length (or magnitude) of a vector v = (x, y, z) is calculated using the Pythagorean theorem:

|v| = sqrt(x*x + y*y + z*z)

|v| = sqrt(x*x + y*y + z*z)

To normalize a vector, you divide each component by its length:

unit_vector = (x/|v|, y/|v|, z/|v|)

unit_vector = (x/|v|, y/|v|, z/|v|)

Here's how we implement this in code:

C++

inline double length(const vec3& v) {
    return std::sqrt(dot(v, v));
}

inline vec3 unit_vector(const vec3& v) {
    return v / length(v);
}

inline double length(const vec3& v) {
    return std::sqrt(dot(v, v));
}

inline vec3 unit_vector(const vec3& v) {
    return v / length(v);
}

The length function computes the magnitude of the vector, and unit_vector returns a new vector pointing in the same direction but with a length of 1. Unit vectors are crucial in ray tracing for representing directions, such as the direction a ray travels or the direction of a surface normal. Using unit vectors ensures that calculations like lighting and reflection behave correctly and consistently.

Dual Purpose: Vectors for Both Geometry and Color

Now we come to one of the most elegant aspects of the vec3 class: it can represent both geometric quantities (positions, directions) and colors (RGB values). This might seem surprising at first, but it makes perfect sense when you think about it mathematically.

Remember from the previous lesson that colors are represented as RGB triplets: three numbers for red, green, and blue. A vector is also three numbers: x, y, and z. Mathematically, they're identical structures. The operations we perform on them are also similar. When you add two colors, you add their components. When you scale a color (to make it brighter or dimmer), you multiply each component by a scalar. These are exactly the same operations we perform on geometric vectors.

To make this dual purpose explicit and to make our code more readable, we use type aliases. At the end of the vec3 header file, you'll see these lines:

C++

using point3 = vec3;  // 3D point
using color  = vec3;  // RGB color

using point3 = vec3;  // 3D point
using color  = vec3;  // RGB color

The using keyword creates an alias: point3 is just another name for vec3, and color is also just another name for vec3. They're all the same type under the hood, but using different names in different contexts makes the code's intent much clearer.

When you write point3 camera_position(0, 0, 0);, it's immediately obvious that you're talking about a position in 3D space. When you write color pixel_color(1.0, 0.0, 0.0);, it's clear you're talking about a red color. Both are vec3 objects, but the names document what they represent.

As we progress through the course, you'll see how powerful this unified approach is. When we calculate lighting, we'll multiply colors by scalars to adjust brightness. When we blend colors, we'll add color vectors together. When we calculate how much light reflects off a surface, we'll use the same vector operations we use for geometric calculations. The vec3 class, with its color and point3 aliases, provides a consistent, elegant foundation for all of these operations.

In this lesson, you learned that vectors are mathematical objects with both magnitude and direction, represented by three components: x, y, and z. The vec3 class in C++ provides a clean way to work with these three-component values, supporting essential operations like addition, scalar multiplication, the dot product (measuring alignment), and the cross product (finding perpendicular vectors). You also saw how to normalize vectors to unit length, which is important for consistent calculations.

Importantly, the same vec3 class can represent both geometric quantities (like positions and directions) and colors (RGB values), thanks to type aliases (point3 and color). This unifies your code and makes it more readable.

You don’t need to memorize every detail now—what matters is understanding how vectors work and why they’re essential for ray tracing. In the next practice exercises, you’ll use the vec3 class hands-on to solidify these concepts. Let's continue building your ray tracer!

Introduction: Why Vectors Matter in Ray Tracing

Understanding Vectors: More Than Just Three Numbers

Join the 1M+ learners on CodeSignal

The vec3 Class: Structure and Basic Operations

The Dot Product: Measuring Vector Alignment

The Cross Product: Finding Perpendicular Vectors

Normalizing Vectors: The unit_vector Function

Dual Purpose: Vectors for Both Geometry and Color

Summary: Your Vector Toolkit for Ray Tracing