Add background color to restOfYourLife

hollasch · hollasch · commit a82bb45b1885 · 2020-01-22T12:13:57.000-08:00
In addition, I've renamed the `light_shape` parameter to `lights`.
diff --git a/books/RayTracingTheRestOfYourLife.html b/books/RayTracingTheRestOfYourLife.html
@@ -848,7 +848,7 @@
 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, const vec3& background, hittable& world, int depth) {
         hit_record rec;
 
         // If we've exceeded the ray bounce limit, no more light is gathered.
@@ -857,7 +857,7 @@
 
         // If the ray hits nothing, return the background color.
         if (!world.hit(r, 0.001, infinity, rec))
-            return vec3(0,0,0);
+            return background;
 
         ray scattered;
         vec3 attenuation;
@@ -872,7 +872,7 @@
 
         return emitted
              + albedo * rec.mat_ptr->scattering_pdf(r, rec, scattered)
-                      * ray_color(scattered, world, depth-1) / pdf;
+                      * ray_color(scattered, background, world, depth-1) / pdf;
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -1306,7 +1306,7 @@
 that math and get the concept, we can add it (see the highlighted region):
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-    vec3 ray_color(const ray& r, hittable& world, int depth) {
+    vec3 ray_color(const ray& r, const vec3& background, hittable& world, int depth) {
         hit_record rec;
 
         // If we've exceeded the ray bounce limit, no more light is gathered.
@@ -1315,7 +1315,7 @@
 
         // If the ray hits nothing, return the background color.
         if (!world.hit(r, 0.001, infinity, rec))
-            return vec3(0,0,0);
+            return background;
 
         ray scattered;
         vec3 attenuation;
@@ -1345,7 +1345,7 @@
 
         return emitted
              + albedo * rec.mat_ptr->scattering_pdf(r, rec, scattered)
-                      * ray_color(scattered, world, depth-1) / pdf;
+                      * ray_color(scattered, background, world, depth-1) / pdf;
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     [Listing [ray-color-lights]: <kbd>[main.cc]</kbd> Ray color with light sampling]
@@ -1477,7 +1477,7 @@
 change variable `pdf` to some other variable name to avoid a name conflict with the new `pdf` class.
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-    vec3 ray_color(const ray& r, hittable& world, int depth) {
+    vec3 ray_color(const ray& r, const vec3& background, hittable& world, int depth) {
         hit_record rec;
 
         // If we've exceeded the ray bounce limit, no more light is gathered.
@@ -1486,7 +1486,7 @@
 
         // If the ray hits nothing, return the background color.
         if (!world.hit(r, 0.001, infinity, rec))
-            return vec3(0,0,0);
+            return background;
 
         ray scattered;
         vec3 attenuation;
@@ -1504,7 +1504,7 @@
 
         return emitted
              + albedo * rec.mat_ptr->scattering_pdf(r, rec, scattered)
-                      * ray_color(scattered, world, depth-1)
+                      * ray_color(scattered, background, world, depth-1)
                       / pdf_val;
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -1612,7 +1612,7 @@
 And then change `ray_color()`:
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-    vec3 ray_color(const ray& r, hittable& world, int depth) {
+    vec3 ray_color(const ray& r, const vec3& background, hittable& world, int depth) {
         hit_record rec;
 
         // If we've exceeded the ray bounce limit, no more light is gathered.
@@ -1621,7 +1621,7 @@
 
         // If the ray hits nothing, return the background color.
         if (!world.hit(r, 0.001, infinity, rec))
-            return vec3(0,0,0);
+            return background;
 
         ray scattered;
         vec3 attenuation;
@@ -1642,7 +1642,7 @@
 
         return emitted
              + albedo * rec.mat_ptr->scattering_pdf(r, rec, scattered)
-                      * ray_color(scattered, world, depth-1)
+                      * ray_color(scattered, background, world, depth-1)
                       / pdf_val;
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -1690,7 +1690,13 @@
 And plugging it into `ray_color()`:
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
-    vec3 ray_color(const ray& r, hittable& world, shared_ptr<hittable> light_shape, int depth) {
+    vec3 ray_color(
+        const ray& r,
+        const vec3& background,
+        hittable& world,
+        shared_ptr<hittable> lights,
+        int depth
+    ) {
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
         hit_record rec;
 
@@ -1700,7 +1706,7 @@
 
         // If the ray hits nothing, return the background color.
         if (!world.hit(r, 0.001, infinity, rec))
-            return vec3(0,0,0);
+            return background;
 
         ray scattered;
         vec3 attenuation;
@@ -1724,7 +1730,7 @@
 
         return emitted
              + albedo * rec.mat_ptr->scattering_pdf(r, rec, scattered)
-                      * ray_color(scattered, world, depth-1)
+                      * ray_color(scattered, background, world, lights, depth-1)
                       / pdf_val;
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -1884,7 +1890,13 @@
 And `ray_color()` changes are small:
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-    vec3 ray_color(const ray& r, hittable& world, shared_ptr<hittable> light_shape, int depth) {
+    vec3 ray_color(
+        const ray& r,
+        const vec3& background,
+        hittable& world,
+        shared_ptr<hittable> lights,
+        int depth
+    ) {
         hit_record rec;
 
         // If we've exceeded the ray bounce limit, no more light is gathered.
@@ -1893,23 +1905,23 @@
 
         // If the ray hits nothing, return the background color.
         if (!world.hit(r, 0.001, infinity, rec))
-            return vec3(0,0,0);
+            return background;
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
         scatter_record srec;
         vec3 emitted = rec.mat_ptr->emitted(r, rec, rec.u, rec.v, rec.p);
         if (!rec.mat_ptr->scatter(r, rec, srec))
             return emitted;
 
-        auto light_ptr = make_shared<hittable_pdf>(light_shape, rec.p);
+        auto light_ptr = make_shared<hittable_pdf>(lights, rec.p);
         mixture_pdf p(light_ptr, srec.pdf_ptr);
 
         ray scattered = ray(rec.p, p.generate(), r.time());
         auto pdf_val = p.value(scattered.direction());
 
         return emitted
             + srec.attenuation * rec.mat_ptr->scattering_pdf(r, rec, scattered)
-                               * ray_color(scattered, world, light_shape, depth-1)
+                               * ray_color(scattered, background, world, lights, depth-1)
                                / pdf_val;
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     }
@@ -1954,7 +1966,13 @@
 `ray_color()` just needs a new case to generate an implicitly sampled ray:
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-    vec3 ray_color(const ray& r, hittable& world, shared_ptr<hittable> light_shape, int depth) {
+    vec3 ray_color(
+        const ray& r,
+        const vec3& background,
+        hittable& world,
+        shared_ptr<hittable> lights,
+        int depth
+    ) {
         hit_record rec;
 
         // If we've exceeded the ray bounce limit, no more light is gathered.
@@ -1963,7 +1981,7 @@
 
         // If the ray hits nothing, return the background color.
         if (!world.hit(r, 0.001, infinity, rec))
-            return vec3(0,0,0);
+            return background;
 
         scatter_record srec;
         vec3 emitted = rec.mat_ptr->emitted(r, rec, rec.u, rec.v, rec.p);
@@ -1973,11 +1991,11 @@
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
         if (srec.is_specular) {
             return srec.attenuation
-                 * ray_color(srec.specular_ray, world, light_shape, depth-1);
+                 * ray_color(srec.specular_ray, background, world, lights, depth-1);
         }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
 
-        shared_ptr<pdf> light_ptr = make_shared<hittable_pdf>(light_shape, rec.p);
+        shared_ptr<pdf> light_ptr = make_shared<hittable_pdf>(lights, rec.p);
         mixture_pdf p(light_ptr, srec.pdf_ptr);
 
         ray scattered = ray(rec.p, p.generate(), r.time());
@@ -1986,7 +2004,7 @@
 
         return emitted + srec.attenuation
                        * rec.mat_ptr->scattering_pdf(r, rec, scattered)
-                       * ray_color(scattered, world, light_shape, depth-1)
+                       * ray_color(scattered, background, world, lights, depth-1)
                        / pdf_val;
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -2174,7 +2192,7 @@
                 auto u = (i + random_double()) / image_width;
                 auto v = (j + random_double()) / image_height;
                 ray r = cam->get_ray(u, v);
-                col += ray_color(r, world, glass_sphere, max_depth);
+                col += ray_color(r, background, world, glass_sphere, max_depth);
             }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     [Listing [sampling-sphere]: <kbd>[main.cc]</kbd> Sampling just the sphere]
diff --git a/src/TheRestOfYourLife/main.cc b/src/TheRestOfYourLife/main.cc
@@ -19,7 +19,13 @@
 #include <iostream>
 
 
-vec3 ray_color(const ray& r, hittable& world, shared_ptr<hittable> light_shape, int depth) {
+vec3 ray_color(
+    const ray& r,
+    const vec3& background,
+    hittable& world,
+    shared_ptr<hittable> lights,
+    int depth
+) {
     hit_record rec;
 
     // If we've exceeded the ray bounce limit, no more light is gathered.
@@ -28,7 +34,7 @@ vec3 ray_color(const ray& r, hittable& world, shared_ptr<hittable> light_shape,
 
     // If the ray hits nothing, return the background color.
     if (!world.hit(r, 0.001, infinity, rec))
-        return vec3(0,1,1);
+        return background;
 
     scatter_record srec;
     vec3 emitted = rec.mat_ptr->emitted(r, rec, rec.u, rec.v, rec.p);
@@ -37,17 +43,18 @@ vec3 ray_color(const ray& r, hittable& world, shared_ptr<hittable> light_shape,
         return emitted;
 
     if (srec.is_specular) {
-        return srec.attenuation * ray_color(srec.specular_ray, world, light_shape, depth-1);
+        return srec.attenuation
+             * ray_color(srec.specular_ray, background, world, lights, depth-1);
     }
 
-    auto light_ptr = make_shared<hittable_pdf>(light_shape, rec.p);
+    auto light_ptr = make_shared<hittable_pdf>(lights, rec.p);
     mixture_pdf p(light_ptr, srec.pdf_ptr);
     ray scattered = ray(rec.p, p.generate(), r.time());
     auto pdf_val = p.value(scattered.direction());
 
     return emitted
          + srec.attenuation * rec.mat_ptr->scattering_pdf(r, rec, scattered)
-                            * ray_color(scattered, world, light_shape, depth-1)
+                            * ray_color(scattered, background, world, lights, depth-1)
                             / pdf_val;
 }
 
@@ -99,6 +106,8 @@ int main() {
 
     std::cout << "P3\n" << image_width << ' ' << image_height << "\n255\n";
 
+    vec3 background(0,0,0);
+
     camera cam;
     auto world = cornell_box(cam, aspect_ratio);
 
@@ -114,7 +123,7 @@ int main() {
                 auto u = (i + random_double()) / image_width;
                 auto v = (j + random_double()) / image_height;
                 ray r = cam.get_ray(u, v);
-                color += ray_color(r, world, lights, max_depth);
+                color += ray_color(r, background, world, lights, max_depth);
             }
             color.write_color(std::cout, samples_per_pixel);
         }
