Merge pull request #913 from RayTracing/tdb/instance_clarity

hollasch · web-flow · commit 62ce2e6a1f08 · 2021-09-12T21:59:52.000-07:00
Added world space and object space explanation
diff --git a/books/RayTracingTheNextWeek.html b/books/RayTracingTheNextWeek.html
@@ -2975,12 +2975,14 @@
 
 <div class='together'>
 Now that we have boxes, we need to rotate them a bit to have them match the _real_ Cornell box. In
-ray tracing, this is usually done with an _instance_. An instance is a geometric primitive that has
-been moved or rotated somehow. This is especially easy in ray tracing because we don’t move
-anything; instead we move the rays in the opposite direction. For example, consider a _translation_
-(often called a _move_). We could take the pink box at the origin and add 2 to all its x components,
-or (as we almost always do in ray tracing) leave the box where it is, but in its hit routine
-subtract 2 off the x-component of the ray origin.
+ray tracing, this is usually done with an _instance_. An instance is a copy of a geometric
+primitive that has been placed into the scene. This instance is entirely independent of the other
+copies of the primitive and can be moved or rotated. In this case, our geometric primitive is our
+hittable `box` object, and we want to rotate it. This is especially easy in ray tracing because we
+don’t actually need to move objects in the scene; instead we move the rays in the opposite
+direction. For example, consider a _translation_ (often called a _move_). We could take the pink box
+at the origin and add two to all its x components, or (as we almost always do in ray tracing) leave
+the box where it is, but in its hit routine subtract two off the x-component of the ray origin.
 
   ![Figure [ray-box]: Ray-box intersection with moved ray vs box](../images/fig-2.08-ray-box.jpg)
 
@@ -2990,41 +2992,83 @@
 Instance Translation
 ---------------------
 <div class='together'>
-Whether you think of this as a move or a change of coordinates is up to you. The code for this, to
-move any underlying hittable is a _translate_ instance.
+Whether you think of this as a move or a change of coordinates is up to you. The way to reason about
+this is to think of moving the incident ray backwards the offset amount, determining if an
+intersection occurs, and then moving that intersection point forward the offset amount.
+
+We need to move the intersection point forward the offset amount so that the intersection is
+actually in the path of the incident ray. If we forgot to move the intersection point forward then
+the intersection would be in the path of the offset ray, which isn't correct. Let's add the code to
+make this happen.
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     class translate : public hittable {
       public:
+        ...
+
+        bool hit(const ray& r, interval ray_t, hit_record& rec) const override {
+            // Move the ray backwards by the offset
+            ray offset_r(r.origin() - offset, r.direction(), r.time());
+
+            // Determine where (if any) an intersection occurs along the offset ray
+            if (!object->hit(offset_r, ray_t, rec))
+                return false;
+
+            // Move the intersection point forwards by the offset
+            rec.p += offset;
+
+            return true;
+        }
+
+        ...
+    };
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    [Listing [translate-hit]: <kbd>[hittable.h]</kbd> Hittable translation hit function]
+
+... and then flesh out the rest of the `translate` class:
+
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
+    class translate : public hittable {
+      public:
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
         translate(shared_ptr<hittable> p, const vec3& displacement)
           : object(p), offset(displacement)
         {
             bbox = object->bounding_box() + offset;
         }
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
 
         bool hit(const ray& r, interval ray_t, hit_record& rec) const override {
-            ray moved_r(r.origin() - offset, r.direction(), r.time());
-            if (!object->hit(moved_r, ray_t, rec))
+            // Move the ray backwards by the offset
+            ray offset_r(r.origin() - offset, r.direction(), r.time());
+
+            // Determine where (if any) an intersection occurs along the offset ray
+            if (!object->hit(offset_r, ray_t, rec))
                 return false;
 
+            // Move the intersection point forwards by the offset
             rec.p += offset;
-            rec.set_face_normal(moved_r, rec.normal);
 
             return true;
         }
 
+
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
         aabb bounding_box() const override { return bbox; }
 
       public:
         shared_ptr<hittable> object;
         vec3 offset;
         aabb bbox;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     };
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     [Listing [translate-class]: <kbd>[hittable.h]</kbd> Hittable translation class]
 </div>
 
