Move vec methods from material.h, pdf.h to vec3.h

Also, eliminate a duplicate (and inconsistent) implementations.

It's interesting to note that this includes the formulation of
random_unit_vector() that performs better than the method that picks
random points from a box until one is chosen that lies in the inscribed
sphere.

Author: hollasch

books/RayTracingInOneWeekend.html

@@ -1316,19 +1316,19 @@
 the unit ball, and then normalizing those.
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-    vec3 random_on_unit_sphere() {
+    vec3 random_unit_vector() {
         return unit_vector(random_in_unit_sphere());
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    [Listing [random-on-unit-sphere]: <kbd>[material.h]</kbd> The random_on_unit_sphere() function]
+    [Listing [random-unit-vector]: <kbd>[vec3.h]</kbd> The random_unit_vector() function]
 
   ![Figure [rand-unit-vector]: Generating a random unit vector](../images/fig.rand-unitvector.png)
 
 </div>
 
 
 <div class='together'>
-This `random_on_unit_sphere()` is a drop-in replacement for the existing `random_in_unit_sphere()`
+This `random_unit_vector()` is a drop-in replacement for the existing `random_in_unit_sphere()`
 function.
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
@@ -1338,7 +1338,7 @@
             if (depth <= 0)
                 return vec3(0,0,0);
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
-            vec3 target = rec.p + rec.normal + random_on_unit_sphere();
+            vec3 target = rec.p + rec.normal + random_unit_vector();
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
             return 0.5 * ray_color(ray(rec.p, target - rec.p), world, depth-1);
         }
@@ -1399,10 +1399,8 @@
             return -in_unit_sphere;
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    [Listing [random-in-hemisphere]: <kbd>[material.h]</kbd> The random_in_hemisphere(normal) function]
+    [Listing [random-in-hemisphere]: <kbd>[vec3.h]</kbd> The random_in_hemisphere(normal) function]
 
-Note that the functionality should be identical between `random_in_unit_sphere()` and
-`random_on_unit_sphere()`
 </div>
 
 <div class='together'>
@@ -1435,7 +1433,8 @@
 <div class='together'>
 Scenes will become more complicated over the course of the book. You are encouraged to
 switch between the different diffuse renderers presented here. Most scenes of interest will contain
-a disproportionate amount of diffuse materials. You can gain valuable insight by understanding the effect of different diffuse methods on the lighting of the scene.
+a disproportionate amount of diffuse materials. You can gain valuable insight by understanding the
+effect of different diffuse methods on the lighting of the scene.
 </div>
 
 Metal
@@ -1616,7 +1615,7 @@
         return v - 2*dot(v,n)*n;
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    [Listing [vec3-reflect]: <kbd>[material.h]</kbd> vec3 reflection function]
+    [Listing [vec3-reflect]: <kbd>[vec3.h]</kbd> vec3 reflection function]
 </div>
 
 <div class='together'>
@@ -1729,18 +1728,9 @@
 The bigger the sphere, the fuzzier the reflections will be. This suggests adding a fuzziness
 parameter that is just the radius of the sphere (so zero is no perturbation). The catch is that for
 big spheres or grazing rays, we may scatter below the surface. We can just have the surface
-absorb those. We’ll put a maximum of 1 on the radius of the sphere which yields:
+absorb those.
 
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
-    vec3 random_in_unit_sphere() {
-        vec3 p;
-        do {
-            p = 2*vec3(random_double(), random_double(), random_double()) - vec3(1,1,1);
-        } while (p.squared_length() >= 1);
-        return p;
-    }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-
     class metal : public material {
         public:
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
@@ -1763,7 +1753,7 @@
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     };
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    [Listing [metal-fuzz]: <kbd>[main.cc]</kbd> Metal spheres with fuzziness]
+    [Listing [metal-fuzz]: <kbd>[material.h]</kbd> Metal spheres with fuzziness]
 
 In order to generate a random point inside a unit sphere (`random_in_unit_sphere()`), we used one of
 the easiest algorithms: a rejection method. First, pick a random point in the unit cube where x, y,
@@ -1832,7 +1822,7 @@
         return true;
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    [Listing [refract]: <kbd>[material.h]</kbd> Refraction function]
+    [Listing [refract]: <kbd>[vec3.h]</kbd> Refraction function]
 </div>
 
 <div class='together'>

books/RayTracingTheRestOfYourLife.html

@@ -548,11 +548,11 @@
         return p;
     }
 
