Refactor hittable.h for clarity

Author: hollasch

books/RayTracingTheNextWeek.html

@@ -2043,12 +2043,11 @@
             flip_face(shared_ptr<hittable> p) : ptr(p) {}
 
             virtual bool hit(const ray& r, double t_min, double t_max, hit_record& rec) const {
-                if (ptr->hit(r, t_min, t_max, rec)) {
-                    rec.front_face = !rec.front_face;
-                    return true;
-                }
-                else
+                if (!ptr->hit(r, t_min, t_max, rec))
                     return false;
+
+                rec.front_face = !rec.front_face;
+                return true;
             }
 
             virtual bool bounding_box(double t0, double t1, aabb& output_box) const {
@@ -2202,24 +2201,24 @@
 
     bool translate::hit(const ray& r, double t_min, double t_max, hit_record& rec) const {
         ray moved_r(r.origin() - offset, r.direction(), r.time());
-        if (ptr->hit(moved_r, t_min, t_max, rec)) {
-            rec.p += offset;
-            rec.set_face_normal(moved_r, rec.normal);
-            return true;
-        }
-        else
+        if (!ptr->hit(moved_r, t_min, t_max, rec))
             return false;
+
+        rec.p += offset;
+        rec.set_face_normal(moved_r, rec.normal);
+
+        return true;
     }
 
     bool translate::bounding_box(double t0, double t1, aabb& output_box) const {
-        if (ptr->bounding_box(t0, t1, output_box)) {
-            output_box = aabb(
-                output_box.min() + offset,
-                output_box.max() + offset);
-            return true;
-        }
-        else
+        if (!ptr->bounding_box(t0, t1, output_box))
             return false;
+
+        output_box = aabb(
+            output_box.min() + offset,
+            output_box.max() + offset);
+
+        return true;
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     [Listing [translate-class]: <kbd>[hittable.h]</kbd> Hittable translation class]
@@ -2300,26 +2299,30 @@
         sin_theta = sin(radians);
         cos_theta = cos(radians);
         hasbox = ptr->bounding_box(0, 1, bbox);
-        vec3 min(infinity, infinity, infinity);
+
+        vec3 min( infinity,  infinity,  infinity);
         vec3 max(-infinity, -infinity, -infinity);
+
         for (int i = 0; i < 2; i++) {
             for (int j = 0; j < 2; j++) {
                 for (int k = 0; k < 2; k++) {
                     auto x = i*bbox.max().x() + (1-i)*bbox.min().x();
                     auto y = j*bbox.max().y() + (1-j)*bbox.min().y();
                     auto z = k*bbox.max().z() + (1-k)*bbox.min().z();
-                    auto newx = cos_theta*x + sin_theta*z;
+
+                    auto newx =  cos_theta*x + sin_theta*z;
                     auto newz = -sin_theta*x + cos_theta*z;
+
                     vec3 tester(newx, y, newz);
+
                     for (int c = 0; c < 3; c++) {
-                        if (tester[c] > max[c])
-                            max[c] = tester[c];
-                        if (tester[c] < min[c])
-                            min[c] = tester[c];
+                        min[c] = ffmin(min[c], tester[c]);
+                        max[c] = ffmax(max[c], tester[c]);
                     }
                 }
             }
         }
+
         bbox = aabb(min, max);
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -2333,24 +2336,31 @@
     bool rotate_y::hit(const ray& r, double t_min, double t_max, hit_record& rec) const {
         vec3 origin = r.origin();
         vec3 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];
+        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 (ptr->hit(rotated_r, t_min, t_max, rec)) {
-            vec3 p = rec.p;
-            vec3 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;
-        }
-        else
+
+        if (!ptr->hit(rotated_r, t_min, t_max, rec))
             return false;
+
+        vec3 p = rec.p;
+        vec3 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;
     }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     [Listing [rot-y-hit]: <kbd>[hittable.h]</kbd> Hittable Y-rotate hit function]

src/TheNextWeek/hittable.h

@@ -53,12 +53,11 @@ class flip_face : public hittable {
         flip_face(shared_ptr<hittable> p) : ptr(p) {}
 
         virtual bool hit(const ray& r, double t_min, double t_max, hit_record& rec) const {
-            if (ptr->hit(r, t_min, t_max, rec)) {
-                rec.front_face = !rec.front_face;
-                return true;
-            }
-            else
+            if (!ptr->hit(r, t_min, t_max, rec))
                 return false;
+
+            rec.front_face = !rec.front_face;
+            return true;
         }
 
         virtual bool bounding_box(double t0, double t1, aabb& output_box) const {
@@ -86,25 +85,25 @@ class translate : public hittable {
 
 bool translate::hit(const ray& r, double t_min, double t_max, hit_record& rec) const {
     ray moved_r(r.origin() - offset, r.direction(), r.time());
-    if (ptr->hit(moved_r, t_min, t_max, rec)) {
-        rec.p += offset;
-        rec.set_face_normal(moved_r, rec.normal);
-        return true;
-    }
-    else
+    if (!ptr->hit(moved_r, t_min, t_max, rec))
         return false;
+
+    rec.p += offset;
+    rec.set_face_normal(moved_r, rec.normal);
+
+    return true;
 }
 
 
 bool translate::bounding_box(double t0, double t1, aabb& output_box) const {
-    if (ptr->bounding_box(t0, t1, output_box)) {
-        output_box = aabb(
-            output_box.min() + offset,
-            output_box.max() + offset);
-        return true;
-    }
-    else
+    if (!ptr->bounding_box(t0, t1, output_box))
         return false;
+
+    output_box = aabb(
+        output_box.min() + offset,
+        output_box.max() + offset);
+
+    return true;
 }
 
 
@@ -132,51 +131,63 @@ rotate_y::rotate_y(shared_ptr<hittable> p, double angle) : ptr(p) {
     sin_theta = sin(radians);
     cos_theta = cos(radians);
     hasbox = ptr->bounding_box(0, 1, bbox);
-    vec3 min(infinity, infinity, infinity);
+
+    vec3 min( infinity,  infinity,  infinity);
     vec3 max(-infinity, -infinity, -infinity);
+
     for (int i = 0; i < 2; i++) {
         for (int j = 0; j < 2; j++) {
             for (int k = 0; k < 2; k++) {
                 auto x = i*bbox.max().x() + (1-i)*bbox.min().x();
                 auto y = j*bbox.max().y() + (1-j)*bbox.min().y();
                 auto z = k*bbox.max().z() + (1-k)*bbox.min().z();
-                auto newx = cos_theta*x + sin_theta*z;
+
+                auto newx =  cos_theta*x + sin_theta*z;
                 auto newz = -sin_theta*x + cos_theta*z;
+
                 vec3 tester(newx, y, newz);
+
                 for (int c = 0; c < 3; c++) {
-                    if (tester[c] > max[c])
-                        max[c] = tester[c];
-                    if (tester[c] < min[c])
-                        min[c] = tester[c];
+                    min[c] = ffmin(min[c], tester[c]);
+                    max[c] = ffmax(max[c], tester[c]);
                 }
             }
         }
     }
+
     bbox = aabb(min, max);
 }
 
 
 bool rotate_y::hit(const ray& r, double t_min, double t_max, hit_record& rec) const {
     vec3 origin = r.origin();
     vec3 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];
+    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 (ptr->hit(rotated_r, t_min, t_max, rec)) {
-        vec3 p = rec.p;
-        vec3 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;
-    }
-    else
+
+    if (!ptr->hit(rotated_r, t_min, t_max, rec))
         return false;
+
+    vec3 p = rec.p;
+    vec3 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;
 }
 
+
 #endif