Merge remote-tracking branch 'origin/explain-sphere-uv' into explain-sphere-uv

Author: hollasch

CHANGELOG.md

@@ -5,15 +5,20 @@ Change Log -- Ray Tracing in One Weekend
 
 ### Common
   - Change: refactor `sphere::hit()` method to reuse common blocks of code.
-  - Fix: Added `fmin` to book text for `cos_theta` of `refract`
+  - Fix: Added `fmin` to book text for `cos_theta` of `refract` (#732)
   - Fix: Standardized naming for ray-t and time parameters (#746)
+  - Fix: `random_unit_vector()` was incorrect (#697)
 
 ### In One Weekend
 
 ### The Next Week
   - Add: Improved explanation of `get_sphere_uv()` function (#533)
 
 ### The Rest of Your Life
+  - Fix: Missing `override` keyword for `xz_rect::pdf_value()` and `xz_rect::random()` methods
+    (#748)
+  - Fix: Synchronize book and source for `cornell_box()` function.
+  - Fix: Introduction of light code was introduced out of sequence (#738, #740)
   - Add: Improved explanation of `get_sphere_uv()` function (#533)
 
 

books/RayTracingInOneWeekend.html

@@ -1738,16 +1738,18 @@
 
 However, we are interested in a Lambertian distribution, which has a distribution of $\cos (\phi)$.
 True Lambertian has the probability higher for ray scattering close to the normal, but the
-distribution is more uniform. This is achieved by picking points on the surface of the unit sphere,
-offset along the surface normal. Picking points on the sphere can be achieved by picking points in
-the unit ball, and then normalizing those.
+distribution is more uniform. This is achieved by picking random points on the surface of the unit
+sphere, offset along the surface normal. Picking random points on the unit sphere can be achieved by
+picking random points _in_ the unit sphere, and then normalizing those.
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
+    inline vec3 random_in_unit_sphere() {
+        ...
+    }
+
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
     vec3 random_unit_vector() {
-        auto a = random_double(0, 2*pi);
-        auto z = random_double(-1, 1);
-        auto r = sqrt(1 - z*z);
-        return vec3(r*cos(a), r*sin(a), z);
+        return unit_vector(random_in_unit_sphere());
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     [Listing [random-unit-vector]: <kbd>[vec3.h]</kbd> The random_unit_vector() function]

books/RayTracingTheRestOfYourLife.html

@@ -544,33 +544,12 @@
 
   $$ \int cos^2(\theta) $$
 
-<div class='together'>
 By MC integration, we should just be able to sample $\cos^2(\theta) / p(\text{direction})$, but what
-is direction in that context? We could make it based on polar coordinates, so $p$ would be in terms
-of $(\theta, \phi)$. However you do it, remember that a PDF has to integrate to 1 and represent the
-relative probability of that direction being sampled. We have a method from the last books to take
-uniform random samples in or on a unit sphere:
-
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-    vec3 random_unit_vector() {
-        auto a = random_double(0, 2*pi);
-        auto z = random_double(-1, 1);
-        auto r = sqrt(1 - z*z);
-        return vec3(r*cos(a), r*sin(a), z);
-    }
-
-    ...
-
-    vec3 random_in_unit_sphere() {
-        while (true) {
-            auto p = vec3::random(-1,1);
-            if (p.length_squared() >= 1) continue;
-            return p;
-        }
-    }
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    [Listing [random-unit-vector]: <kbd>[vec3.h]</kbd> Random vector of unit length]
-</div>
+is _direction_ in that context? We could make it based on polar coordinates, so $p$ would be in
+terms of $(\theta, \phi)$. However you do it, remember that a PDF has to integrate to 1 and
+represent the relative probability of that direction being sampled. Recall that we have vec3
+functions to take uniform random samples in (`random_in_unit_sphere()`) or on
+(`random_unit_vector()`) a unit sphere.
 
 <div class='together'>
 Now what is the PDF of these uniform points? As a density on the unit sphere, it is $1/\text{area}$
@@ -757,35 +736,36 @@
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     ...
-    color ray_color(
+    color ray_color(...) {
         ...
+    }
 
     hittable_list cornell_box() {
-        hittable_list world;
+        hittable_list objects;
 
         auto red   = make_shared<lambertian>(color(.65, .05, .05));
         auto white = make_shared<lambertian>(color(.73, .73, .73));
         auto green = make_shared<lambertian>(color(.12, .45, .15));
         auto light = make_shared<diffuse_light>(color(15, 15, 15));
 
-        world.add(make_shared<yz_rect>(0, 555, 0, 555, 555, green));
-        world.add(make_shared<yz_rect>(0, 555, 0, 555, 0, red));
-        world.add(make_shared<xz_rect>(213, 343, 227, 332, 554, light));
-        world.add(make_shared<xz_rect>(0, 555, 0, 555, 555, white));
-        world.add(make_shared<xz_rect>(0, 555, 0, 555, 0, white));
-        world.add(make_shared<xy_rect>(0, 555, 0, 555, 555, white));
+        objects.add(make_shared<yz_rect>(0, 555, 0, 555, 555, green));
+        objects.add(make_shared<yz_rect>(0, 555, 0, 555, 0, red));
+        objects.add(make_shared<xz_rect>(213, 343, 227, 332, 554, light));
+        objects.add(make_shared<xz_rect>(0, 555, 0, 555, 555, white));
+        objects.add(make_shared<xz_rect>(0, 555, 0, 555, 0, white));
+        objects.add(make_shared<xy_rect>(0, 555, 0, 555, 555, white));
 
         shared_ptr<hittable> box1 = make_shared<box>(point3(0,0,0), point3(165,330,165), white);
         box1 = make_shared<rotate_y>(box1, 15);
         box1 = make_shared<translate>(box1, vec3(265,0,295));
-        world.add(box1);
+        objects.add(box1);
 
         shared_ptr<hittable> box2 = make_shared<box>(point3(0,0,0), point3(165,165,165), white);
         box2 = make_shared<rotate_y>(box2, -18);
         box2 = make_shared<translate>(box2, vec3(130,0,65));
-        world.add(box2);
+        objects.add(box2);
 
-        return world;
+        return objects;
     }
 
     int main() {
@@ -799,10 +779,6 @@
 
         // World
 
-        auto lights = make_shared<hittable_list>();
-        lights->add(make_shared<xz_rect>(213, 343, 227, 332, 554, shared_ptr<material>()));
-        lights->add(make_shared<sphere>(point3(190, 90, 190), 90, shared_ptr<material>()));
-
         auto world = cornell_box();
 
         color background(0,0,0);
@@ -1524,21 +1500,21 @@
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     hittable_list cornell_box() {
-        hittable_list world;
+        hittable_list objects;
 
         auto red   = make_shared<lambertian>(color(.65, .05, .05));
         auto white = make_shared<lambertian>(color(.73, .73, .73));
         auto green = make_shared<lambertian>(color(.12, .45, .15));
         auto light = make_shared<diffuse_light>(color(15, 15, 15));
 
-        world.add(make_shared<yz_rect>(0, 555, 0, 555, 555, green));
-        world.add(make_shared<yz_rect>(0, 555, 0, 555, 0, red));
+        objects.add(make_shared<yz_rect>(0, 555, 0, 555, 555, green));
+        objects.add(make_shared<yz_rect>(0, 555, 0, 555, 0, red));
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
-        world.add(make_shared<flip_face>(make_shared<xz_rect>(213, 343, 227, 332, 554, light)));
+        objects.add(make_shared<flip_face>(make_shared<xz_rect>(213, 343, 227, 332, 554, light)));
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-        world.add(make_shared<xz_rect>(0, 555, 0, 555, 555, white));
-        world.add(make_shared<xz_rect>(0, 555, 0, 555, 0, white));
-        world.add(make_shared<xy_rect>(0, 555, 0, 555, 555, white));
+        objects.add(make_shared<xz_rect>(0, 555, 0, 555, 555, white));
+        objects.add(make_shared<xz_rect>(0, 555, 0, 555, 0, white));
+        objects.add(make_shared<xy_rect>(0, 555, 0, 555, 555, white));
 
         ...
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -1690,8 +1666,7 @@
 
         return emitted
              + albedo * rec.mat_ptr->scattering_pdf(r, rec, scattered)
-                      * ray_color(scattered, background, world, depth-1)
-                      / pdf_val;
+                      * ray_color(scattered, background, world, depth-1) / pdf_val;
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     [Listing [ray-color-cos-pdf]: <kbd>[main.cc]</kbd> The ray_color function, using cosine pdf]
@@ -1821,8 +1796,7 @@
 
         return emitted
              + albedo * rec.mat_ptr->scattering_pdf(r, rec, scattered)
-                      * ray_color(scattered, background, world, depth-1)
-                      / pdf_val;
+                      * ray_color(scattered, background, world, depth-1) / pdf_val;
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     [Listing [ray-color-hittable-pdf]: <kbd>[main.cc]</kbd> ray_color function with hittable PDF]
@@ -1872,15 +1846,8 @@
 <div class='together'>
 And plugging it into `ray_color()`:
 
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
-    color ray_color(
-        const ray& r,
-        const color& background,
-        const hittable& world,
-        shared_ptr<hittable> lights,
-        int depth
-    ) {
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
+    color ray_color(const ray& r, const color& background, const hittable& world, int depth) {
         hit_record rec;
 
         // If we've exceeded the ray bounce limit, no more light is gathered.
@@ -1912,8 +1879,7 @@
 
         return emitted
              + albedo * rec.mat_ptr->scattering_pdf(r, rec, scattered)
-                      * ray_color(scattered, background, world, lights, depth-1)
-                      / pdf_val;
+                      * ray_color(scattered, background, world, depth-1) / pdf_val;
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     [Listing [ray-color-mixture]: <kbd>[main.cc]</kbd> The ray_color function, using mixture PDF]
@@ -1972,7 +1938,7 @@
 
 
 
-Cleaning Up PDF Management.
+Cleaning Up PDF Management
 ====================================================================================================
 
 <div class='together'>
@@ -2077,14 +2043,15 @@
 <div class='together'>
 And `ray_color()` changes are small:
 
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
     color ray_color(
         const ray& r,
         const color& background,
         const hittable& world,
         shared_ptr<hittable> lights,
         int depth
     ) {
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
         hit_record rec;
 
         // If we've exceeded the ray bounce limit, no more light is gathered.
@@ -2109,10 +2076,32 @@
 
         return emitted
             + srec.attenuation * rec.mat_ptr->scattering_pdf(r, rec, scattered)
-                               * ray_color(scattered, background, world, lights, depth-1)
-                               / pdf_val;
+                               * ray_color(scattered, background, world, lights, depth-1) / pdf_val;
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     }
+
+    ...
+
+    int main() {
+        ...
+        // World
+
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
+        auto lights = make_shared<hittable_list>();
+        lights->add(make_shared<xz_rect>(213, 343, 227, 332, 554, shared_ptr<material>()));
+        lights->add(make_shared<sphere>(point3(190, 90, 190), 90, shared_ptr<material>()));
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
+
+        auto world = cornell_box();
+
+        color background(0,0,0);
+
+        for (int j = image_height-1; j >= 0; --j) {
+            std::cerr << "\rScanlines remaining: " << j << ' ' << std::flush;
+            for (int i = 0; i < image_width; ++i) {
+                ...
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
+                pixel_color += ray_color(r, background, world, lights, max_depth);
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     [Listing [ray-color-scatter]: <kbd>[main.cc]</kbd> Ray color with scatter]
 </div>
@@ -2218,32 +2207,31 @@
 
         return emitted + srec.attenuation
                        * rec.mat_ptr->scattering_pdf(r, rec, scattered)
-                       * ray_color(scattered, background, world, lights, depth-1)
-                       / pdf_val;
+                       * ray_color(scattered, background, world, lights, depth-1) / pdf_val;
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     [Listing [ray-color-implicit]: <kbd>[main.cc]</kbd>
     Ray color function with implicitly-sampled rays]
 </div>
 
 <div class='together'>
-We also need to change the block to metal.
+We also need to change the block to metal. We'll also swap out the short block for a glass sphere.
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-    hittable_list cornell_box(camera& cam, double aspect) {
-        hittable_list world;
+    hittable_list cornell_box() {
+        hittable_list objects;
 
         auto red   = make_shared<lambertian>(color(.65, .05, .05));
         auto white = make_shared<lambertian>(color(.73, .73, .73));
         auto green = make_shared<lambertian>(color(.12, .45, .15));
         auto light = make_shared<diffuse_light>(color(15, 15, 15));
 
-        world.add(make_shared<yz_rect>(0, 555, 0, 555, 555, green));
-        world.add(make_shared<yz_rect>(0, 555, 0, 555, 0, red));
-        world.add(make_shared<xz_rect>(213, 343, 227, 332, 554, light));
-        world.add(make_shared<xz_rect>(0, 555, 0, 555, 555, white));
-        world.add(make_shared<xz_rect>(0, 555, 0, 555, 0, white));
-        world.add(make_shared<xy_rect>(0, 555, 0, 555, 555, white));
+        objects.add(make_shared<yz_rect>(0, 555, 0, 555, 555, green));
+        objects.add(make_shared<yz_rect>(0, 555, 0, 555, 0, red));
+        objects.add(make_shared<flip_face>(make_shared<xz_rect>(213, 343, 227, 332, 554, light)));
+        objects.add(make_shared<xz_rect>(0, 555, 0, 555, 555, white));
+        objects.add(make_shared<xz_rect>(0, 555, 0, 555, 0, white));
+        objects.add(make_shared<xy_rect>(0, 555, 0, 555, 555, white));
 
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
@@ -2252,25 +2240,15 @@
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
         box1 = make_shared<rotate_y>(box1, 15);
         box1 = make_shared<translate>(box1, vec3(265,0,295));
-        world.add(box1);
-
-        shared_ptr<hittable> box2 = make_shared<box>(point3(0,0,0), point3(165,165,165), white);
-        box2 = make_shared<rotate_y>(box2, -18);
-        box2 = make_shared<translate>(box2, vec3(130,0,65);
-        world.add(box2);
+        objects.add(box1);
 
-        point3 lookfrom(278, 278, -800);
-        point3 lookat(278, 278, 0);
-        vec3 vup(0, 1, 0);
-        auto dist_to_focus = 10.0;
-        auto aperture = 0.0;
-        auto vfov = 40.0;
-        auto time0 = 0.0;
-        auto time1 = 1.0;
 
-        cam = camera(lookfrom, lookat, vup, vfov, aspect, aperture, dist_to_focus, time0, time1);
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
+        auto glass = make_shared<dielectric>(1.5);
+        objects.add(make_shared<sphere>(point3(190,90,190), 90 , glass));
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
 
-        return world;
+        return objects;
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     [Listing [scene-cornell-al]: <kbd>[main.cc]</kbd> Cornell box scene with aluminum material]
@@ -2511,6 +2489,7 @@
         auto g = pixel_color.y();
         auto b = pixel_color.z();
 
+
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
         // Replace NaN components with zero. See explanation in Ray Tracing: The Rest of Your Life.
         if (r != r) r = 0.0;

src/TheNextWeek/main.cc

@@ -150,7 +150,7 @@ hittable_list cornell_box() {
     auto red   = make_shared<lambertian>(color(.65, .05, .05));
     auto white = make_shared<lambertian>(color(.73, .73, .73));
     auto green = make_shared<lambertian>(color(.12, .45, .15));
-    auto light = make_shared<diffuse_light>(color(15,15,15));
+    auto light = make_shared<diffuse_light>(color(15, 15, 15));
 
     objects.add(make_shared<yz_rect>(0, 555, 0, 555, 555, green));
     objects.add(make_shared<yz_rect>(0, 555, 0, 555, 0, red));

src/TheRestOfYourLife/aarect.h

@@ -55,7 +55,7 @@ class xz_rect : public hittable {
             return true;
         }
 
-        virtual double pdf_value(const point3& origin, const vec3& v) const {
+        virtual double pdf_value(const point3& origin, const vec3& v) const override {
             hit_record rec;
             if (!this->hit(ray(origin, v), 0.001, infinity, rec))
                 return 0;
@@ -67,7 +67,7 @@ class xz_rect : public hittable {
             return distance_squared / (cosine * area);
         }
 
-        virtual vec3 random(const point3& origin) const {
+        virtual vec3 random(const point3& origin) const override {
             auto random_point = point3(random_double(x0,x1), k, random_double(z0,z1));
             return random_point - origin;
         }