-The expression `object->bounding_box() + offset` above requires some additional support.
+We also need to remember to offset the bounding box, otherwise the incident ray might be looking in
+the wrong place and trivially reject the intersection. The expression
+`object->bounding_box() + offset` above requires some additional support.
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     class aabb {
@@ -3101,24 +3145,99 @@
   $$ x' =  \cos(\theta) \cdot x + \sin(\theta) \cdot z $$
   $$ z' = -\sin(\theta) \cdot x + \cos(\theta) \cdot z $$
 
-And about the x-axis:
+And if we want to rotate about the x-axis:
 
   $$ y' = \cos(\theta) \cdot y - \sin(\theta) \cdot z $$
   $$ z' = \sin(\theta) \cdot y + \cos(\theta) \cdot z $$
 </div>
 
-Unlike the situation with translations, the surface normal vector also changes, so we need to
-transform directions too if we get a hit. Fortunately for rotations, the same formulas apply. If you
-add scales, things get more complicated. See the web page https://in1weekend.blogspot.com/ for links
-to that.
+Thinking of translation as a simple movement of the initial ray is a fine way to reason about what's
+going on. But, for a more complex operation like a rotation, it can be easy to accidentally get your
+terms crossed (or forget a negative sign), so it's better to consider a rotation as a change of
+coordinates.
+
+The pseudocode for the `translate::hit` function above describes the function in terms of _moving_:
+
+1. Move the ray backwards by the offset
+2. Determine whether an intersection exists along the offset ray (and if so, where)
+3. Move the intersection point forwards by the offset
+
+But this can also be thought of in terms of a _changing of coordinates_:
+
+1. Change the ray from world space to object space
+2. Determine whether an intersection exists in object space (and if so, where)
+3. Change the intersection point from object space to world space
+
 
 <div class='together'>
-For a y-rotation class we have:
+Rotating an object will not only change the point of intersection, but will also change the surface
+normal vector, which will change the direction of reflections and refractions. So we need to change
+the normal as well. Fortunately, the normal will rotate similarly to a vector, so we can use the
+same formulas as above.  While normals and vectors may appear identical for an object undergoing
+rotation and translation, an object undergoing scaling requires special attention to keep the
+normals orthogonal to the surface. We won't cover that here, but you should research surface normal
+transformations if you implement scaling.
+
+We need to start by changing the ray from world space to object space, which for rotation means
+rotating by $-\theta$.
+
+  $$ x' = \cos(\theta) \cdot x - \sin(\theta) \cdot z $$
+  $$ z' = \sin(\theta) \cdot x + \cos(\theta) \cdot z $$
+
+We can now create a class for y-rotation:
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     class rotate_y : public hittable {
       public:
-        rotate_y(shared_ptr<hittable> p, double angle) : object(p) {
+        ...
+
+        bool hit(const ray& r, interval ray_t, hit_record& rec) const override {
+            // Change the ray from world space to object space
+            auto origin = r.origin();
+            auto direction = r.direction();
+
+            origin[0] = cos_theta*r.origin()[0] - sin_theta*r.origin()[2];
+            origin[2] = sin_theta*r.origin()[0] + cos_theta*r.origin()[2];
+
+            direction[0] = cos_theta*r.direction()[0] - sin_theta*r.direction()[2];
+            direction[2] = sin_theta*r.direction()[0] + cos_theta*r.direction()[2];
+
+            ray rotated_r(origin, direction, r.time());
+
+            // Determine where (if any) an intersection occurs in object space
+            if (!object->hit(rotated_r, ray_t, rec))
+                return false;
+
+            // Change the intersection point from object space to world space
+            auto p = rec.p;
+            p[0] =  cos_theta*rec.p[0] + sin_theta*rec.p[2];
+            p[2] = -sin_theta*rec.p[0] + cos_theta*rec.p[2];
+
+            // Change the normal from object space to world space
+            auto normal = rec.normal
+            normal[0] =  cos_theta*rec.normal[0] + sin_theta*rec.normal[2];
+            normal[2] = -sin_theta*rec.normal[0] + cos_theta*rec.normal[2];
+
+            rec.p = p;
+            rec.normal = normal;
+
+            return true;
+        }
+
+        ...
+    };
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    [Listing [rot-y-hit]: <kbd>[hittable.h]</kbd> Hittable rotate-Y hit function]
+
+</div>
+... and now for the rest of the class:
+
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
+    class rotate_y : public hittable {
+      public:
+
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
+            rotate_y(shared_ptr<hittable> p, double angle) : object(p) {
             auto radians = degrees_to_radians(angle);
             sin_theta = sin(radians);
             cos_theta = cos(radians);
@@ -3149,48 +3268,25 @@
 
             bbox = aabb(min, max);
         }
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
 
         bool hit(const ray& r, interval ray_t, hit_record& rec) const override {
-            auto origin = r.origin();
-            auto direction = r.direction();
-
-            origin[0] = cos_theta*r.origin()[0] - sin_theta*r.origin()[2];
-            origin[2] = sin_theta*r.origin()[0] + cos_theta*r.origin()[2];
-
-            direction[0] = cos_theta*r.direction()[0] - sin_theta*r.direction()[2];
-            direction[2] = sin_theta*r.direction()[0] + cos_theta*r.direction()[2];
-
-            ray rotated_r(origin, direction, r.time());
-
-            if (!object->hit(rotated_r, ray_t, rec))
-                return false;
-
-            auto p = rec.p;
-            auto normal = rec.normal;
-
-            p[0] =  cos_theta*rec.p[0] + sin_theta*rec.p[2];
-            p[2] = -sin_theta*rec.p[0] + cos_theta*rec.p[2];
-
-            normal[0] =  cos_theta*rec.normal[0] + sin_theta*rec.normal[2];
-            normal[2] = -sin_theta*rec.normal[0] + cos_theta*rec.normal[2];
-
-            rec.p = p;
-            rec.set_face_normal(rotated_r, normal);
-
-            return true;
+            ...
         }
 
+
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
         aabb bounding_box() const override { return bbox; }
 
       public:
         shared_ptr<hittable> object;
         double sin_theta;
         double cos_theta;
         aabb bbox;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     };
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     [Listing [rot-y]: <kbd>[hittable.h]</kbd> Hittable rotate-Y class]
-</div>
 
 <div class='together'>
 And the changes to Cornell are:
diff --git a/src/TheNextWeek/hittable.h b/src/TheNextWeek/hittable.h
@@ -55,12 +55,15 @@ class translate : public hittable {
     }
 
     bool hit(const ray& r, interval ray_t, hit_record& rec) const override {
-        ray moved_r(r.origin() - offset, r.direction(), r.time());
-        if (!object->hit(moved_r, ray_t, rec))
+        // Move the ray backwards by the offset
+        ray offset_r(r.origin() - offset, r.direction(), r.time());
+
+        // Determine whether an intersection exists along the offset ray (and if so, where)
+        if (!object->hit(offset_r, ray_t, rec))
             return false;
 
+        // Move the intersection point forwards by the offset
         rec.p += offset;
-        rec.set_face_normal(moved_r, rec.normal);
 
         return true;
     }
@@ -109,6 +112,7 @@ class rotate_y : public hittable {
     }
 
     bool hit(const ray& r, interval ray_t, hit_record& rec) const override {
+        // Change the ray from world space to object space
         auto origin = r.origin();
         auto direction = r.direction();
 
@@ -120,20 +124,22 @@ class rotate_y : public hittable {
 
         ray rotated_r(origin, direction, r.time());
 
+        // Determine whether an intersection exists in object space (and if so, where)
         if (!object->hit(rotated_r, ray_t, rec))
             return false;
 
+        // Change the intersection point from object space to world space
         auto p = rec.p;
-        auto normal = rec.normal;
-
         p[0] =  cos_theta*rec.p[0] + sin_theta*rec.p[2];
         p[2] = -sin_theta*rec.p[0] + cos_theta*rec.p[2];
 
+        // Change the normal from object space to world space
+        auto normal = rec.normal;
         normal[0] =  cos_theta*rec.normal[0] + sin_theta*rec.normal[2];
         normal[2] = -sin_theta*rec.normal[0] + cos_theta*rec.normal[2];
 
         rec.p = p;
-        rec.set_face_normal(rotated_r, normal);
+        rec.normal = normal;
 
         return true;
     }
diff --git a/src/TheRestOfYourLife/hittable.h b/src/TheRestOfYourLife/hittable.h
@@ -63,12 +63,15 @@ class translate : public hittable {
     }
 
     bool hit(const ray& r, interval ray_t, hit_record& rec) const override {
-        ray moved_r(r.origin() - offset, r.direction(), r.time());
-        if (!object->hit(moved_r, ray_t, rec))
+        // Move the ray backwards by the offset
+        ray offset_r(r.origin() - offset, r.direction(), r.time());
+
+        // Determine whether an intersection exists along the offset ray (and if so, where)
+        if (!object->hit(offset_r, ray_t, rec))
             return false;
 
+        // Move the intersection point forwards by the offset
         rec.p += offset;
-        rec.set_face_normal(moved_r, rec.normal);
 
         return true;
     }
@@ -117,6 +120,7 @@ class rotate_y : public hittable {
     }
 
     bool hit(const ray& r, interval ray_t, hit_record& rec) const override {
+        // Change the ray from world space to object space
         auto origin = r.origin();
         auto direction = r.direction();
 
@@ -128,20 +132,22 @@ class rotate_y : public hittable {
 
         ray rotated_r(origin, direction, r.time());
 
+        // Determine whether an intersection exists in object space (and if so, where)
         if (!object->hit(rotated_r, ray_t, rec))
             return false;
 
+        // Change the intersection point from object space to world space
         auto p = rec.p;
-        auto normal = rec.normal;
-
         p[0] =  cos_theta*rec.p[0] + sin_theta*rec.p[2];
         p[2] = -sin_theta*rec.p[0] + cos_theta*rec.p[2];
 
+        // Change the normal from object space to world space
+        auto normal = rec.normal;
         normal[0] =  cos_theta*rec.normal[0] + sin_theta*rec.normal[2];
         normal[2] = -sin_theta*rec.normal[0] + cos_theta*rec.normal[2];
 
         rec.p = p;
-        rec.set_face_normal(rotated_r, normal);
+        rec.normal = normal;
 
         return true;
     }
