Updates from book 3 complete progression

Also includes some minor fixes.

Note that this shows the current state of some buggy renders, which
render the entire scene as black, except for the single square light
source.

Resolves #988
Resolves #1317

src/InOneWeekend/color.h

@@ -16,6 +16,7 @@
 
 using color = vec3;
 
+
 inline double linear_to_gamma(double linear_component)
 {
     if (linear_component > 0)
@@ -24,6 +25,7 @@ inline double linear_to_gamma(double linear_component)
     return 0;
 }
 
+
 void write_color(std::ostream& out, const color& pixel_color) {
     auto r = pixel_color.x();
     auto g = pixel_color.y();

src/InOneWeekend/rtweekend.h

@@ -21,11 +21,13 @@
 using std::make_shared;
 using std::shared_ptr;
 
+
 // Constants
 
 const double infinity = std::numeric_limits<double>::infinity();
 const double pi = 3.1415926535897932385;
 
+
 // Utility Functions
 
 inline double degrees_to_radians(double degrees) {
@@ -42,6 +44,7 @@ inline double random_double(double min, double max) {
     return min + (max-min)*random_double();
 }
 
+
 // Common Headers
 
 #include "color.h"

src/TheNextWeek/color.h

@@ -16,6 +16,7 @@
 
 using color = vec3;
 
+
 inline double linear_to_gamma(double linear_component)
 {
     if (linear_component > 0)
@@ -24,6 +25,7 @@ inline double linear_to_gamma(double linear_component)
     return 0;
 }
 
+
 void write_color(std::ostream& out, const color& pixel_color) {
     auto r = pixel_color.x();
     auto g = pixel_color.y();

src/TheNextWeek/quad.h

@@ -14,6 +14,7 @@
 #include "hittable.h"
 #include "hittable_list.h"
 
+
 class quad : public hittable {
   public:
     quad(const point3& Q, const vec3& u, const vec3& v, shared_ptr<material> mat)

src/TheNextWeek/rtweekend.h

@@ -21,11 +21,13 @@
 using std::make_shared;
 using std::shared_ptr;
 
+
 // Constants
 
 const double infinity = std::numeric_limits<double>::infinity();
 const double pi = 3.1415926535897932385;
 
+
 // Utility Functions
 
 inline double degrees_to_radians(double degrees) {
@@ -47,6 +49,7 @@ inline int random_int(int min, int max) {
     return int(random_double(min, max+1));
 }
 
+
 // Common Headers
 
 #include "color.h"

src/TheRestOfYourLife/camera.h

@@ -14,6 +14,7 @@
 #include "rtweekend.h"
 
 #include "hittable.h"
+#include "pdf.h"
 #include "material.h"
 
 
@@ -175,12 +176,13 @@ class camera {
         mixture_pdf p(light_ptr, srec.pdf_ptr);
 
         ray scattered = ray(rec.p, p.generate(), r.time());
-        auto pdf_val = p.value(scattered.direction());
+        auto pdf_value = p.value(scattered.direction());
 
         double scattering_pdf = rec.mat->scattering_pdf(r, rec, scattered);
 
         color sample_color = ray_color(scattered, depth-1, world, lights);
-        color color_from_scatter = (srec.attenuation * scattering_pdf * sample_color) / pdf_val;
+        color color_from_scatter =
+            (srec.attenuation * scattering_pdf * sample_color) / pdf_value;
 
         return color_from_emission + color_from_scatter;
     }

src/TheRestOfYourLife/color.h

@@ -16,6 +16,7 @@
 
 using color = vec3;
 
+
 inline double linear_to_gamma(double linear_component)
 {
     if (linear_component > 0)
@@ -24,6 +25,7 @@ inline double linear_to_gamma(double linear_component)
     return 0;
 }
 
+
 void write_color(std::ostream& out, const color& pixel_color) {
     auto r = pixel_color.x();
     auto g = pixel_color.y();

src/TheRestOfYourLife/cos_cubed.cc

@@ -13,7 +13,7 @@
 
 #include <iostream>
 #include <iomanip>
-#include <math.h>
+
 
 double f(double r2) {
     // auto x = std::cos(2*pi*r1) * 2 * std::sqrt(r2*(1-r2));
@@ -23,10 +23,12 @@ double f(double r2) {
     return cos_theta*cos_theta*cos_theta;
 }
 
+
 double pdf() {
     return 1.0 / (2.0*pi);
 }
 
+
 int main() {
     int N = 1000000;
 

src/TheRestOfYourLife/cos_density.cc

@@ -13,17 +13,19 @@
 
 #include <iostream>
 #include <iomanip>
-#include <math.h>
+
 
 double f(const vec3& d) {
     auto cos_theta = d.z();
     return cos_theta*cos_theta*cos_theta;
 }
 
+
 double pdf(const vec3& d) {
     return d.z() / pi;
 }
 
+
 int main() {
     int N = 1000000;
 

src/TheRestOfYourLife/estimate_halfway.cc

@@ -13,40 +13,42 @@
 #include <vector>
 #include <iostream>
 #include <iomanip>
-#include <math.h>
-#include <cmath>
-#include <stdlib.h>
+
 
 struct sample {
     double x;
     double p_x;
 };
 
+
 bool compare_by_x(const sample& a, const sample& b) {
     return a.x < b.x;
 }
 
+
 int main() {
     unsigned int N = 10000;
     double sum = 0.0;
 
-    // iterate through all of our samples
+    // Iterate through all of our samples.
+
     std::vector<sample> samples;
     for (unsigned int i = 0; i < N; i++) {
-        // Get the area under the curve
+        // Get the area under the curve.
         auto x = random_double(0, 2*pi);
         auto sin_x = std::sin(x);
         auto p_x = exp(-x / (2*pi)) * sin_x * sin_x;
         sum += p_x;
-        // store this sample
+
+        // Store this sample.
         sample this_sample = {x, p_x};
         samples.push_back(this_sample);
     }
 
-    // Sort the samples by x
+    // Sort the samples by x.
     std::sort(samples.begin(), samples.end(), compare_by_x);
 
-    // Find out the sample at which we have half of our area
+    // Find out the sample at which we have half of our area.
     double half_sum = sum / 2.0;
     double halfway_point = 0.0;
     double accum = 0.0;

src/TheRestOfYourLife/integrate_x_sq.cc

@@ -13,26 +13,31 @@
 
 #include <iostream>
 #include <iomanip>
-#include <math.h>
-#include <stdlib.h>
+
 
 double f(double d) {
     return 8.0 * std::pow(d, 1.0/3.0);
 }
 
+
 double pdf(double x) {
-        return (3.0/8.0) * x*x;
+    return (3.0/8.0) * x*x;
 }
 
+
 int main() {
     int N = 1;
-
     auto sum = 0.0;
+
     for (int i = 0; i < N; i++) {
-        auto x = f(random_double());
+        auto z = random_double();
+        if (z == 0.0)  // Ignore zero to avoid NaNs
+            continue;
+
+        auto x = f(z);
         sum += x*x / pdf(x);
     }
 
     std::cout << std::fixed << std::setprecision(12);
-    std::cout << "I = " << sum / N << '\n';
+    std::cout << "I = " << (sum / N) << '\n';
 }

src/TheRestOfYourLife/main.cc

@@ -12,8 +12,6 @@
 #include "rtweekend.h"
 
 #include "camera.h"
-#include "constant_medium.h"
-#include "hittable.h"
 #include "hittable_list.h"
 #include "material.h"
 #include "quad.h"

src/TheRestOfYourLife/onb.h

@@ -13,6 +13,7 @@
 
 #include "rtweekend.h"
 
+
 class onb {
   public:
     onb() {}

src/TheRestOfYourLife/pdf.h

@@ -1,15 +1,5 @@
 #ifndef PDF_H
 #define PDF_H
-//==============================================================================================
-// Originally written in 2016 by Peter Shirley <ptrshrl@gmail.com>
-//
-// To the extent possible under law, the author(s) have dedicated all copyright and related and
-// neighboring rights to this software to the public domain worldwide. This software is
-// distributed without any warranty.
-//
-// You should have received a copy (see file COPYING.txt) of the CC0 Public Domain Dedication
-// along with this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
-//==============================================================================================
 
 #include "rtweekend.h"
 
@@ -26,35 +16,35 @@ class pdf {
 };
 
 
-class cosine_pdf : public pdf {
+class sphere_pdf : public pdf {
   public:
-    cosine_pdf(const vec3& w) { uvw.build_from_w(w); }
+    sphere_pdf() {}
 
     double value(const vec3& direction) const override {
-        auto cosine_theta = dot(unit_vector(direction), uvw.w());
-        return std::fmax(0, cosine_theta/pi);
+        return 1/ (4 * pi);
     }
 
     vec3 generate() const override {
-        return uvw.local(random_cosine_direction());
+        return random_unit_vector();
     }
-
-  private:
-    onb uvw;
 };
 
 
-class sphere_pdf : public pdf {
+class cosine_pdf : public pdf {
   public:
-    sphere_pdf() {}
+    cosine_pdf(const vec3& w) { uvw.build_from_w(w); }
 
     double value(const vec3& direction) const override {
-        return 1/ (4 * pi);
+        auto cosine_theta = dot(unit_vector(direction), uvw.w());
+        return std::fmax(0, cosine_theta/pi);
     }
 
     vec3 generate() const override {
-        return random_unit_vector();
+        return uvw.local(random_cosine_direction());
     }
+
+  private:
+    onb uvw;
 };
 
 

src/TheRestOfYourLife/pi.cc

@@ -13,10 +13,11 @@
 
 #include <iostream>
 #include <iomanip>
-#include <stdlib.h>
 
 
 int main() {
+    std::cout << std::fixed << std::setprecision(12);
+
     int inside_circle = 0;
     int inside_circle_stratified = 0;
     int sqrt_N = 1000;
@@ -25,21 +26,19 @@ int main() {
         for (int j = 0; j < sqrt_N; j++) {
             auto x = random_double(-1,1);
             auto y = random_double(-1,1);
-
             if (x*x + y*y < 1)
                 inside_circle++;
 
             x = 2*((i + random_double()) / sqrt_N) - 1;
             y = 2*((j + random_double()) / sqrt_N) - 1;
-
             if (x*x + y*y < 1)
                 inside_circle_stratified++;
         }
     }
 
-    std::cout << std::fixed << std::setprecision(12);
-    std::cout << "Regular    Estimate of Pi = "
-        << (4.0 * inside_circle) / (sqrt_N*sqrt_N) << '\n';
-    std::cout << "Stratified Estimate of Pi = "
+    std::cout
+        << "Regular    Estimate of Pi = "
+        << (4.0 * inside_circle) / (sqrt_N*sqrt_N) << '\n'
+        << "Stratified Estimate of Pi = "
         << (4.0 * inside_circle_stratified) / (sqrt_N*sqrt_N) << '\n';
 }

src/TheRestOfYourLife/quad.h

@@ -14,6 +14,7 @@
 #include "hittable.h"
 #include "hittable_list.h"
 
+
 class quad : public hittable {
   public:
     quad(const point3& Q, const vec3& u, const vec3& v, shared_ptr<material> mat)