Updates from progression 2024-04-05

hollasch · hollasch · commit 4002df073f87 · 2024-04-07T10:38:39.000-07:00
Some minor fixes, plus lots of reconciliation between book 2, book 2
source, and book 3 source.
diff --git a/books/RayTracingTheNextWeek.html b/books/RayTracingTheNextWeek.html
@@ -355,7 +355,7 @@
         cam.lookat   = point3(0,0,0);
         cam.vup      = vec3(0,1,0);
 
-        cam.defocus_angle = 0.02;
+        cam.defocus_angle = 0.6;
         cam.focus_dist    = 10.0;
 
         cam.render(world);
@@ -713,8 +713,8 @@
     class sphere : public hittable {
       public:
         // Stationary Sphere
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
         sphere(const point3& center, double radius, shared_ptr<material> mat)
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
           : center1(center), radius(fmax(0,radius)), mat(mat), is_moving(false)
         {
             auto rvec = vec3(radius, radius, radius);
@@ -1086,6 +1086,7 @@
     #include "bvh.h"
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     #include "camera.h"
+    #include "hittable.h"
     #include "hittable_list.h"
     #include "material.h"
     #include "sphere.h"
@@ -1251,16 +1252,16 @@
 
     class solid_color : public texture {
       public:
-        solid_color(const color& albedo) : color_value(albedo) {}
+        solid_color(const color& albedo) : albedo(albedo) {}
 
         solid_color(double red, double green, double blue) : solid_color(color(red,green,blue)) {}
 
         color value(double u, double v, const point3& p) const override {
-            return color_value;
+            return albedo;
         }
 
       private:
-        color color_value;
+        color albedo;
     };
 
     #endif
@@ -1403,6 +1404,7 @@
 
     #include "bvh.h"
     #include "camera.h"
+    #include "hittable.h"
     #include "hittable_list.h"
     #include "material.h"
     #include "sphere.h"
@@ -1454,6 +1456,7 @@
 
     #include "bvh.h"
     #include "camera.h"
+    #include "hittable.h"
     #include "hittable_list.h"
     #include "material.h"
     #include "sphere.h"
@@ -1493,6 +1496,7 @@
 
     #include "bvh.h"
     #include "camera.h"
+    #include "hittable.h"
     #include "hittable_list.h"
     #include "material.h"
     #include "sphere.h"
@@ -2020,7 +2024,7 @@
         static int* perlin_generate_perm() {
             auto p = new int[point_count];
 
-            for (int i = 0; i < perlin::point_count; i++)
+            for (int i = 0; i < point_count; i++)
                 p[i] = i;
 
             permute(p, point_count);
@@ -2491,7 +2495,7 @@
             auto weight = 1.0;
 
             for (int i = 0; i < depth; i++) {
-                accum += weight*noise(temp_p);
+                accum += weight * noise(temp_p);
                 weight *= 0.5;
                 temp_p *= 2;
             }
@@ -3126,7 +3130,7 @@
 
     #include "bvh.h"
     #include "camera.h"
-    #include "color.h"
+    #include "hittable.h"
     #include "hittable_list.h"
     #include "material.h"
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
@@ -3679,7 +3683,7 @@
             // Move the ray backwards by the offset
             ray offset_r(r.origin() - offset, r.direction(), r.time());
 
-            // Determine where (if any) an intersection occurs along the offset ray
+            // Determine whether an intersection exists along the offset ray (and if so, where)
             if (!object->hit(offset_r, ray_t, rec))
                 return false;
 
@@ -3869,7 +3873,7 @@
 
             ray rotated_r(origin, direction, r.time());
 
-            // Determine where (if any) an intersection occurs in object space
+            // Determine whether an intersection exists in object space (and if so, where)
             if (!object->hit(rotated_r, ray_t, rec))
                 return false;
 
@@ -4038,12 +4042,14 @@
 
     class constant_medium : public hittable {
       public:
-        constant_medium(shared_ptr<hittable> b, double d, shared_ptr<texture> a)
-          : boundary(b), neg_inv_density(-1/d), phase_function(make_shared<isotropic>(a))
+        constant_medium(shared_ptr<hittable> boundary, double density, shared_ptr<texture> tex)
+          : boundary(boundary), neg_inv_density(-1/density),
+            phase_function(make_shared<isotropic>(tex))
         {}
 
-        constant_medium(shared_ptr<hittable> b, double d, const color& c)
-          : boundary(b), neg_inv_density(-1/d), phase_function(make_shared<isotropic>(c))
+        constant_medium(shared_ptr<hittable> boundary, double density, const color& albedo)
+          : boundary(boundary), neg_inv_density(-1/density),
+            phase_function(make_shared<isotropic>(albedo))
         {}
 
         bool hit(const ray& r, interval ray_t, hit_record& rec) const override {
@@ -4059,7 +4065,7 @@
             if (!boundary->hit(r, interval(rec1.t+0.0001, infinity), rec2))
                 return false;
 
-            if (debugging) std::clog << "\nray_tmin=" << rec1.t << ", ray_tmax=" << rec2.t << '\n';
+            if (debugging) std::clog << "\nt_min=" << rec1.t << ", t_max=" << rec2.t << '\n';
 
             if (rec1.t < ray_t.min) rec1.t = ray_t.min;
             if (rec2.t > ray_t.max) rec2.t = ray_t.max;
@@ -4119,13 +4125,13 @@
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
     class isotropic : public material {
       public:
-        isotropic(const color& c) : tex(make_shared<solid_color>(c)) {}
+        isotropic(const color& albedo) : tex(make_shared<solid_color>(albedo)) {}
         isotropic(shared_ptr<texture> tex) : tex(tex) {}
 
         bool scatter(const ray& r_in, const hit_record& rec, color& attenuation, ray& scattered)
         const override {
-            attenuation = tex->value(rec.u, rec.v, rec.p);
             scattered = ray(rec.p, random_unit_vector(), r_in.time());
+            attenuation = tex->value(rec.u, rec.v, rec.p);
             return true;
         }
 
@@ -4158,10 +4164,10 @@
 
     #include "bvh.h"
     #include "camera.h"
-    #include "color.h"
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
     #include "constant_medium.h"
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
+    #include "hittable.h"
     #include "hittable_list.h"
     #include "material.h"
     #include "quad.h"
diff --git a/src/TheNextWeek/constant_medium.h b/src/TheNextWeek/constant_medium.h
@@ -25,9 +25,9 @@ class constant_medium : public hittable {
         phase_function(make_shared<isotropic>(tex))
     {}
 
-    constant_medium(shared_ptr<hittable> boundary, double density, const color& c)
+    constant_medium(shared_ptr<hittable> boundary, double density, const color& albedo)
       : boundary(boundary), neg_inv_density(-1/density),
-        phase_function(make_shared<isotropic>(c))
+        phase_function(make_shared<isotropic>(albedo))
     {}
 
     bool hit(const ray& r, interval ray_t, hit_record& rec) const override {
diff --git a/src/TheNextWeek/main.cc b/src/TheNextWeek/main.cc
@@ -81,8 +81,8 @@ void bouncing_spheres() {
     cam.lookat   = point3(0,0,0);
     cam.vup      = vec3(0,1,0);
 
-    cam.defocus_angle = 0.02;
-    cam.focus_dist    = 10;
+    cam.defocus_angle = 0.6;
+    cam.focus_dist    = 10.0;
 
     cam.render(world);
 }
diff --git a/src/TheNextWeek/perlin.h b/src/TheNextWeek/perlin.h
@@ -90,7 +90,7 @@ class perlin {
 
     static void permute(int* p, int n) {
         for (int i = n-1; i > 0; i--) {
-            int target = random_int(0,i);
+            int target = random_int(0, i);
             int tmp = p[i];
             p[i] = p[target];
             p[target] = tmp;
@@ -107,9 +107,10 @@ class perlin {
             for (int j=0; j < 2; j++)
                 for (int k=0; k < 2; k++) {
                     vec3 weight_v(u-i, v-j, w-k);
-                    accum += (i*uu + (1-i)*(1-uu))*
-                        (j*vv + (1-j)*(1-vv))*
-                        (k*ww + (1-k)*(1-ww))*dot(c[i][j][k], weight_v);
+                    accum += (i*uu + (1-i)*(1-uu))
+                           * (j*vv + (1-j)*(1-vv))
+                           * (k*ww + (1-k)*(1-ww))
+                           * dot(c[i][j][k], weight_v);
                 }
 
         return accum;
diff --git a/src/TheNextWeek/texture.h b/src/TheNextWeek/texture.h
@@ -29,8 +29,7 @@ class solid_color : public texture {
   public:
     solid_color(const color& albedo) : albedo(albedo) {}
 
-    solid_color(double red, double green, double blue)
-      : solid_color(color(red,green,blue)) {}
+    solid_color(double red, double green, double blue) : solid_color(color(red,green,blue)) {}
 
     color value(double u, double v, const point3& p) const override {
         return albedo;
diff --git a/src/TheRestOfYourLife/camera.h b/src/TheRestOfYourLife/camera.h
@@ -93,7 +93,7 @@ class camera {
         vec3 viewport_u = viewport_width * u;    // Vector across viewport horizontal edge
         vec3 viewport_v = viewport_height * -v;  // Vector down viewport vertical edge
 
-        // Calculate the horizontal and vertical delta vectors to the next pixel.
+        // Calculate the horizontal and vertical delta vectors from pixel to pixel.
         pixel_delta_u = viewport_u / image_width;
         pixel_delta_v = viewport_v / image_height;
 
@@ -134,7 +134,7 @@ class camera {
     }
 
     vec3 sample_square() const {
-        // Returns a random point in the square surrounding a pixel at the origin.
+        // Returns the vector to a random point in the [-.5,-.5]-[+.5,+.5] unit square.
         return vec3(random_double() - 0.5, random_double() - 0.5, 0);
     }
 
diff --git a/src/TheRestOfYourLife/constant_medium.h b/src/TheRestOfYourLife/constant_medium.h
@@ -25,9 +25,9 @@ class constant_medium : public hittable {
         phase_function(make_shared<isotropic>(tex))
     {}
 
-    constant_medium(shared_ptr<hittable> boundary, double density, const color& c)
+    constant_medium(shared_ptr<hittable> boundary, double density, const color& albedo)
       : boundary(boundary), neg_inv_density(-1/density),
-        phase_function(make_shared<isotropic>(c))
+        phase_function(make_shared<isotropic>(albedo))
     {}
 
     bool hit(const ray& r, interval ray_t, hit_record& rec) const override {
diff --git a/src/TheRestOfYourLife/perlin.h b/src/TheRestOfYourLife/perlin.h
@@ -90,7 +90,7 @@ class perlin {
 
     static void permute(int* p, int n) {
         for (int i = n-1; i > 0; i--) {
-            int target = random_int(0,i);
+            int target = random_int(0, i);
             int tmp = p[i];
             p[i] = p[target];
             p[target] = tmp;
@@ -107,9 +107,10 @@ class perlin {
             for (int j=0; j < 2; j++)
                 for (int k=0; k < 2; k++) {
                     vec3 weight_v(u-i, v-j, w-k);
-                    accum += (i*uu + (1-i)*(1-uu))*
-                        (j*vv + (1-j)*(1-vv))*
-                        (k*ww + (1-k)*(1-ww))*dot(c[i][j][k], weight_v);
+                    accum += (i*uu + (1-i)*(1-uu))
+                           * (j*vv + (1-j)*(1-vv))
+                           * (k*ww + (1-k)*(1-ww))
+                           * dot(c[i][j][k], weight_v);
                 }
 
         return accum;
diff --git a/src/TheRestOfYourLife/texture.h b/src/TheRestOfYourLife/texture.h
@@ -29,8 +29,7 @@ class solid_color : public texture {
   public:
     solid_color(const color& albedo) : albedo(albedo) {}
 
-    solid_color(double red, double green, double blue)
-      : solid_color(color(red,green,blue)) {}
+    solid_color(double red, double green, double blue) : solid_color(color(red,green,blue)) {}
 
     color value(double u, double v, const point3& p) const override {
         return albedo;

Original file line number	Diff line number	Diff line change
`@@ -81,8 +81,8 @@ void bouncing_spheres() {`
`81`	`81`	`cam.lookat = point3(0,0,0);`
`82`	`82`	`cam.vup = vec3(0,1,0);`
`83`	`83`
`84`		`- cam.defocus_angle = 0.02;`
`85`		`- cam.focus_dist = 10;`
	`84`	`+ cam.defocus_angle = 0.6;`
	`85`	`+ cam.focus_dist = 10.0;`
`86`	`86`
`87`	`87`	`cam.render(world);`
`88`	`88`	`}`
Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,7 @@ class camera {`
`93`	`93`	`vec3 viewport_u = viewport_width * u; // Vector across viewport horizontal edge`
`94`	`94`	`vec3 viewport_v = viewport_height * -v; // Vector down viewport vertical edge`
`95`	`95`
`96`		`- // Calculate the horizontal and vertical delta vectors to the next pixel.`
	`96`	`+ // Calculate the horizontal and vertical delta vectors from pixel to pixel.`
`97`	`97`	`pixel_delta_u = viewport_u / image_width;`
`98`	`98`	`pixel_delta_v = viewport_v / image_height;`
`99`	`99`
`@@ -134,7 +134,7 @@ class camera {`
`134`	`134`	`}`
`135`	`135`
`136`	`136`	`vec3 sample_square() const {`
`137`		`- // Returns a random point in the square surrounding a pixel at the origin.`
	`137`	`+ // Returns the vector to a random point in the [-.5,-.5]-[+.5,+.5] unit square.`
`138`	`138`	`return vec3(random_double() - 0.5, random_double() - 0.5, 0);`
`139`	`139`	`}`
`140`	`140`