Use const ref params

* Pass vec, pt, ray, color params by const ref
* Update text for vec, pt, ray, color pass-by-ref

Resolves #1250

Author: hollasch

books/RayTracingInOneWeekend.html

@@ -322,7 +322,7 @@
         double operator[](int i) const { return e[i]; }
         double& operator[](int i) { return e[i]; }
 
-        vec3& operator+=(const vec3 &v) {
+        vec3& operator+=(const vec3& v) {
             e[0] += v.e[0];
             e[1] += v.e[1];
             e[2] += v.e[2];
@@ -355,47 +355,47 @@
 
     // Vector Utility Functions
 
-    inline std::ostream& operator<<(std::ostream &out, const vec3 &v) {
+    inline std::ostream& operator<<(std::ostream& out, const vec3& v) {
         return out << v.e[0] << ' ' << v.e[1] << ' ' << v.e[2];
     }
 
-    inline vec3 operator+(const vec3 &u, const vec3 &v) {
+    inline vec3 operator+(const vec3& u, const vec3& v) {
         return vec3(u.e[0] + v.e[0], u.e[1] + v.e[1], u.e[2] + v.e[2]);
     }
 
-    inline vec3 operator-(const vec3 &u, const vec3 &v) {
+    inline vec3 operator-(const vec3& u, const vec3& v) {
         return vec3(u.e[0] - v.e[0], u.e[1] - v.e[1], u.e[2] - v.e[2]);
     }
 
-    inline vec3 operator*(const vec3 &u, const vec3 &v) {
+    inline vec3 operator*(const vec3& u, const vec3& v) {
         return vec3(u.e[0] * v.e[0], u.e[1] * v.e[1], u.e[2] * v.e[2]);
     }
 
-    inline vec3 operator*(double t, const vec3 &v) {
+    inline vec3 operator*(double t, const vec3& v) {
         return vec3(t*v.e[0], t*v.e[1], t*v.e[2]);
     }
 
-    inline vec3 operator*(const vec3 &v, double t) {
+    inline vec3 operator*(const vec3& v, double t) {
         return t * v;
     }
 
-    inline vec3 operator/(vec3 v, double t) {
+    inline vec3 operator/(const vec3& v, double t) {
         return (1/t) * v;
     }
 
-    inline double dot(const vec3 &u, const vec3 &v) {
+    inline double dot(const vec3& u, const vec3& v) {
         return u.e[0] * v.e[0]
              + u.e[1] * v.e[1]
              + u.e[2] * v.e[2];
     }
 
-    inline vec3 cross(const vec3 &u, const vec3 &v) {
+    inline vec3 cross(const vec3& u, const vec3& v) {
         return vec3(u.e[1] * v.e[2] - u.e[2] * v.e[1],
                     u.e[2] * v.e[0] - u.e[0] * v.e[2],
                     u.e[0] * v.e[1] - u.e[1] * v.e[0]);
     }
 
-    inline vec3 unit_vector(vec3 v) {
+    inline vec3 unit_vector(const vec3& v) {
         return v / v.length();
     }
 
@@ -424,7 +424,7 @@
 
     using color = vec3;
 
-    void write_color(std::ostream &out, color pixel_color) {
+    void write_color(std::ostream& out, const color& pixel_color) {
         // Write the translated [0,255] value of each color component.
         out << int(255.999 * pixel_color.x()) << ' '
             << int(255.999 * pixel_color.y()) << ' '
@@ -1108,7 +1108,7 @@
 
     class sphere : public hittable {
       public:
-        sphere(point3 _center, double _radius) : center(_center), radius(_radius) {}
+        sphere(const point3& _center, double _radius) : center(_center), radius(_radius) {}
 
         bool hit(const ray& r, double ray_tmin, double ray_tmax, hit_record& rec) const override {
             vec3 oc = center - r.origin();
@@ -2013,7 +2013,7 @@
 and the number of samples involved:
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
-    void write_color(std::ostream &out, color pixel_color, int samples_per_pixel) {
+    void write_color(std::ostream& out, const color& pixel_color, int samples_per_pixel) {
         auto r = pixel_color.x();
         auto g = pixel_color.y();
         auto b = pixel_color.z();
@@ -2225,7 +2225,7 @@
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     ...
 
-    inline vec3 unit_vector(vec3 v) {
+    inline vec3 unit_vector(const vec3& v) {
         return v / v.length();
     }
 
@@ -2651,7 +2651,7 @@
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
 
-    void write_color(std::ostream &out, color pixel_color, int samples_per_pixel) {
+    void write_color(std::ostream& out, const color& pixel_color, int samples_per_pixel) {
         auto r = pixel_color.x();
         auto g = pixel_color.y();
         auto b = pixel_color.z();
@@ -2777,7 +2777,7 @@
     class sphere : public hittable {
       public:
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
-        sphere(point3 _center, double _radius, shared_ptr<material> _material)
+        sphere(const point3& _center, double _radius, shared_ptr<material> _material)
           : center(_center), radius(_radius), mat(_material) {}
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
 
@@ -3877,7 +3877,7 @@
 `random_in_unit_sphere()`, just for two dimensions.
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-    inline vec3 unit_vector(vec3 u) {
+    inline vec3 unit_vector(const vec3& u) {
         return v / v.length();
     }
 

books/RayTracingTheNextWeek.html

@@ -176,11 +176,12 @@
       public:
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
         // Stationary Sphere
-        sphere(point3 _center, double _radius, shared_ptr<material> _material)
+        sphere(const point3& _center, double _radius, shared_ptr<material> _material)
           : center1(_center), radius(_radius), mat(_material), is_moving(false) {}
 
         // Moving Sphere
-        sphere(point3 _center1, point3 _center2, double _radius, shared_ptr<material> _material)
+        sphere(const point3& _center1, const point3& _center2, double _radius,
+               shared_ptr<material> _material)
           : center1(_center1), radius(_radius), mat(_material), is_moving(true)
         {
             center_vec = _center2 - _center1;
@@ -735,7 +736,7 @@
       public:
         // Stationary Sphere
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
-        sphere(point3 _center, double _radius, shared_ptr<material> _material)
+        sphere(const point3& _center, double _radius, shared_ptr<material> _material)
           : center1(_center), radius(_radius), mat(_material), is_moving(false)
         {
             auto rvec = vec3(radius, radius, radius);
@@ -770,7 +771,8 @@
       public:
         ...
         // Moving Sphere
-        sphere(point3 _center1, point3 _center2, double _radius, shared_ptr<material> _material)
+        sphere(const point3& _center1, const point3& _center2, double _radius,
+               shared_ptr<material> _material)
           : center1(_center1), radius(_radius), mat(_material), is_moving(true)
         {
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
@@ -1222,7 +1224,7 @@
 
     class solid_color : public texture {
       public:
-        solid_color(color c) : color_value(c) {}
+        solid_color(const color& c) : color_value(c) {}
 
         solid_color(double red, double green, double blue) : solid_color(color(red,green,blue)) {}
 
@@ -1290,7 +1292,7 @@
         checker_texture(double _scale, shared_ptr<texture> _even, shared_ptr<texture> _odd)
           : inv_scale(1.0 / _scale), even(_even), odd(_odd) {}
 
-        checker_texture(double _scale, color c1, color c2)
+        checker_texture(double _scale, const color& c1, const color& c2)
           : inv_scale(1.0 / _scale),
             even(make_shared<solid_color>(c1)),
             odd(make_shared<solid_color>(c2))
@@ -1693,7 +1695,7 @@
 
         ~rtw_image() { STBI_FREE(data); }
 
-        bool load(const std::string filename) {
+        bool load(const std::string& filename) {
             // Loads image data from the given file name. Returns true if the load succeeded.
             auto n = bytes_per_pixel; // Dummy out parameter: original components per pixel
             data = stbi_load(filename.c_str(), &image_width, &image_height, &n, bytes_per_pixel);
@@ -1749,7 +1751,6 @@
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
     #include "rtw_stb_image.h"
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-    #include "perlin.h"
 
     ...
 
@@ -1948,9 +1949,13 @@
 <div class='together'>
 Now if we create an actual texture that takes these floats between 0 and 1 and creates grey colors:
 
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
     #include "perlin.h"
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
 
+    ...
+
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
     class noise_texture : public texture {
       public:
         noise_texture() {}
@@ -2279,8 +2284,15 @@
       ...
       private:
         ...
-        static double perlin_interp(vec3 c[2][2][2], double u, double v, double w) {
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ delete
+        static double trilinear_interp(double c[2][2][2], double u, double v, double w) {
+            ...
+        }
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
+
+
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
+        static double perlin_interp(const vec3 c[2][2][2], double u, double v, double w) {
             auto uu = u*u*(3-2*u);
             auto vv = v*v*(3-2*v);
             auto ww = w*w*(3-2*w);
@@ -2297,9 +2309,8 @@
                     }
 
             return accum;
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
         }
-        ...
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     };
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     [Listing [perlin-interp]: <kbd>[perlin.h]</kbd> Perlin interpolation function so far]
@@ -3050,7 +3061,7 @@
     class diffuse_light : public material {
       public:
         diffuse_light(shared_ptr<texture> a) : emit(a) {}
-        diffuse_light(color c) : emit(make_shared<solid_color>(c)) {}
+        diffuse_light(const color& c) : emit(make_shared<solid_color>(c)) {}
 
         bool scatter(const ray& r_in, const hit_record& rec, color& attenuation, ray& scattered)
         const override {
@@ -3842,7 +3853,7 @@
           : boundary(b), neg_inv_density(-1/d), phase_function(make_shared<isotropic>(a))
         {}
 
-        constant_medium(shared_ptr<hittable> b, double d, color c)
+        constant_medium(shared_ptr<hittable> b, double d, const color& c)
           : boundary(b), neg_inv_density(-1/d), phase_function(make_shared<isotropic>(c))
         {}
 
@@ -3913,7 +3924,7 @@
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     class isotropic : public material {
       public:
-        isotropic(color c) : albedo(make_shared<solid_color>(c)) {}
+        isotropic(const color& c) : albedo(make_shared<solid_color>(c)) {}
         isotropic(shared_ptr<texture> a) : albedo(a) {}
 
         bool scatter(const ray& r_in, const hit_record& rec, color& attenuation, ray& scattered)

books/RayTracingTheRestOfYourLife.html

@@ -2291,7 +2291,7 @@
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     class isotropic : public material {
       public:
-        isotropic(color c) : albedo(make_shared<solid_color>(c)) {}
+        isotropic(const color& c) : albedo(make_shared<solid_color>(c)) {}
         isotropic(shared_ptr<texture> a) : albedo(a) {}
 
 
@@ -2709,7 +2709,7 @@
             return 0.0;
         }
 
-        virtual vec3 random(const vec3& o) const {
+        virtual vec3 random(const point3& origin) const {
             return vec3(1, 0, 0);
         }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
@@ -3167,7 +3167,7 @@
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     class isotropic : public material {
       public:
-        isotropic(color c) : albedo(make_shared<solid_color>(c)) {}
+        isotropic(const color& c) : albedo(make_shared<solid_color>(c)) {}
         isotropic(shared_ptr<texture> a) : albedo(a) {}
 
 
@@ -3496,8 +3496,8 @@
             return  1 / solid_angle;
         }
 
-        vec3 random(const point3& o) const override {
-            vec3 direction = center1 - o;
+        vec3 random(const point3& origin) const override {
+            vec3 direction = center1 - origin;
             auto distance_squared = direction.length_squared();
             onb uvw;
             uvw.build_from_w(direction);
@@ -3595,9 +3595,9 @@
             return sum;
         }
 
-        vec3 random(const vec3& o) const override {
+        vec3 random(const point3& origin) const override {
             auto int_size = int(objects.size());
-            return objects[random_int(0, int_size-1)]->random(o);
+            return objects[random_int(0, int_size-1)]->random(origin);
         }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
 
@@ -3659,7 +3659,7 @@
 `write_color()` function to replace any `NaN` components with zero:
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-    void write_color(std::ostream &out, color pixel_color, int samples_per_pixel) {
+    void write_color(std::ostream& out, const color& pixel_color, int samples_per_pixel) {
         auto r = pixel_color.x();
         auto g = pixel_color.y();
         auto b = pixel_color.z();

src/InOneWeekend/color.h

@@ -25,7 +25,7 @@ inline double linear_to_gamma(double linear_component)
     return 0;
 }
 
-void write_color(std::ostream &out, color pixel_color, int samples_per_pixel) {
+void write_color(std::ostream& out, const color& pixel_color, int samples_per_pixel) {
     auto r = pixel_color.x();
     auto g = pixel_color.y();
     auto b = pixel_color.z();
@@ -36,7 +36,7 @@ void write_color(std::ostream &out, color pixel_color, int samples_per_pixel) {
     g *= scale;
     b *= scale;
 
-    // Apply a linear to gamma transform for gamma 2
+    // Apply the linear to gamma transform.
     r = linear_to_gamma(r);
     g = linear_to_gamma(g);
     b = linear_to_gamma(b);

src/InOneWeekend/rtw_stb_image.h

@@ -45,7 +45,7 @@ class rtw_image {
 
     ~rtw_image() { STBI_FREE(data); }
 
-    bool load(const std::string filename) {
+    bool load(const std::string& filename) {
         // Loads image data from the given file name. Returns true if the load succeeded.
         auto n = bytes_per_pixel; // Dummy out parameter: original components per pixel
         data = stbi_load(filename.c_str(), &image_width, &image_height, &n, bytes_per_pixel);

src/InOneWeekend/sphere.h

@@ -18,7 +18,7 @@
 
 class sphere : public hittable {
   public:
-    sphere(point3 _center, double _radius, shared_ptr<material> _material)
+    sphere(const point3& _center, double _radius, shared_ptr<material> _material)
       : center(_center), radius(_radius), mat(_material) {}
 
     bool hit(const ray& r, interval ray_t, hit_record& rec) const override {