Camera Control: Mapping Pixels to Viewport

Introduction: From Pixels to a 3D Viewport

So far, our rays have been somewhat arbitrarily defined. To create a proper camera, we need a precise model. Imagine a simple pinhole camera. Light from the scene passes through a tiny aperture and projects an inverted image onto a film plane behind it.

In ray tracing, we simulate this process in reverse. We cast rays from the pinhole (our camera's position) out into the world, passing through a virtual "screen" or "viewport" that represents our final image. Our main task is to determine the exact 3D direction for the ray that corresponds to each pixel on our 2D screen.

For a great visual introduction to this concept, take a few minutes to watch the following clip.

The Geometry of a Simple Viewport

To start, we'll define a simple, fixed camera located at the origin (0, 0, 0) and looking along the negative Z-axis. This is a common convention in graphics. The viewport is a rectangular plane positioned in front of the camera at a certain distance, known as the focal length.

Here are the key parameters we need to define our viewport:

1. Image Dimensions: The width and height of our output image in pixels (e.g., 400x225).
2. Aspect Ratio: The ratio of the image width to its height. For an image of 1920x1080, the aspect ratio is 1920 / 1080 = 16.0 / 9.0.
3. Viewport Dimensions: The dimensions of the virtual screen in world-space units. We can set the height arbitrarily (e.g., viewport_height = 2.0), and then derive the width from the aspect ratio: viewport_width = viewport_height * aspect_ratio.
4. Focal Length: The distance from the camera center to the viewport plane. For now, we'll use a focal_length of 1.0.

Calculating Pixel Locations in 3D Space

With these parameters, we can compute the 3D world coordinate for the center of any pixel. Since you have a strong background in linear algebra, you'll appreciate this vector-based approach.

1. Establish Viewport Basis Vectors: We need vectors that describe the viewport's orientation and scale. For our simple camera looking down the Z-axis:

   • A vector across the horizontal edge of the viewport: viewport_u = vec3(viewport_width, 0, 0).
   • A vector down the vertical edge of the viewport: viewport_v = vec3(0, -viewport_height, 0). (We use a negative Y because our pixel coordinates typically start from the top-left corner, so j increases downwards).

2. Calculate Pixel-to-Pixel Spacing: We can find the world-space distance between adjacent pixel centers by dividing the total viewport vectors by the image dimensions:

   • Horizontal step per pixel: pixel_delta_u = viewport_u / image_width.
   • Vertical step per pixel: pixel_delta_v = viewport_v / image_height.

3. Find the First Pixel's Location: The final piece is a starting point. We can calculate the location of the center of the top-left pixel (0,0).

   • First, find the location of the viewport's upper-left corner: viewport_upper_left = camera_center - vec3(0, 0, focal_length) - viewport_u/2 - viewport_v/2. This starts at the camera, moves to the viewport plane, and then shifts to the top-left edge.
   • Then, find the center of the first pixel by moving half a pixel's width and height from that corner: pixel00_loc = viewport_upper_left + 0.5 * (pixel_delta_u + pixel_delta_v).

4. Putting it all together: To find the center of any pixel (i, j), we start at the first pixel's center and step across and down:

   $${\text{pixel\_center}}_{(i,j)}=\text{pixel00\_loc}+(i\times \text{pixel\_delta\_u})+(j\times \text{pixel\_delta\_v})$$

Once you have the pixel_center in world space, the ray direction is simply the vector from the camera's center to this point: ray_direction = pixel_center - camera_center.

The Ray Tracing in One Weekend book provides an excellent, clear implementation of exactly this logic.

By implementing this, you will have created your first simple, but geometrically correct, camera! Your main function will now contain the core logic for a camera, which we will refactor into its own class in a future lesson.

An Alternative View: Coordinate Space Transformations

The vector-based method we just covered is very direct. Another common approach in computer graphics, which you might encounter in shader programming or other rendering contexts, is to think of this as a series of coordinate space transformations.

This method involves these steps:

1. Raster Space to NDC Space: Convert pixel coordinates (i, j) from their integer range to a normalized [0, 1] range. This is called Normalized Device Coordinates (NDC).

   $$\begin{array}{rl}u& =\frac{i+0.5}{\text{image\_width}}\\ v& =\frac{j+0.5}{\text{image\_height}}\end{array}$$

   The + 0.5 is to find the center of the pixel.

2. NDC Space to Screen Space: Remap the [0, 1] range to [-1, 1], which is more convenient for a centered viewport. The Y-coordinate is also flipped because NDC's origin is usually top-left, while screen space's origin is at the center.

   $$\begin{array}{rl}x& =(2u-1)\times \text{aspect\_ratio}\\ y& =1-2v\end{array}$$

   The aspect ratio correction ensures the pixels aren't stretched.

3. Screen Space to World Space: With our simple camera, this (x, y) coordinate now lies on a plane at z = -1 (one focal length unit away). The 3D point is (x, y, -1). If the camera were positioned and rotated elsewhere, you would apply a camera-to-world transformation matrix here.

You don't need to implement this second method now, but it's valuable to know it exists as it's a fundamental concept in 3D graphics pipelines. For a deeper dive on this, the "Generating Camera Rays" article on Scratchapixel is an excellent resource.

Conclusion

In this lesson, you've taken the first and most critical step in building a flexible camera system. You now understand the geometry that connects the 2D grid of pixels in your final image to a 3D viewport in your scene.

Key Takeaways:

• A ray tracing camera works by casting rays from an origin point through a virtual viewport positioned in the 3D scene.
• The core task is to map each 2D pixel coordinate (i, j) to a 3D world-space coordinate on this viewport.
• Using vector arithmetic, we can define the viewport's dimensions and orientation, calculate pixel-to-pixel stepping vectors (pixel_delta_u, pixel_delta_v), and compute the precise center of any given pixel.
• The final ray direction is the vector from the camera's center to the calculated pixel center on the viewport.

Next Steps

Now that we have a solid, albeit fixed, camera foundation, the next step is to make it movable. In the next lesson, we will tackle the learning outcome: Compute camera orientation basis vectors (u, v, w) from look-from, look-at, and view-up parameters. This will allow you to place your camera anywhere in the scene and point it at any object, giving you true directorial control.