Update camera code

In the prior code, changes to camera variables would require associated
changes to a number of other related variables, in ways that were not
apparent. This change uses variables a more consistent manner, where
changing any particular variable should yield consistent results in
other values.

In addition, this provides a more consistent series of iterative steps
as the camera develops through the text.

Resolves #527

Author: hollasch

books/RayTracingInOneWeekend.html

@@ -466,12 +466,21 @@
 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
-camera) at $(0,0,0)$. I will have the y-axis go up, and the x-axis to the right. In order to respect
-the convention of a right handed coordinate system, into the screen is the negative z-axis. I will
-traverse the screen from the lower left hand corner, and use two offset vectors along the screen
-sides to move the ray endpoint across the screen. Note that I do not make the ray direction a unit
-length vector because I think not doing that makes for simpler and slightly faster code.
+often, so I’ll use a non-square image. For now we'll use a 16:9 aspect ratio, since that's so
+common.
+
+In addition to setting up the pixel dimensions for the rendered image, we also need to set up a
+virtual viewport through which to pass our scene rays. For the standard square pixel spacing, the
+viewport's aspect ratio should be the same as our rendered image. We'll just pick a viewport two
+units in height. Ultimately, changing the scale of the viewport (while holding the focal distance
+constant) is equivalent to changing the viewing angle, or “zoom” of the image.
+
+I’ll put the “eye” (or camera center if you think of a camera) at $(0,0,0)$. I will have the y-axis
+go up, and the x-axis to the right. In order to respect the convention of a right handed coordinate
+system, into the screen is the negative z-axis. I will traverse the screen from the lower left hand
+corner, and use two offset vectors along the screen sides to move the ray endpoint across the
+screen. Note that I do not make the ray direction a unit length vector because I think not doing
+that makes for simpler and slightly faster code.
 
   ![Figure [cam-geom]: Camera geometry](../images/fig.cam-geom.jpg)
 
@@ -497,19 +506,25 @@
 
         std::cout << "P3\n" << image_width << " " << image_height << "\n255\n";
 
+
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
-        point3 origin(0.0, 0.0, 0.0);
-        vec3 horizontal(4.0, 0.0, 0.0);
-        vec3 vertical(0.0, 2.25, 0.0);
-        point3 lower_left_corner = origin - horizontal/2 - vertical/2 - vec3(0,0,1);
+        auto viewport_height = 2.0;
+        auto viewport_width = aspect_ratio * viewport_height;
+        auto focal_length = 1.0;
+
+        auto origin = point3(0, 0, 0);
+        auto horizontal = vec3(viewport_width, 0, 0);
+        auto vertical = vec3(0, viewport_height, 0);
+        auto lower_left_corner = origin - horizontal/2 - vertical/2 - vec3(0, 0, focal_length);
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
+
         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
                 auto u = double(i) / (image_width-1);
                 auto v = double(j) / (image_height-1);
-                ray r(origin, lower_left_corner + u*horizontal + v*vertical);
+                ray r(origin, lower_left_corner + u*horizontal + v*vertical - origin);
                 color pixel_color = ray_color(r);
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
                 write_color(std::cout, pixel_color);
@@ -1201,10 +1216,14 @@
 
         std::cout << "P3\n" << image_width << ' ' << image_height << "\n255\n";
 
-        point3 lower_left_corner(-2.0, -1.0, -1.0);
-        vec3 horizontal(4.0, 0.0, 0.0);
-        vec3 vertical(0.0, 2.0, 0.0);
-        point3 origin(0.0, 0.0, 0.0);
+        auto viewport_height = 2.0;
+        auto viewport_width = aspect_ratio * viewport_height;
+        auto focal_length = 1.0;
+
+        auto origin = point3(0, 0, 0);
+        auto horizontal = vec3(viewport_width, 0, 0);
+        auto vertical = vec3(0, viewport_height, 0);
+        auto lower_left_corner = origin - horizontal/2 - vertical/2 - vec3(0, 0, focal_length);
 
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
@@ -1313,7 +1332,8 @@
 </div>
 
 <div class='together'>