-    vec3 random_on_unit_sphere() {
+    vec3 random_unit_vector() {
         return unit_vector(random_in_unit_sphere());
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    [Listing [random-on-unit-sphere]: <kbd>[pdf.h]</kbd> Random point on the unit sphere]
+    [Listing [random-unit-vector]: <kbd>[vec3.h]</kbd> Random vector of unit length]
 </div>
 
 <div class='together'>
@@ -569,7 +569,7 @@
         int N = 1000000;
         auto sum = 0.0;
         for (int i = 0; i < N; i++) {
-            vec3 d = random_on_unit_sphere();
+            vec3 d = random_unit_vector();
             auto cosine_squared = d.z()*d.z();
             sum += cosine_squared / pdf(d);
         }
@@ -809,7 +809,7 @@
             bool scatter(
                 const ray& r_in, const hit_record& rec, vec3& alb, ray& scattered, double& pdf
             ) const {
-                vec3 target = rec.p + rec.normal + random_on_unit_sphere();
+                vec3 target = rec.p + rec.normal + random_unit_vector();
                 scattered = ray(rec.p, unit_vector(target-rec.p), r_in.time());
                 alb = albedo->value(rec.u, rec.v, rec.p);
                 pdf = dot(rec.normal, scattered.direction()) / pi;

src/InOneWeekend/material.h

@@ -24,50 +24,6 @@ double schlick(double cosine, double ref_idx) {
 }
 
 
-bool refract(const vec3& v, const vec3& n, double ni_over_nt, vec3& refracted) {
-    vec3 uv = unit_vector(v);
-    auto dt = dot(uv, n);
-    auto discriminant = 1.0 - ni_over_nt*ni_over_nt*(1-dt*dt);
-
-    if (discriminant <= 0)
-        return false;
-
-    refracted = ni_over_nt*(uv - n*dt) - n*sqrt(discriminant);
-    return true;
-}
-
-
-vec3 reflect(const vec3& v, const vec3& n) {
-     return v - 2*dot(v,n)*n;
-}
-
-
-vec3 random_unit_vector() {
-    auto a = 2*pi * random_double();
-    auto z = 2*random_double() - 1;
-    auto r = sqrt(1 - z*z);
-    return vec3(r*cos(a), r*sin(a), z);
-}
-
-
-vec3 random_in_unit_sphere() {
-    vec3 p;
-    do {
-        p = 2.0*vec3(random_double(),random_double(),random_double()) - vec3(1,1,1);
-    } while (p.squared_length() >= 1.0);
-    return p;
-}
-
-
-vec3 random_in_hemisphere(const vec3& normal) {
-    vec3 in_unit_sphere = random_in_unit_sphere();
-    if (dot(in_unit_sphere, normal) > 0.0) // In the same hemisphere as the normal
-        return in_unit_sphere;
-    else
-        return -in_unit_sphere;
-}
-
-
 class material  {
     public:
         virtual bool scatter(

src/TheNextWeek/material.h

@@ -22,40 +22,6 @@ double schlick(double cosine, double ref_idx) {
     return r0 + (1-r0)*pow((1 - cosine),5);
 }
 
-bool refract(const vec3& v, const vec3& n, double ni_over_nt, vec3& refracted) {
-    vec3 uv = unit_vector(v);
-    auto dt = dot(uv, n);
-    auto discriminant = 1.0 - ni_over_nt*ni_over_nt*(1-dt*dt);
-
-    if (discriminant <= 0)
-        return false;
-
-    refracted = ni_over_nt*(uv - n*dt) - n*sqrt(discriminant);
-    return true;
-}
-
-
-vec3 reflect(const vec3& v, const vec3& n) {
-     return v - 2*dot(v,n)*n;
-}
-
-
-vec3 random_unit_vector() {
-    auto a = 2*pi * random_double();
-    auto z = 2*random_double() - 1;
-    auto r = sqrt(1 - z*z);
-    return vec3(r*cos(a), r*sin(a), z);
-}
-
-
-vec3 random_in_unit_sphere() {
-    vec3 p;
-    do {
-        p = 2.0*vec3(random_double(),random_double(),random_double()) - vec3(1,1,1);
-    } while (dot(p,p) >= 1.0);
-    return p;
-}
-
 
 class material  {
     public:

src/TheRestOfYourLife/material.h

@@ -23,24 +23,6 @@ double schlick(double cosine, double ref_idx) {
 }
 
 
-bool refract(const vec3& v, const vec3& n, double ni_over_nt, vec3& refracted) {
-    vec3 uv = unit_vector(v);
-    auto dt = dot(uv, n);
-    auto discriminant = 1.0 - ni_over_nt*ni_over_nt*(1-dt*dt);
-
-    if (discriminant <= 0)
-        return false;
-
-    refracted = ni_over_nt*(uv - n*dt) - n*sqrt(discriminant);
-    return true;
-}
-
-
-vec3 reflect(const vec3& v, const vec3& n) {
-     return v - 2*dot(v,n)*n;
-}
-
-
 struct scatter_record
 {
     ray specular_ray;

src/TheRestOfYourLife/pdf.h

@@ -25,6 +25,7 @@ inline vec3 random_cosine_direction() {
     return vec3(x, y, z);
 }
 
+
 inline vec3 random_to_sphere(double radius, double distance_squared) {
     auto r1 = random_double();
     auto r2 = random_double();
@@ -35,25 +36,6 @@ inline vec3 random_to_sphere(double radius, double distance_squared) {
     return vec3(x, y, z);
 }
 
-vec3 random_in_unit_sphere() {
-    vec3 p;
-    do {
-        p = 2*vec3(random_double(),random_double(),random_double()) - vec3(1,1,1);
-    } while (p.squared_length() >= 1);
-    return p;
-}
-
-vec3 random_on_unit_sphere() {
-    return unit_vector(random_in_unit_sphere());
-}
-
-vec3 random_in_hemisphere(const vec3& normal) {
-    vec3 in_unit_sphere = random_in_unit_sphere();
-    if (dot(in_unit_sphere, normal) > 0.0) // In the same hemisphere as the normal
-        return in_unit_sphere;
-    else
-        return -in_unit_sphere;
-}
 
 class pdf  {
     public:
@@ -62,6 +44,7 @@ class pdf  {
         virtual ~pdf() {}
 };
 
+
 class cosine_pdf : public pdf {
     public:
         cosine_pdf(const vec3& w) { uvw.build_from_w(w); }
@@ -78,6 +61,7 @@ class cosine_pdf : public pdf {
         onb uvw;
 };
 
+
 class hittable_pdf : public pdf {
     public:
         hittable_pdf(hittable *p, const vec3& origin) : ptr(p), o(origin) {}
@@ -91,6 +75,7 @@ class hittable_pdf : public pdf {
         hittable *ptr;
 };
 
+
 class mixture_pdf : public pdf {
     public:
         mixture_pdf(pdf *p0, pdf *p1) { p[0] = p0; p[1] = p1; }
@@ -106,4 +91,5 @@ class mixture_pdf : public pdf {
         pdf *p[2];
 };
 
+
 #endif

src/TheRestOfYourLife/sphere_importance.cc

@@ -16,27 +16,17 @@
 #include <math.h>
 #include <stdlib.h>
 
-vec3 random_in_unit_sphere() {
-    vec3 p;
-    do {
-        p = 2*vec3(random_double(), random_double(), random_double()) - vec3(1,1,1);
-    } while (p.squared_length() >= 1);
-    return p;
-}
-
-vec3 random_on_unit_sphere() {
-    return unit_vector(random_in_unit_sphere());
-}
 
 inline double pdf(const vec3& p) {
     return  1.0 / (4.0*pi);
 }
 
+
 int main() {
     int N = 1000000;
     auto sum = 0.0;
     for (int i = 0; i < N; i++) {
-        vec3 d = random_on_unit_sphere();
+        vec3 d = random_unit_vector();
         auto cosine_squared = d.z()*d.z();
         sum += cosine_squared / pdf(d);
     }

src/common/vec3.h

@@ -131,4 +131,44 @@ vec3 random_in_unit_disk() {
     return p;
 }
 
+vec3 random_unit_vector() {
+    auto a = 2*pi * random_double();
+    auto z = 2*random_double() - 1;
+    auto r = sqrt(1 - z*z);
+    return vec3(r*cos(a), r*sin(a), z);
+}
+
+vec3 random_in_unit_sphere() {
+    vec3 p;
+    do {
+        p = 2.0*vec3(random_double(),random_double(),random_double()) - vec3(1,1,1);
+    } while (p.squared_length() >= 1.0);
+    return p;
+}
+
+vec3 random_in_hemisphere(const vec3& normal) {
+    vec3 in_unit_sphere = random_in_unit_sphere();
+    if (dot(in_unit_sphere, normal) > 0.0) // In the same hemisphere as the normal
+        return in_unit_sphere;
+    else
+        return -in_unit_sphere;
+}
+
+vec3 reflect(const vec3& v, const vec3& n) {
+    return v - 2*dot(v,n)*n;
+}
+
+bool refract(const vec3& v, const vec3& n, double ni_over_nt, vec3& refracted) {
+    vec3 uv = unit_vector(v);
+    auto dt = dot(uv, n);
+    auto discriminant = 1.0 - ni_over_nt*ni_over_nt*(1-dt*dt);
+
+    if (discriminant <= 0)
+        return false;
+
+    refracted = ni_over_nt*(uv - n*dt) - n*sqrt(discriminant);
+    return true;
+}
+
+
 #endif