Rename main color to pixel_color

This change also fixes references to the `ray_color` function, which
used to be named just `color`.

Work related to issue #422

Author: hollasch

books/RayTracingInOneWeekend.html

@@ -344,8 +344,8 @@
             std::cerr << "\rScanlines remaining: " << j << ' ' << std::flush;
             for (int i = 0; i < image_width; ++i) {
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
-                vec3 color(double(i)/(image_width-1), double(j)/(image_height-1), 0.25);
-                color.write_color(std::cout);
+                vec3 pixel_color(double(i)/(image_width-1), double(j)/(image_height-1), 0.25);
+                pixel_color.write_color(std::cout);
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
             }
         }
@@ -411,8 +411,8 @@
 through pixels and computes the color seen in the direction of those rays. The involved steps are
 (1) calculate the ray from the eye to the pixel, (2) determine which objects the ray intersects, and
 (3) compute a color for that intersection point. When first developing a ray tracer, I always do a
-simple camera for getting the code up and running. I also make a simple `color(ray)` function that
-returns the color of the background (a simple gradient).
+simple camera for getting the code up and running. I also make a simple `ray_color(ray)` function
+that returns the color of the background (a simple gradient).
 
 I’ve often gotten into trouble using square images for debugging because I transpose $x$ and $y$ too
 often, so I’ll stick with a 200×100 image. I’ll put the “eye” (or camera center if you think of a
@@ -459,9 +459,9 @@
                 auto u = double(i) / (image_width-1);
                 auto v = double(j) / (image_height-1);
                 ray r(origin, lower_left_corner + u*horizontal + v*vertical);
-                vec3 color = ray_color(r);
+                vec3 pixel_color = ray_color(r);
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-                color.write_color(std::cout);
+                pixel_color.write_color(std::cout);
             }
         }
 
@@ -1154,10 +1154,10 @@
 
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
-                vec3 color = ray_color(r, world);
+                vec3 pixel_color = ray_color(r, world);
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
 
-                color.write_color(std::cout);
+                pixel_color.write_color(std::cout);
             }
         }
 
@@ -1334,14 +1334,14 @@
             std::cerr << "\rScanlines remaining: " << j << ' ' << std::flush;
             for (int i = 0; i < image_width; ++i) {
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
-                vec3 color(0, 0, 0);
+                vec3 pixel_color(0, 0, 0);
                 for (int s = 0; s < samples_per_pixel; ++s) {
                     auto u = (i + random_double()) / (image_width-1);
                     auto v = (j + random_double()) / (image_height-1);
                     ray r = cam.get_ray(u, v);
-                    color += ray_color(r, world);
+                    pixel_color += ray_color(r, world);
                 }
-                color.write_color(std::cout, samples_per_pixel);
+                pixel_color.write_color(std::cout, samples_per_pixel);
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
             }
         }
@@ -1499,16 +1499,16 @@
         for (int j = image_height-1; j >= 0; --j) {
             std::cerr << "\rScanlines remaining: " << j << ' ' << std::flush;
             for (int i = 0; i < image_width; ++i) {
-                vec3 color(0, 0, 0);
+                vec3 pixel_color(0, 0, 0);
                 for (int s = 0; s < samples_per_pixel; ++s) {
                     auto u = (i + random_double()) / (image_width-1);
                     auto v = (j + random_double()) / (image_height-1);
                     ray r = cam.get_ray(u, v);
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
-                    color += ray_color(r, world, max_depth);
+                    pixel_color += ray_color(r, world, max_depth);
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
                 }
-                color.write_color(std::cout, samples_per_pixel);
+                pixel_color.write_color(std::cout, samples_per_pixel);
             }
         }
 
@@ -1811,7 +1811,7 @@
 `hit_record` is just a way to stuff a bunch of arguments into a struct so we can send them as a
 group. When a ray hits a surface (a particular sphere for example), the material pointer in the
 `hit_record` will be set to point at the material pointer the sphere was given when it was set up in
-`main()` when we start. When the `color()` routine gets the `hit_record` it can call member
+`main()` when we start. When the `ray_color()` routine gets the `hit_record` it can call member
 functions of the material pointer to find out what ray, if any, is scattered.
 
 <div class='together'>
@@ -1951,7 +1951,7 @@
 </div>
 
 <div class='together'>