-Putting that all together yields a camera class encapsulating our simple axis-aligned camera from
+Now's a good time to create a `camera` class to manage our virtual camera and the related tasks of
+scene scampling. The following class implements a simple camera using the axis-aligned camera from
 before:
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
@@ -1325,10 +1345,15 @@
     class camera {
         public:
             camera() {
-                lower_left_corner = point3(-2.0, -1.0, -1.0);
-                horizontal = vec3(4.0, 0.0, 0.0);
-                vertical = vec3(0.0, 2.0, 0.0);
-                origin = point3(0.0, 0.0, 0.0);
+                auto aspect_ratio = 16.0 / 9.0;
+                auto viewport_height = 2.0;
+                auto viewport_width = aspect_ratio * viewport_height;
+                auto focal_length = 1.0;
+
+                origin = point3(0, 0, 0);
+                horizontal = vec3(viewport_width, 0.0, 0.0);
+                vertical = vec3(0.0, viewport_height, 0.0);
+                lower_left_corner = origin - horizontal/2 - vertical/2 - vec3(0, 0, focal_length);
             }
 
             ray get_ray(double u, double v) const {
@@ -1399,9 +1424,11 @@
         world.add(make_shared<sphere>(point3(0,0,-1), 0.5));
         world.add(make_shared<sphere>(point3(0,-100.5,-1), 100));
 
+
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
         camera cam;
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
+
         for (int j = image_height-1; j >= 0; --j) {
             std::cerr << "\rScanlines remaining: " << j << ' ' << std::flush;
             for (int i = 0; i < image_width; ++i) {
@@ -1882,7 +1909,6 @@
         double t;
         bool front_face;
 
-
         inline void set_face_normal(const ray& r, const vec3& outward_normal) {
             front_face = dot(r.direction(), outward_normal) < 0;
             normal = front_face ? outward_normal :-outward_normal;
@@ -2107,6 +2133,7 @@
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
 
         camera cam;
+
         for (int j = image_height-1; j >= 0; --j) {
             std::cerr << "\rScanlines remaining: " << j << ' ' << std::flush;
             for (int i = 0; i < image_width; ++i) {
@@ -2551,16 +2578,17 @@
                 double vfov, // vertical field-of-view in degrees
                 double aspect_ratio
             ) {
-                origin = point3(0.0, 0.0, 0.0);
-
                 auto theta = degrees_to_radians(vfov);
-                auto half_height = tan(theta/2);
-                auto half_width = aspect_ratio * half_height;
+                auto h = tan(theta/2);
+                auto viewport_height = 2.0 * h;
+                auto viewport_width = aspect_ratio * viewport_height;
 
-                lower_left_corner = point3(-half_width, -half_height, -1.0);
+                auto focal_length = 1.0;
 
-                horizontal = vec3(2*half_width, 0.0, 0.0);
-                vertical = vec3(0.0, 2*half_height, 0.0);
+                origin = point3(0, 0, 0);
+                horizontal = vec3(viewport_width, 0.0, 0.0);
+                vertical = vec3(0.0, viewport_height, 0.0);
+                lower_left_corner = origin - horizontal/2 - vertical/2 - vec3(0, 0, focal_length);
             }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
 
@@ -2626,29 +2654,28 @@
         public:
             camera(
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
-                point3 lookfrom, point3 lookat, vec3 vup,
+                point3 lookfrom,
+                point3 lookat,
+                vec3   vup,
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
                 double vfov, // vertical field-of-view in degrees
                 double aspect_ratio
             ) {
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
-                origin = lookfrom;
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-                vec3 u, v, w;
-
                 auto theta = degrees_to_radians(vfov);
-                auto half_height = tan(theta/2);
-                auto half_width = aspect_ratio * half_height;
+                auto h = tan(theta/2);
+                auto viewport_height = 2.0 * h;
+                auto viewport_width = aspect_ratio * viewport_height;
 
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
-                w = unit_vector(lookfrom - lookat);
-                u = unit_vector(cross(vup, w));
-                v = cross(w, u);
 
-                lower_left_corner = origin - half_width*u - half_height*v - w;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
+                auto w = unit_vector(lookfrom - lookat);
+                auto u = unit_vector(cross(vup, w));
+                auto v = cross(w, u);
 
-                horizontal = 2*half_width*u;
-                vertical = 2*half_height*v;
+                origin = lookfrom;
+                horizontal = viewport_width * u;
+                vertical = viewport_height * v;
+                lower_left_corner = origin - horizontal/2 - vertical/2 - w;
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
             }
 
@@ -2759,31 +2786,35 @@
     class camera {
         public:
             camera(
-                point3 lookfrom, point3 lookat, vec3 vup,
+                point3 lookfrom,
+                point3 lookat,
+                vec3   vup,
                 double vfov, // vertical field-of-view in degrees
+                double aspect_ratio,
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
-                double aspect_ratio, double aperture, double focus_dist
-            ) {
-                origin = lookfrom;
-                lens_radius = aperture / 2;
+                double aperture,
+                double focus_dist
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-
+            ) {
                 auto theta = degrees_to_radians(vfov);
-                auto half_height = tan(theta/2);
-                auto half_width = aspect_ratio * half_height;
+                auto h = tan(theta/2);
+                auto viewport_height = 2.0 * h;
+                auto viewport_width = aspect_ratio * viewport_height;
 
+
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
                 w = unit_vector(lookfrom - lookat);
                 u = unit_vector(cross(vup, w));
                 v = cross(w, u);
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
 
+                origin = lookfrom;
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
-                lower_left_corner = origin
-                                  - half_width * focus_dist * u
-                                  - half_height * focus_dist * v
-                                  - focus_dist * w;
+                horizontal = focus_dist * viewport_width * u;
+                vertical = focus_dist * viewport_height * v;
+                lower_left_corner = origin - horizontal/2 - vertical/2 - focus_dist*w;
 
-                horizontal = 2*half_width*focus_dist*u;
-                vertical = 2*half_height*focus_dist*v;
+                lens_radius = aperture / 2;
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
             }
 

books/RayTracingTheNextWeek.html

@@ -108,35 +108,37 @@
     class camera {
         public:
             camera(
-                point3 lookfrom, point3 lookat, vec3 vup,
+                point3 lookfrom,
+                point3 lookat,
+                vec3   vup,
                 double vfov, // vertical field-of-view in degrees
-                double aspect_ratio, double aperture, double focus_dist,
+                double aspect_ratio,
+                double aperture,
+                double focus_dist,
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
-                double t0 = 0, double t1 = 0
+                double t0 = 0,
+                double t1 = 0
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
             ) {
-                origin = lookfrom;
-                lens_radius = aperture / 2;
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
-                time0 = t0;
-                time1 = t1;
-
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
                 auto theta = degrees_to_radians(vfov);
-                auto half_height = tan(theta/2);
-                auto half_width = aspect * half_height;
+                auto h = tan(theta/2);
+                auto viewport_height = 2.0 * h;
+                auto viewport_width = aspect_ratio * viewport_height;
 
                 w = unit_vector(lookfrom - lookat);
                 u = unit_vector(cross(vup, w));
                 v = cross(w, u);
 
-                lower_left_corner = origin
-                                  - half_width*focus_dist*u
-                                  - half_height*focus_dist*v
-                                  - focus_dist*w;
+                origin = lookfrom;
+                horizontal = focus_dist * viewport_width * u;
+                vertical = focus_dist * viewport_height * v;
+                lower_left_corner = origin - horizontal/2 - vertical/2 - focus_dist*w;
 
-                horizontal = 2*half_width*focus_dist*u;
-                vertical = 2*half_height*focus_dist*v;
+                lens_radius = aperture / 2;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
+                time0 = t0;
+                time1 = t1;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
             }
 
             ray get_ray(double s, double t) const {

src/common/camera.h

@@ -19,31 +19,33 @@ class camera {
         camera() : camera(point3(0,0,-1), point3(0,0,0), vec3(0,1,0), 40, 1, 0, 10) {}
 
         camera(
-            point3 lookfrom, point3 lookat, vec3 vup,
+            point3 lookfrom,
+            point3 lookat,
+            vec3   vup,
             double vfov, // vertical field-of-view in degrees
-            double aspect_ratio, double aperture, double focus_dist,
-            double t0 = 0, double t1 = 0
+            double aspect_ratio,
+            double aperture,
+            double focus_dist,
+            double t0 = 0,
+            double t1 = 0
         ) {
-            origin = lookfrom;
-            lens_radius = aperture / 2;
-            time0 = t0;
-            time1 = t1;
-
             auto theta = degrees_to_radians(vfov);
-            auto half_height = tan(theta/2);
-            auto half_width = aspect_ratio * half_height;
+            auto h = tan(theta/2);
+            auto viewport_height = 2.0 * h;
+            auto viewport_width = aspect_ratio * viewport_height;
 
             w = unit_vector(lookfrom - lookat);
             u = unit_vector(cross(vup, w));
             v = cross(w, u);
 
-            lower_left_corner = origin
-                              - half_width*focus_dist*u
-                              - half_height*focus_dist*v
-                              - focus_dist*w;
+            origin = lookfrom;
+            horizontal = focus_dist * viewport_width * u;
+            vertical = focus_dist * viewport_height * v;
+            lower_left_corner = origin - horizontal/2 - vertical/2 - focus_dist*w;
 
-            horizontal = 2*half_width*focus_dist*u;
-            vertical = 2*half_height*focus_dist*v;
+            lens_radius = aperture / 2;
+            time0 = t0;
+            time1 = t1;
         }
 
         ray get_ray(double s, double t) const {