Generating Uniform Random Numbers with `std::random`

Why Not rand()?

If you've encountered random numbers in C or older C++ before, you might have seen the rand() function. While simple to use, it's generally avoided in modern C++ for several reasons:

• Low-Quality Randomness: The quality of the random numbers produced by rand() can be poor, sometimes showing predictable patterns.
• Global State: rand() relies on a hidden global state, which can cause issues in complex or multi-threaded applications.
• Limited Control: It's difficult to manage different random streams or use different types of distributions (e.g., normal vs. uniform).

For these reasons, the C++11 standard introduced the <random> library, which gives us a much more powerful, flexible, and high-quality system.

The Modern C++ Approach: The <random> Library

The modern C++ approach involves three key components working together. Understanding this separation of concerns is key to using the library effectively.

Let's break down these three components:

1. The Seeder (std::random_device): This is our source of high-quality, non-deterministic randomness. It typically asks the operating system for a truly random number based on entropy sources (like mouse movements or network packet timings). It's great for seeding, but it can be slow, so we only use it to get things started.

2. The Engine (std::mt19937): This is a fast pseudo-random number generator (PRNG). You give it an initial seed, and it produces a long sequence of numbers that appear random. A popular and high-quality engine is the Mersenne Twister, available as std::mt19937. A crucial feature is that for the same seed, it will always produce the same sequence of numbers. This is fantastic for debugging!

3. The Distribution (std::uniform_real_distribution): The engine produces raw, uniformly distributed integer values over a huge range. This is rarely what we want directly. A distribution object takes a number from the engine and maps it to a range and shape that we care about. For anti-aliasing, we'll need random floating-point numbers between 0.0 and 1.0, which is exactly what std::uniform_real_distribution is for.

This combination gives us the best of both worlds: a high-quality initial seed from std::random_device and a fast, reproducible stream of numbers from the engine, shaped to our exact needs by the distribution.

Seeing it in Action

Let's watch a couple of short videos that demonstrate how to put these pieces together in code.

Now, let's see how to generate the floating-point numbers we'll actually need for our ray tracer.

#include <iostream>
#include <random>

int main() {
    std::random_device rd;
    std::mt19937 generator(rd());
    std::uniform_real_distribution<double> distribution(0.0, 1.0);

    for (int i = 0; i < 5; ++i) {
        std::cout << distribution(generator) << std::endl;
    }
}

#include <iostream>
#include <random>

int main() {
    std::random_device rd;
    std::mt19937 generator(rd());
    // Change is on this line:
    std::uniform_int_distribution<int> distribution(1, 6);

    for (int i = 0; i < 5; ++i) {
        std::cout << distribution(generator) << std::endl;
    }
}

Integrating Random Numbers into Our Project

Now, let's adopt the approach from our main guide, the Ray Tracing in One Weekend series. The book provides a convenient helper function that encapsulates this logic, which we can add to a shared header file.

Following this guide, we'll create a common utility header (let's call it rtweekend.h, as the book does) and place our random number functions there.

Here is the code you should add. This structure is very common and effective.

// In a new header file, e.g., "rtweekend.h"

#ifndef RTWEEKEND_H
#define RTWEEKEND_H

#include <cmath>
#include <limits>
#include <memory>
#include <random> // Add this include

// Constants
const double infinity = std::numeric_limits<double>::infinity();
const double pi = 3.1415926535897932385;

// Utility Functions
inline double degrees_to_radians(double degrees) {
    return degrees * pi / 180.0;
}

// NEW RANDOM NUMBER UTILITY
inline double random_double() {
    static std::uniform_real_distribution<double> distribution(0.0, 1.0);
    static std::mt19937 generator;
    return distribution(generator);
}

inline double random_double(double min, double max) {
    // Returns a random real in [min,max).
    return min + (max - min) * random_double();
}

// Common Headers (we will add to this file as we go)
#include "ray.h"
#include "vec3.h"

#endif

A quick note on the static keyword here: using static inside the function ensures that the distribution and generator objects are created only once, the very first time random_double() is called. On all subsequent calls, the same objects are reused. This is much more efficient than re-creating them every time. Notice that the generator is default-constructed, which means it will be seeded with a default value. For a given run of the program, it will produce the same sequence of "random" numbers, which is perfect for debugging and getting consistent renders.

Conclusion

You've now learned the modern, robust way to generate random numbers in C++. This is a fundamental skill that goes far beyond ray tracing, but it's the specific tool we need to solve the problem of aliasing.

Key Takeaways:

• The modern C++ <random> library is preferred over the old C-style rand().
• It works by combining three components:
  1. A Seeder (std::random_device) for true randomness.
  2. An Engine (std::mt19937) for fast pseudo-random number generation.
  3. A Distribution (std::uniform_real_distribution) to shape the output to our desired range (e.g., [0.0, 1.0)).
• We've created a reusable random_double() helper function that encapsulates this logic, making it easy to use throughout our project.

Next Steps

With our random number generator ready, we have everything we need to tackle aliasing. In the next lesson, we will finally implement multi-sample anti-aliasing. You'll modify your main render loop to cast multiple, randomly jittered rays for each pixel and average their colors. The visual improvement will be dramatic and deeply satisfying.