Move random_in_unit_disk() from camera.h to vec3.h

In addition, I've updated the text around defocus blur.

Author: hollasch

books/RayTracingInOneWeekend.html

@@ -2164,31 +2164,43 @@
 
 The reason we defocus blur in real cameras is because they need a big hole (rather than just a
 pinhole) to gather light. This would defocus everything, but if we stick a lens in the hole, there
-will be a certain distance where everything is in focus. The distance to that plane where things are
-in focus is controlled by the distance between the lens and the film/sensor. That is why you see the
-lens move relative to the camera when you change what is in focus (that may happen in your phone
-camera too, but the sensor moves). The “aperture” is a hole to control how big the lens is
-effectively. For a real camera, if you need more light you make the aperture bigger, and will get
-more defocus blur. For our virtual camera, we can have a perfect sensor and never need more light,
-so we only have an aperture when we want defocus blur.
-
-A real camera has a compound lens that is complicated. For our code we could simulate the order:
-sensor, then lens, then aperture, and figure out where to send the rays and flip the image once
-computed (the image is projected upside down on the film). Graphics people usually use a thin lens
-approximation.
+will be a certain distance where everything is in focus. You can think of a lens this way: all light
+rays coming _from_ a specific point at the focal distance -- and that hit the lens -- will be bent
+back _to_ a single point on the image sensor.
+
+In a physical camera, the distance to that plane where things are in focus is controlled by the
+distance between the lens and the film/sensor. That is why you see the lens move relative to the
+camera when you change what is in focus (that may happen in your phone camera too, but the sensor
+moves). The “aperture” is a hole to control how big the lens is effectively. For a real camera, if
+you need more light you make the aperture bigger, and will get more defocus blur. For our virtual
+camera, we can have a perfect sensor and never need more light, so we only have an aperture when we
+want defocus blur.
+
+<div class="together">
+A real camera has a complicated compound lens. For our code we could simulate the order: sensor,
+then lens, then aperture, and figure out where to send the rays and flip the image once computed
+(the image is projected upside down on the film). Graphics people usually use a thin lens
+approximation:
 
   ![Figure [cam-lens]: Camera lens model](../images/fig.cam-lens.jpg)
 
-We also don’t need to simulate any of the inside of the camera. For the purposes of rendering an
-image outside the camera, that would be unnecessary complexity. Instead I usually start rays from
-the surface of the lens, and send them toward a virtual film plane, by finding the projection of the
+</div>
+
+<div class="together">
+We don’t need to simulate any of the inside of the camera. For the purposes of rendering an image
+outside the camera, that would be unnecessary complexity. Instead, I usually start rays from the
+surface of the lens, and send them toward a virtual film plane, by finding the projection of the
 film on the plane that is in focus (at the distance `focus_dist`).
 
   ![Figure [cam-film-plane]: Camera focus plane](../images/fig.cam-film-plane.jpg)
 
-<div class='together'>
-For that we just need to have the ray origins be on a disk around `lookfrom` rather than from a
-point:
+</div>
+
+Normally, all scene rays originate from the `lookfrom` point. In order to accomplish defocus blur,
+generate random scene rays originating from inside a disk centered at the `lookfrom` point. The
+larger the radius, the greater the defocus blur. You can think of our original camera as having a
+defocus disk of radius zero (no blur at all), so all rays originated at the disk center
+(`lookfrom`).
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     vec3 random_in_unit_disk() {
@@ -2198,7 +2210,10 @@
         } while (dot(p,p) >= 1.0);
         return p;
     }
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    [Listing [rand-in-unit-disk]: <kbd>[vec3.h]</kbd> Generate random point inside unit disk]
 
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     class camera {
         public:
             camera(
@@ -2253,7 +2268,6 @@
     };
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     [Listing [camera-dof]: <kbd>[camera.h]</kbd> Camera with adjustable depth-of-field (dof)]
-</div>
 
 <div class='together'>
 Using a big aperture:

src/common/camera.h

@@ -14,14 +14,6 @@
 #include "common/rtweekend.h"
 
 
-vec3 random_in_unit_disk() {
-    vec3 p;
-    do {
-        p = 2.0*vec3(random_double(),random_double(),0) - vec3(1,1,0);
-    } while (dot(p,p) >= 1.0);
-    return p;
-}
-
 class camera {
     public:
         camera(
@@ -52,7 +44,7 @@ class camera {
         }
 
         ray get_ray(double s, double t) {
-            vec3 rd = lens_radius*random_in_unit_disk();
+            vec3 rd = lens_radius * random_in_unit_disk();
             vec3 offset = u * rd.x() + v * rd.y();
             auto time = time0 + random_double()*(time1-time0);
             return ray(

src/common/vec3.h

@@ -123,4 +123,12 @@ inline vec3 unit_vector(vec3 v) {
     return v / v.length();
 }
 
+vec3 random_in_unit_disk() {
+    vec3 p;
+    do {
+        p = 2.0*vec3(random_double(),random_double(),0) - vec3(1,1,0);
+    } while (dot(p,p) >= 1.0);
+    return p;
+}
+
 #endif