#include <memory>

#include <vector>

using std::make_shared;

class hittable_list : public hittable {

public:

// C++ Std Usings

using std::make_shared;

using std::sqrt;

// Constants

// Common Headers

#include "ray.h"

#include "vec3.h"

this assumption in mind.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ delete

#include <iostream>

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

[Listing [assume-rtw-color]: <kbd>[color.h]</kbd> Assume rtweekend.h in color.h]

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ delete

using std::make_shared;

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

[Listing [assume-rtw-hittable-list]: <kbd>[hittable_list.h]</kbd>

Assume rtweekend.h in hittable_list.h

#include "rtweekend.h"

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++

#include "color.h"

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight

#include "hittable.h"

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++

// Common Headers

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ Highlight

#include "interval.h"

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++

color ray_color(const ray& r, const hittable& world) {

hit_record rec;

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight

auto a = 0.5*(unit_direction.y() + 1.0);

return (1.0-a)*color(1.0, 1.0, 1.0) + a*color(0.5, 0.7, 1.0);

}

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

[Listing [main-with-interval]: <kbd>[main.cc]</kbd> The new main using interval]

#include "rtweekend.h"

#include "hittable.h"

class camera {

...

color ray_color(const ray& r, const hittable& world) const {

hit_record rec;

if (world.hit(r, interval(0, infinity), rec)) {

vec3 unit_direction = unit_vector(r.direction());

auto a = 0.5*(unit_direction.y() + 1.0);

return (1.0-a)*color(1.0, 1.0, 1.0) + a*color(0.5, 0.7, 1.0);

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++

};

#endif

migrated code:

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++

class camera {

public:

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight

<div class='together'>

And here's the much reduced main:

#include "rtweekend.h"

#include "camera.h"

#include "hittable_list.h"

#include "sphere.h"

int main() {

hittable_list world;

world.add(make_shared<sphere>(point3(0,0,-1), 0.5));

cam.image_width = 400;

cam.render(world);

}

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

[Listing [main-with-new-camera]: <kbd>[main.cc]</kbd> The new main, using the new camera]

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ Highlight

#include <cstdlib>

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++

#include <limits>

#include <memory>

...

Here's the updated `write_color()` function that incorporates the interval clamping function:

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++

void write_color(std::ostream& out, const color& pixel_color) {

auto r = pixel_color.x();

auto g = pixel_color.y();

double pixel_samples_scale; // Color scale factor for a sum of pixel samples

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++

point3 center; // Camera center

void initialize() {

image_height = int(image_width / aspect_ratio);

}

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++

};

#endif

that will be defined later. Since we're just specifying a pointer to the class, the compiler doesn't

need to know the details of the class, solving the circular reference issue.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight

class material;

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++

class sphere : public hittable {

public:

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++

bool hit(const ray& r, interval ray_t, hit_record& rec) const override {

We'll need to use the C++ standard library function `std::fabs`, which returns the absolute value of

its input. We'll add this to `rtweekend.h` since we'll use this in several future locations.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++

// C++ Std Usings

using std::shared_ptr;

using std::sqrt;

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++

class vec3 {

...

#include "rtweekend.h"

#include "hittable.h"

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight

#include "material.h"

</div>

A Scene with Metal Spheres

---------------------------

#include "rtweekend.h"

#include "camera.h"

#include "hittable_list.h"

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight

#include "material.h"

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++

auto material_ground = make_shared<lambertian>(color(0.8, 0.8, 0.0));

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight

auto material_left = make_shared<dielectric>(1.5);

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++

auto material_right = make_shared<metal>(color(0.8, 0.6, 0.2), 1.0);

bool cannot_refract = ri * sin_theta > 1.0;

vec3 direction;

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight

if (cannot_refract || reflectance(cos_theta, ri) > random_double())

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++

}

ray get_ray(int i, int j) const {

// Construct a camera ray originating from the defocus disk and directed at a randomly

// sampled point around the pixel location i, j.

auto offset = sample_square();

auto pixel_sample = pixel00_loc

#include "bvh.h"

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++

#include "camera.h"

#include "hittable_list.h"

#include "material.h"

#include "sphere.h"

If we add this to our main scene:

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++

#include "bvh.h"

#include "camera.h"

#include "hittable_list.h"

#include "material.h"

#include "sphere.h"

#include "bvh.h"

#include "camera.h"

#include "hittable_list.h"

#include "material.h"

#include "sphere.h"

#include "bvh.h"

#include "camera.h"

#include "hittable_list.h"

#include "material.h"

#include "sphere.h"

#include "rtweekend.h"

#include "camera.h"

#include "hittable_list.h"

#include "material.h"

#include "quad.h"