aabb: fix performance puzzle with aabb::hit()

It turns out that the slow version, preserved in the original code, had
a bug in that it failed to tighten the `ray_t` interval with each
successive iteration through the X, Y and Z axes. Instead, it was
modifying temporary variables.

This change cleans up the two versions of the `hit()` method, and aligns
the text's version with our codebase.

Resolves #817

Author: hollasch

books/RayTracingTheNextWeek.html

@@ -682,14 +682,19 @@
         ...
         bool hit(const ray& r, interval ray_t) const {
             for (int a = 0; a < 3; a++) {
-                auto invD = 1.0f / r.direction()[a];
-                auto t0 = (min()[a] - r.origin()[a]) * invD;
-                auto t1 = (max()[a] - r.origin()[a]) * invD;
-                if (invD < 0.0f)
+                const auto invD = 1 / r.direction()[a];
+                const auto orig = r.origin()[a];
+
+                auto t0 = (axis(a).min - orig) * invD;
+                auto t1 = (axis(a).max - orig) * invD;
+
+                if (invD < 0)
                     std::swap(t0, t1);
-                auto ray_tmin = t0 > ray_t.min ? t0 : ray_t.min;
-                auto ray_tmax = t1 < ray_t.max ? t1 : ray_t.max;
-                if (ray_tmax <= ray_tmin)
+
+                if (t0 > ray_t.min) ray_t.min = t0;
+                if (t1 < ray_t.max) ray_t.max = t1;
+
+                if (ray_t.max <= ray_t.min)
                     return false;
             }
             return true;

src/common/aabb.h

@@ -51,43 +51,25 @@ class aabb {
         return x;
     }
 
-    #if 1
-        // GitHub Issue #817
-        // For some reason I haven't figured out yet, this version is 10x faster than the
-        // version below. I'll come back and figure out why (and in the process, probably figure
-        // out how to configure CMake to create a profile build). Parking this here for now, to
-        // be removed before the v4 release.
-
-        bool hit(const ray& r, interval ray_t) const {
-            for (int a = 0; a < 3; a++) {
-                auto t0 = fmin((axis(a).min - r.origin()[a]) / r.direction()[a],
-                               (axis(a).max - r.origin()[a]) / r.direction()[a]);
-                auto t1 = fmax((axis(a).min - r.origin()[a]) / r.direction()[a],
-                               (axis(a).max - r.origin()[a]) / r.direction()[a]);
-                ray_t.min = fmax(t0, ray_t.min);
-                ray_t.max = fmin(t1, ray_t.max);
-                if (ray_t.max <= ray_t.min)
-                    return false;
-            }
-            return true;
-        }
-    #else
-        bool hit(const ray& r, interval ray_t) const {
-            auto r_origin = r.origin();
-            auto r_dir = r.direction();
-            for (int a = 0; a < 3; a++) {
-                auto invD = 1.0f / r_dir[a];
-                auto orig = r_origin[a];
-                auto t0 = (axis(a).min - orig) * invD;
-                auto t1 = (axis(a).max - orig) * invD;
-                if (invD < 0)
-                    std::swap(t0, t1);
-                if (fmin(t1, ray_t.max) <= fmax(t0, ray_t.min))
-                    return false;
-            }
-            return true;
+    bool hit(const ray& r, interval ray_t) const {
+        for (int a = 0; a < 3; a++) {
+            const auto invD = 1 / r.direction()[a];
+            const auto orig = r.origin()[a];
+
+            auto t0 = (axis(a).min - orig) * invD;
+            auto t1 = (axis(a).max - orig) * invD;
+
+            if (invD < 0)
+                std::swap(t0, t1);
+
+            if (t0 > ray_t.min) ray_t.min = t0;
+            if (t1 < ray_t.max) ray_t.max = t1;
+
+            if (ray_t.max <= ray_t.min)
+                return false;
         }
-    #endif
+        return true;
+    }
 
   public:
     interval x, y, z;