Implementing an AABB Primitive

1. What is an Axis-Aligned Bounding Box?

An Axis-Aligned Bounding Box (AABB) is the simplest type of bounding volume. It's a 3D box whose faces are all parallel to the main coordinate planes (XY, YZ, and XZ).

Because of this alignment, we can define the entire box with just two points: a point3 for the minimum corner coordinates (e.g., the bottom-front-left) and a point3 for the maximum corner coordinates (e.g., the top-back-right).

A sphere perfectly enclosed by its Axis-Aligned Bounding Box. The box is defined by its minimum (p_min) and maximum (p_max) corner points.

While defining it with two points is intuitive, for the intersection logic, it's often more robust to think of an AABB as the intersection of three "slabs." A slab is the infinite space between two parallel planes.

• An x-slab is the space between planes x=x_min and x=x_max.
• A y-slab is the space between y=y_min and y=y_max.
• A z-slab is the space between z=z_min and z=z_max.

The volume where all three of these slabs overlap is our AABB. This "slab" perspective is the key to creating a fast and elegant intersection algorithm.

2. The Ray-AABB Intersection Algorithm: The Slab Test

To determine if a ray hits an AABB, we don't test against its 6 faces or 8 vertices. Instead, we use the slab representation. The logic is simple: A ray intersects an AABB if and only if the t intervals of intersection for all three slabs overlap.

Let's break this down for a single axis, say the x-axis. A ray is defined by P(t) = Q + t*d, where Q is the origin and d is the direction. The x-coordinate at any point t is x(t) = Q_x + t*d_x.

We can find the t values where the ray crosses the two planes of the x-slab (x_0 and x_1):
$t_0=\frac{x_0-Q_x}{d_x}\text{and}{t}_1=\frac{x_1-Q_x}{d_x}$

These two values, t_0 and t_1, form a t-interval [t_min_x, t_max_x] during which the ray is inside the x-slab. We do the same for the y and z slabs to get [t_min_y, t_max_y] and [t_min_z, t_max_z].

The ray hits the box only if these three intervals overlap. The overlapping region is found by taking the latest start time and the earliest end time:

• t_entry = max(t_min_x, t_min_y, t_min_z)
• t_exit = min(t_max_x, t_max_y, t_max_z)

An intersection occurs if the ray enters before it exits, i.e., t_entry < t_exit.

The book Ray Tracing: The Next Week explains this concept very clearly.

3. Implementing the aabb Class

Now let's translate this theory into C++. Our goal is to create a self-contained aabb.h file. Following the approach in Ray Tracing: The Next Week, we will represent the slabs using a small helper class, interval, which simply stores a min and max value.

This reading contains the complete C++ code for our aabb class, including its constructors and the all-important hit method that implements the slab test.

Dissecting the hit Method

The hit method in the provided code is a compact and efficient implementation of the slab test. Let's analyze its key features:

• for (int axis = 0; axis < 3; axis++): It elegantly loops through the x, y, and z axes.
• const double adinv = 1.0 / ray_dir[axis];: It computes the inverse of the ray's direction component once per axis. This is an important optimization, as multiplication is much faster than division.
• auto t0 = (ax.min - ray_orig[axis]) * adinv;: This is the calculation for the first plane intersection.
• if (t0 < t1) { ... } else { ... }: This if/else block cleverly handles rays traveling in both positive and negative directions. If the ray direction for an axis is negative, t0 will be greater than t1. This code correctly identifies the smaller t as the entry and the larger t as the exit from the slab, regardless of direction.
• if (t0 > ray_t.min) ray_t.min = t0;: This is where the overlap is computed. It's equivalent to ray_t.min = max(ray_t.min, slab_t_min).
• if (ray_t.max <= ray_t.min) return false;: If at any point the overall interval becomes inverted (or zero-length), it means the slabs don't overlap, and we can immediately return false. This is a crucial early-out optimization.

4. Making AABBs Useful

An intersection test is only half the story. To build our BVH, we need two more pieces of functionality:

1. A way for every hittable object to report its own bounding box.
2. A way to create a larger bounding box that encloses two smaller ones.

This involves modifying our abstract hittable class and adding a new constructor to our aabb class.

A final, subtle improvement is to ensure that our bounding boxes have a non-zero thickness on all axes. This prevents numerical issues with flat objects like quads or perfectly-aligned triangles. The Ray Tracing: The Next Week text (resource LINK) introduces a pad_to_minimums() function in Section 4 of the AABB chapter for this purpose, which is a good practice to adopt in your own implementation.

Conclusion

In this lesson, we have constructed a complete and robust AABB primitive. You now have a new tool in your ray tracing toolbox, ready for the next stage.

Key Takeaways:

• AABB Representation: An AABB is defined by its minimum and maximum corners, or equivalently, as the intersection of three axis-aligned slabs.
• The Slab Test: This is a highly efficient intersection algorithm that works by checking for an overlap in the ray's t-intervals across the x, y, and z slabs.
• Robust Implementation: A good implementation handles rays traveling in any direction and avoids division-by-zero issues through the properties of floating-point infinity.
• Class Functionality: A useful aabb class needs more than an intersection test. It requires constructors to be created from points, and importantly, from other aabbs, to allow for hierarchical construction.
• Hittable Interface: By adding bounding_box() to the hittable abstract class, we ensure that any object in our scene can report its spatial bounds.

Next Steps

We now have our building blocks. In the next lesson, we will use this aabb primitive to implement the "H" in BVH: the Hierarchy. We'll learn how to take a list of scene objects, recursively partition them, and build the tree structure that will finally give us the massive performance boost we're looking for.