-We need to modify the color function to use this:
+We need to modify the `ray_color()` function to use this:
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     vec3 ray_color(const ray& r, const hittable& world, int depth) {
@@ -2009,14 +2009,14 @@
         for (int j = image_height-1; j >= 0; --j) {
             std::cerr << "\rScanlines remaining: " << j << ' ' << std::flush;
             for (int i = 0; i < image_width; ++i) {
-                vec3 color(0, 0, 0);
+                vec3 pixel_color(0, 0, 0);
                 for (int s = 0; s < samples_per_pixel; ++s) {
                     auto u = (i + random_double()) / (image_width-1);
                     auto v = (j + random_double()) / (image_height-1);
                     ray r = cam.get_ray(u, v);
-                    color += ray_color(r, world, max_depth);
+                    pixel_color += ray_color(r, world, max_depth);
                 }
-                color.write_color(std::cout, samples_per_pixel);
+                pixel_color.write_color(std::cout, samples_per_pixel);
             }
         }
 

books/RayTracingTheNextWeek.html

@@ -902,7 +902,7 @@
     [Listing [texture]: <kbd>[texture.h]</kbd> A texture class]
 
 <div class='together'>
-Now we can make textured materials by replacing the vec3 color with a texture pointer:
+Now we can make textured materials by replacing the `vec3 solid_color` with a texture pointer:
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     class lambertian : public material {
@@ -1827,7 +1827,7 @@
         ...
         const vec3 background(0,0,0);
         ...
-                    color += ray_color(r, background, world, max_depth);
+                    pixel_color += ray_color(r, background, world, max_depth);
         ...
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

books/RayTracingTheRestOfYourLife.html

@@ -844,7 +844,7 @@
 </div>
 
 <div class='together'>
-And the color function gets a minor modification:
+And the `ray_color` function gets a minor modification:
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     vec3 ray_color(const ray& r, const vec3& background, const hittable& world, int depth) {

src/InOneWeekend/main.cc

@@ -105,14 +105,14 @@ int main() {
     for (int j = image_height-1; j >= 0; --j) {
         std::cerr << "\rScanlines remaining: " << j << ' ' << std::flush;
         for (int i = 0; i < image_width; ++i) {
-            vec3 color;
+            vec3 pixel_color;
             for (int s = 0; s < samples_per_pixel; ++s) {
                 auto u = (i + random_double()) / image_width;
                 auto v = (j + random_double()) / image_height;
                 ray r = cam.get_ray(u, v);
-                color += ray_color(r, world, max_depth);
+                pixel_color += ray_color(r, world, max_depth);
             }
-            color.write_color(std::cout, samples_per_pixel);
+            pixel_color.write_color(std::cout, samples_per_pixel);
         }
     }
 

src/TheNextWeek/main.cc

@@ -449,14 +449,14 @@ int main() {
     for (int j = image_height-1; j >= 0; --j) {
         std::cerr << "\rScanlines remaining: " << j << ' ' << std::flush;
         for (int i = 0; i < image_width; ++i) {
-            vec3 color;
+            vec3 pixel_color;
             for (int s = 0; s < samples_per_pixel; ++s) {
                 auto u = (i + random_double()) / image_width;
                 auto v = (j + random_double()) / image_height;
                 ray r = cam.get_ray(u, v);
-                color += ray_color(r, background, world, max_depth);
+                pixel_color += ray_color(r, background, world, max_depth);
             }
-            color.write_color(std::cout, samples_per_pixel);
+            pixel_color.write_color(std::cout, samples_per_pixel);
         }
     }
 

src/TheRestOfYourLife/main.cc

@@ -120,14 +120,14 @@ int main() {
     for (int j = image_height-1; j >= 0; --j) {
         std::cerr << "\rScanlines remaining: " << j << ' ' << std::flush;
         for (int i = 0; i < image_width; ++i) {
-            vec3 color;
+            vec3 pixel_color;
             for (int s = 0; s < samples_per_pixel; ++s) {
                 auto u = (i + random_double()) / image_width;
                 auto v = (j + random_double()) / image_height;
                 ray r = cam.get_ray(u, v);
-                color += ray_color(r, background, world, lights, max_depth);
+                pixel_color += ray_color(r, background, world, lights, max_depth);
             }
-            color.write_color(std::cout, samples_per_pixel);
+            pixel_color.write_color(std::cout, samples_per_pixel);
         }
     }