Merge development changes (hitvect.2) onto normals_and_dielectrics

Author: trevordblack

books/RayTracingInOneWeekend.html

@@ -618,8 +618,7 @@
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
         if (discriminant < 0) {
             return -1.0;
-        }
-        else {
+        } else {
             return (-b - sqrt(discriminant) ) / (2.0*a);
         }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
@@ -684,8 +683,7 @@
 
     if (discriminant < 0) {
         return -1.0;
-    }
-    else {
+    } else {
         return (-half_b - sqrt(discriminant) ) / a;
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -938,27 +936,35 @@
     #define HITTABLE_LIST_H
 
     #include "hittable.h"
+    #include <vector>
 
     class hittable_list: public hittable {
         public:
             hittable_list() {}
-            hittable_list(hittable **l, int n) {list = l; list_size = n; }
+            hittable_list(hittable* object) { add(object); }
+
+            void clear()               { objects.clear(); }
+            void add(hittable* object) { objects.push_back(object); }
+
             virtual bool hit(const ray& r, double tmin, double tmax, hit_record& rec) const;
-            hittable **list;
-            int list_size;
+
+        public:
+            std::vector<hittable*> objects;
     };
 
     bool hittable_list::hit(const ray& r, double t_min, double t_max, hit_record& rec) const {
         hit_record temp_rec;
         bool hit_anything = false;
-        double closest_so_far = t_max;
-        for (int i = 0; i < list_size; i++) {
-            if (list[i]->hit(r, t_min, closest_so_far, temp_rec)) {
+        auto closest_so_far = t_max;
+
+        for (auto object : objects) {
+            if (object->hit(r, t_min, closest_so_far, temp_rec)) {
                 hit_anything = true;
                 closest_so_far = temp_rec.t;
                 rec = temp_rec;
             }
         }
+
         return hit_anything;
     }
 
@@ -967,6 +973,11 @@
     [Listing [hittable-list-initial]: <kbd>[hittable_list.h]</kbd> The hittable_list class]
 </div>
 
+If you're unfamiliar with C++'s `std::vector`, this is a generic array-like collection of an
+arbitrary type. Above, we use a collection of pointers to `hittable`. `std::vector` automatically
+grows as more values are added: `objects.push_back(object)` adds a value to the end of the
+`std::vector` member variable `objects`.
+
 <div class='together'></div>
 We need some math constants that we conveniently define in their own header file. For now we only
 need infinity, but we will also throw our own definition of pi in there, which we will need later.
@@ -1022,10 +1033,10 @@
     #include <iostream>
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
-    vec3 ray_color(const ray& r, hittable *world) {
+    vec3 ray_color(const ray& r, hittable& world) {
         hit_record rec;
-        if (world->hit(r, 0.0, infinity, rec)) {
-            return 0.5*vec3(rec.normal.x()+1, rec.normal.y()+1, rec.normal.z()+1);
+        if (world.hit(r, 0.0, infinity, rec)) {
+            return 0.5 * (rec.normal + vec3(1,1,1));
         }
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
@@ -1039,18 +1050,19 @@
     int main() {
         int nx = 200;
         int ny = 100;
+
         std::cout << "P3\n" << nx << ' ' << ny << "\n255\n";
+
         vec3 lower_left_corner(-2.0, -1.0, -1.0);
         vec3 horizontal(4.0, 0.0, 0.0);
         vec3 vertical(0.0, 2.0, 0.0);
         vec3 origin(0.0, 0.0, 0.0);
 
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
-        hittable *list[2];
-        list[0] = new sphere(vec3(0,0,-1), 0.5);
-        list[1] = new sphere(vec3(0,-100.5,-1), 100);
-        hittable *world = new hittable_list(list,2);
+        hittable_list world;
+        world.add(new sphere(vec3(0,0,-1), 0.5));
+        world.add(new sphere(vec3(0,-100.5,-1), 100));
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
 
         for (int j = ny-1; j >= 0; --j) {
@@ -1223,12 +1235,12 @@
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
         int num_samples = 100;
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
+
         std::cout << "P3\n" << nx << " " << ny << "\n255\n";
 
-        hittable *list[2];
-        list[0] = new sphere(vec3(0,0,-1), 0.5);
-        list[1] = new sphere(vec3(0,-100.5,-1), 100);
-        hittable *world = new hittable_list(list,2);
+        hittable_list world;
+        world.add(new sphere(vec3(0,0,-1), 0.5));
+        world.add(new sphere(vec3(0,-100.5,-1), 100));
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
         camera cam;
@@ -1342,9 +1354,9 @@
 Then update the `ray_color()` function to use the new random direction generator:
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-    vec3 ray_color(const ray& r, hittable *world) {
+    vec3 ray_color(const ray& r, hittable& world) {
         hit_record rec;
-        if (world->hit(r, 0.0, infinity, rec)) {
+        if (world.hit(r, 0.0, infinity, rec)) {
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
             vec3 target = rec.p + rec.normal + random_in_unit_sphere();
             return 0.5 * ray_color(ray(rec.p, target - rec.p), world);
@@ -1366,9 +1378,10 @@
 depth, returning no light contribution at the maximum depth:
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
-    vec3 ray_color(const ray& r, hittable *world, int depth) {
+    vec3 ray_color(const ray& r, hittable& world, int depth) {
         hit_record rec;
-        if (world->hit(r, 0.0, infinity, rec)) {
+        if (world.hit(r, 0.0, infinity, rec)) {
+            // If we've exceeded the ray bounce limit, no more light is gathered.
             if (depth <= 0)
                 return vec3(0,0,0);
             vec3 target = rec.p + rec.normal + random_in_unit_sphere();
@@ -1388,6 +1401,7 @@
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
         int max_depth = 50;
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
+
         ...
         for (int j = ny-1; j >= 0; --j) {
             std::cerr << "\rScanlines remaining: " << j << ' ' << std::flush;
@@ -1462,7 +1476,7 @@
 point approximation the sphere intersector gives us. So we need to ignore hits very near zero:
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-    if (world->hit(r, 0.001, infinity, rec)) {
+    if (world.hit(r, 0.001, infinity, rec)) {
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     [Listing [reflect-tolerance]: <kbd>[main.cc]</kbd> Calculating reflected ray origins with tolerance]
 
@@ -1503,9 +1517,10 @@
 function.
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-    vec3 ray_color(const ray& r, hittable *world, int depth) {
+    vec3 ray_color(const ray& r, hittable& world, int depth) {
         hit_record rec;
-        if (world->hit(r, 0.0, infinity, rec)) {
+        if (world.hit(r, 0.0, infinity, rec)) {
+            // If we've exceeded the ray bounce limit, no more light is gathered.
             if (depth <= 0)
                 return vec3(0,0,0);
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
@@ -1578,9 +1593,10 @@
 Plugging the new formula into the `ray_color()` function:
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-    vec3 ray_color(const ray& r, hittable *world, int depth) {
+    vec3 ray_color(const ray& r, hittable& world, int depth) {
         hit_record rec;
-        if (world->hit(r, 0.0, infinity, rec)) {
+        if (world.hit(r, 0.0, infinity, rec)) {
+            // If we've exceeded the ray bounce limit, no more light is gathered.
             if (depth <= 0)
                 return vec3(0,0,0);
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
@@ -1826,12 +1842,13 @@
 We need to modify the color function to use this:
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-    vec3 ray_color(const ray& r, hittable *world, int depth) {
+    vec3 ray_color(const ray& r, hittable& world, int depth) {
         hit_record rec;
-        if (world->hit(r, 0.001, infinity, rec)) {
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
+        if (world.hit(r, 0.001, infinity, rec)) {
+            // If we've exceeded the ray bounce limit, no more light is gathered.
             if (depth <= 0)
                 return vec3(0,0,0);
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
             ray scattered;
             vec3 attenuation;
             if (rec.mat_ptr->scatter(r, rec, attenuation, scattered))
@@ -1862,12 +1879,11 @@
 
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
-        hittable *list[4];
-        list[0] = new sphere(vec3(0,0,-1), 0.5, new lambertian(vec3(0.7, 0.3, 0.3)));
-        list[1] = new sphere(vec3(0,-100.5,-1), 100, new lambertian(vec3(0.8, 0.8, 0.0)));
-        list[2] = new sphere(vec3(1,0,-1), 0.5, new metal(vec3(0.8, 0.6, 0.2)));
-        list[3] = new sphere(vec3(-1,0,-1), 0.5, new metal(vec3(0.8, 0.8, 0.8)));
-        hittable *world = new hittable_list(list,4);
+        hittable_list world;
+        world.add(new sphere(vec3(0,0,-1), 0.5, new lambertian(vec3(0.7, 0.3, 0.3))));
+        world.add(new sphere(vec3(0,-100.5,-1), 100, new lambertian(vec3(0.8, 0.8, 0.0))));
+        world.add(new sphere(vec3(1,0,-1), 0.5, new metal(vec3(0.8, 0.6, 0.2))));
+        world.add(new sphere(vec3(-1,0,-1), 0.5, new metal(vec3(0.8, 0.8, 0.8))));
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
 
         camera cam;
@@ -2321,9 +2337,9 @@
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     auto R = cos(pi/4);
-    list[0] = new sphere(vec3(-R,0,-1), R, new lambertian(vec3(0, 0, 1)));
-    list[1] = new sphere(vec3( R,0,-1), R, new lambertian(vec3(1, 0, 0)));
-    hittable *world = new hittable_list(list,2);
+    hittable_list world;
+    world.add(new sphere(vec3(-R,0,-1), R, new lambertian(vec3(0, 0, 1))));
+    world.add(new sphere(vec3( R,0,-1), R, new lambertian(vec3(1, 0, 0))));
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     [Listing [scene-wide-angle]: <kbd>[main.cc]</kbd> Scene with wide-angle camera]
 
@@ -2560,38 +2576,45 @@
 First let’s make the image on the cover of this book -- lots of random spheres:
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-    hittable *random_scene() {
-        int n = 500;
-        hittable **list = new hittable*[n+1];
-        list[0] =  new sphere(vec3(0,-1000,0), 1000, new lambertian(vec3(0.5, 0.5, 0.5)));
+    hittable_list random_scene() {
+        hittable_list objects;
+
+        objects.add(new sphere(vec3(0,-1000,0), 1000, new lambertian(vec3(0.5, 0.5, 0.5))));
+
         int i = 1;
         for (int a = -11; a < 11; a++) {
             for (int b = -11; b < 11; b++) {
                 auto choose_mat = random_double();
                 vec3 center(a + 0.9*random_double(), 0.2, b + 0.9*random_double());
-                if ((center-vec3(4,0.2,0)).length() > 0.9) {
+                if ((center - vec3(4, 0.2, 0)).length() > 0.9) {
                     if (choose_mat < 0.8) {
                         // diffuse
                         auto albedo = vec3::random() * vec3::random();
-                        list[i++] = new sphere(center, 0.2, new lambertian(albedo));
+                        objects.add(new sphere(center, 0.2, new lambertian(albedo)));
                     } else if (choose_mat < 0.95) {
                         // metal
                         auto albedo = vec3::random(.5, 1);
                         auto fuzz = random_double(0, .5);
-                        list[i++] = new sphere(center, 0.2, new metal(albedo, fuzz));
+                        objects.add(new sphere(center, 0.2, new metal(albedo, fuzz)));
                     } else {
                         // glass
-                        list[i++] = new sphere(center, 0.2, new dielectric(1.5));
+                        objects.add(new sphere(center, 0.2, new dielectric(1.5)));
                     }
                 }
             }
         }
 
-        list[i++] = new sphere(vec3(0, 1, 0), 1.0, new dielectric(1.5));
-        list[i++] = new sphere(vec3(-4, 1, 0), 1.0, new lambertian(vec3(0.4, 0.2, 0.1)));
-        list[i++] = new sphere(vec3(4, 1, 0), 1.0, new metal(vec3(0.7, 0.6, 0.5), 0.0));
+        objects.add(new sphere(vec3(0, 1, 0), 1.0, new dielectric(1.5)));
+        objects.add(new sphere(vec3(-4, 1, 0), 1.0, new lambertian(vec3(0.4, 0.2, 0.1))));
+        objects.add(new sphere(vec3(4, 1, 0), 1.0, new metal(vec3(0.7, 0.6, 0.5), 0.0)));
 
-        return new hittable_list(list,i);
+        return objects;
+    }
+
+    int main() {
+        ...
+        auto world = random_scene();
+        ...
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     [Listing [scene-final]: <kbd>[main.cc]</kbd> Final scene]