Update theRestOfYourLife book new hittable_list

Author: hollasch

books/RayTracingTheRestOfYourLife.html

@@ -728,33 +728,43 @@
 our Cornell Box scene again, and let’s generate the camera in the function that generates the model:
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-    void cornell_box(hittable **scene, camera **cam, double aspect) {
-        material *red = new lambertian( new constant_texture(vec3(0.65, 0.05, 0.05)) );
-        material *white = new lambertian( new constant_texture(vec3(0.73, 0.73, 0.73)) );
-        material *green = new lambertian( new constant_texture(vec3(0.12, 0.45, 0.15)) );
-        material *light = new diffuse_light( new constant_texture(vec3(15, 15, 15)) );
-
-        hittable **list = new hittable*[8];
-        int i = 0;
-        list[i++] = new flip_normals(new yz_rect(0, 555, 0, 555, 555, green));
-        list[i++] = new yz_rect(0, 555, 0, 555, 0, red);
-        list[i++] = new xz_rect(213, 343, 227, 332, 554, light);
-        list[i++] = new flip_normals(new xz_rect(0, 555, 0, 555, 555, white));
-        list[i++] = new xz_rect(0, 555, 0, 555, 0, white);
-        list[i++] = new flip_normals(new xy_rect(0, 555, 0, 555, 555, white));
-        list[i++] = new translate(new rotate_y(
-            new box(vec3(0, 0, 0), vec3(165, 165, 165), white), -18), vec3(130,0,65));
-        list[i++] = new translate(new rotate_y(
-            new box(vec3(0, 0, 0), vec3(165, 330, 165), white),  15), vec3(265,0,295));
-        *scene = new hittable_list(list,i);
+    hittable_list cornell_box(camera& cam, double aspect) {
+        hittable_list world;
+
+        auto *red   = new lambertian(new constant_texture(vec3(0.65, 0.05, 0.05)));
+        auto *white = new lambertian(new constant_texture(vec3(0.73, 0.73, 0.73)));
+        auto *green = new lambertian(new constant_texture(vec3(0.12, 0.45, 0.15)));
+        auto *light = new diffuse_light(new constant_texture(vec3(15, 15, 15)));
+
+        world.add(new flip_normals(new yz_rect(0, 555, 0, 555, 555, green)));
+        world.add(new yz_rect(0, 555, 0, 555, 0, red));
+        world.add(new xz_rect(213, 343, 227, 332, 554, light));
+        world.add(new flip_normals(new xz_rect(0, 555, 0, 555, 555, white)));
+        world.add(new xz_rect(0, 555, 0, 555, 0, white));
+        world.add(new flip_normals(new xy_rect(0, 555, 0, 555, 555, white)));
+
+        hittable* box1 = new box(vec3(0,0,0), vec3(165,330,165), white);
+        box1 = new rotate_y(box1, 15);
+        box1 = new translate(box1, vec3(265,0,295));
+        world.add(box1);
+
+        hittable* box2 = new box(vec3(0,0,0), vec3(165,165,165), white);
+        box2 = new rotate_y(box2, -18);
+        box2 = new translate(box2, vec3(130,0,65);
+        world.add(box2);
 
         vec3 lookfrom(278, 278, -800);
         vec3 lookat(278, 278, 0);
+        vec3 up(0, 1, 0);
         auto dist_to_focus = 10.0;
         auto aperture = 0.0;
         auto vfov = 40.0;
-        *cam = new camera(
-            lookfrom, lookat, vec3(0,1,0), vfov, aspect, aperture, dist_to_focus, 0.0, 1.0);
+        auto t0 = 0.0;
+        auto t1 = 1.0;
+
+        cam = camera(lookfrom, lookat, up, vfov, aspect, aperture, dist_to_focus, t0, t1);
+
+        return world;
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     [Listing [cornell-box]: <kbd>[main.cc]</kbd> Cornell box, refactored]
@@ -837,14 +847,22 @@
 And the color function gets a minor modification:
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 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 (depth <= 0 || !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);
+
+        // If the ray hits nothing, return the background color.
+        if (!world.hit(r, 0.001, infinity, rec))
             return vec3(0,0,0);
 
         ray scattered;
         vec3 attenuation;
         vec3 emitted = rec.mat_ptr->emitted(rec.u, rec.v, rec.p);
+
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
         double pdf;
         vec3 albedo;
 
@@ -854,6 +872,7 @@
         return emitted
              + albedo * rec.mat_ptr->scattering_pdf(r, rec, scattered)
                       * ray_color(scattered, world, depth-1) / pdf;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     [Listing [ray-color-impsample]: <kbd>[main.cc]</kbd>
@@ -1284,7 +1303,13 @@
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     vec3 ray_color(const ray& r, hittable *world, int depth) {
         hit_record rec;
-        if (depth <= 0 || !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);
+
+        // If the ray hits nothing, return the background color.
+        if (!world.hit(r, 0.001, infinity, rec))
             return vec3(0,0,0);
 
         ray scattered;
@@ -1445,7 +1470,13 @@
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     vec3 ray_color(const ray& r, hittable *world, int depth) {
         hit_record rec;
-        if (depth <= 0 || !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);
+
+        // If the ray hits nothing, return the background color.
+        if (!world.hit(r, 0.001, infinity, rec))
             return vec3(0,0,0);
 
         ray scattered;
@@ -1564,7 +1595,13 @@
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     vec3 ray_color(const ray& r, hittable *world, int depth) {
         hit_record rec;
-        if (depth <= 0 || !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);
+
+        // If the ray hits nothing, return the background color.
+        if (!world.hit(r, 0.001, infinity, rec))
             return vec3(0,0,0);
 
         ray scattered;
@@ -1630,7 +1667,13 @@
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     vec3 ray_color(const ray& r, hittable *world, hittable *light_shape, int depth) {
         hit_record rec;
-        if (depth <= 0 || !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);
+
+        // If the ray hits nothing, return the background color.
+        if (!world.hit(r, 0.001, infinity, rec))
             return vec3(0,0,0);
 
         ray scattered;
@@ -1813,9 +1856,14 @@
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     vec3 ray_color(const ray& r, hittable *world, hittable *light_shape, int depth) {
         hit_record rec;
-        if (depth <= 0 || !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);
 
+        // If the ray hits nothing, return the background color.
+        if (!world.hit(r, 0.001, infinity, rec))
+            return vec3(0,0,0);
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
         scatter_record srec;
@@ -1876,7 +1924,13 @@
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     vec3 ray_color(const ray& r, hittable *world, hittable *light_shape, int depth) {
         hit_record rec;
-        if (depth <= 0 || !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);
+
+        // If the ray hits nothing, return the background color.
+        if (!world.hit(r, 0.001, infinity, rec))
             return vec3(0,0,0);
 
         scatter_record srec;
@@ -1910,37 +1964,46 @@
 We also need to change the block to metal.
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-    void cornell_box(hittable **scene, camera **cam, double aspect) {
-        int i = 0;
-        hittable **list = new hittable*[8];
-        material *red = new lambertian( new constant_texture(vec3(0.65, 0.05, 0.05)) );
-        material *white = new lambertian( new constant_texture(vec3(0.73, 0.73, 0.73)) );
-        material *green = new lambertian( new constant_texture(vec3(0.12, 0.45, 0.15)) );
-        material *light = new diffuse_light( new constant_texture(vec3(15, 15, 15)) );
-        list[i++] = new flip_normals(new yz_rect(0, 555, 0, 555, 555, green));
-        list[i++] = new yz_rect(0, 555, 0, 555, 0, red);
-        list[i++] = new flip_normals(new xz_rect(213, 343, 227, 332, 554, light));
-        list[i++] = new flip_normals(new xz_rect(0, 555, 0, 555, 555, white));
-        list[i++] = new xz_rect(0, 555, 0, 555, 0, white);
-        list[i++] = new flip_normals(new xy_rect(0, 555, 0, 555, 555, white));
-        list[i++] = new translate(
-            new rotate_y(new box(vec3(0, 0, 0), vec3(165, 165, 165), white),  -18),
-            vec3(130,0,65));
+    hittable_list cornell_box(camera& cam, double aspect) {
+        hittable_list world;
+
+        auto *red   = new lambertian(new constant_texture(vec3(0.65, 0.05, 0.05)));
+        auto *white = new lambertian(new constant_texture(vec3(0.73, 0.73, 0.73)));
+        auto *green = new lambertian(new constant_texture(vec3(0.12, 0.45, 0.15)));
+        auto *light = new diffuse_light(new constant_texture(vec3(15, 15, 15)));
+
+        world.add(new flip_normals(new yz_rect(0, 555, 0, 555, 555, green)));
+        world.add(new yz_rect(0, 555, 0, 555, 0, red));
+        world.add(new xz_rect(213, 343, 227, 332, 554, light));
+        world.add(new flip_normals(new xz_rect(0, 555, 0, 555, 555, white)));
+        world.add(new xz_rect(0, 555, 0, 555, 0, white));
+        world.add(new flip_normals(new xy_rect(0, 555, 0, 555, 555, white)));
+
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
         material *aluminum = new metal(vec3(0.8, 0.85, 0.88), 0.0);
-        list[i++] = new translate(
-            new rotate_y(new box(vec3(0, 0, 0), vec3(165, 330, 165), aluminum),  15),
-            vec3(265,0,295));
+        hittable* box1 = new box(vec3(0,0,0), vec3(165,330,165), aluminum);
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-        *scene = new hittable_list(list,i);
+        box1 = new rotate_y(box1, 15);
+        box1 = new translate(box1, vec3(265,0,295));
+        world.add(box1);
+
+        hittable* box2 = new box(vec3(0,0,0), vec3(165,165,165), white);
+        box2 = new rotate_y(box2, -18);
+        box2 = new translate(box2, vec3(130,0,65);
+        world.add(box2);
 
         vec3 lookfrom(278, 278, -800);
-        vec3 lookat(278,278,0);
+        vec3 lookat(278, 278, 0);
+        vec3 up(0, 1, 0);
         auto dist_to_focus = 10.0;
         auto aperture = 0.0;
         auto vfov = 40.0;
-        *cam = new camera(
-            lookfrom, lookat, vec3(0,1,0), vfov, aspect, aperture, dist_to_focus, 0.0, 1.0);
+        auto t0 = 0.0;
+        auto t1 = 1.0;
+
+        cam = camera(lookfrom, lookat, up, vfov, aspect, aperture, dist_to_focus, t0, t1);
+
+        return world;
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     [Listing [scene-cornell-al]: <kbd>[main.cc]</kbd> Cornell box scene with aluminum material]
@@ -2100,31 +2163,31 @@
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     double hittable_list::pdf_value(const vec3& o, const vec3& v) const {
-        auto weight = 1.0/list_size;
+        auto weight = 1.0/objects.size();
         auto sum = 0.0;
-        for (int i = 0; i < list_size; i++)
-            sum += weight*list[i]->pdf_value(o, v);
+
+        for (auto object : objects)
+            sum += weight * object->pdf_value(o, v);
+
         return sum;
     }
 
     vec3 hittable_list::random(const vec3& o) const {
-        int index = random_int(0, list_size-1);
-        return list[ index ]->random(o);
+        auto int_size = static_cast<int>(objects.size());
+        auto index = static_cast<size_t>(random_int(0, int_size-1));
+        return objects[index]->random(o);
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     [Listing [density-mixture]: <kbd>[hittable_list.h]</kbd> Creating a mixture of densities]
 </div>
 
 <div class='together'>
-We assemble a list to pass in to `ray_color()`.
+We assemble a list to pass to `ray_color()` `from main()`:
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-    hittable *light_shape = new xz_rect(213, 343, 227, 332, 554, 0);
-    hittable *glass_sphere = new sphere(vec3(190, 90, 190), 90, 0);
-    hittable *a[2];
-    a[0] = light_shape;
-    a[1] = glass_sphere;
-    hittable_list hlist(a,2);
+    hittable_list lights;
+    lights.add(new xz_rect(213, 343, 227, 332, 554, 0));
+    lights.add(new sphere(vec3(190, 90, 190), 90, 0));
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     [Listing [scene-density-mixture]: <kbd>[main.cc]</kbd> Updating the scene]
 </div>