hitvec restLife: hittable_list uses vector

For bvh.h, the original code for TheRestOfYourLife had changes in it
plus a final commented-out section. Once that's removed, most of the new
code is pointless. In addition, the book makes no mention of BVH
changes. In the end, I've decided to make the code identical to match
the text.

Author: hollasch

src/TheRestOfYourLife/box.h

@@ -19,35 +19,35 @@
 class box: public hittable  {
     public:
         box() {}
-
         box(const vec3& p0, const vec3& p1, material *ptr);
 
         virtual bool hit(const ray& r, double t0, double t1, hit_record& rec) const;
 
         virtual bool bounding_box(double t0, double t1, aabb& output_box) const {
-            output_box = aabb(pmin, pmax);
+            output_box = aabb(box_min, box_max);
             return true;
         }
 
-        vec3 pmin, pmax;
-        hittable *list_ptr;
+        vec3 box_min;
+        vec3 box_max;
+        hittable_list sides;
 };
 
 box::box(const vec3& p0, const vec3& p1, material *ptr) {
-    pmin = p0;
-    pmax = p1;
-    hittable **list = new hittable*[6];
-    list[0] = new xy_rect(p0.x(), p1.x(), p0.y(), p1.y(), p1.z(), ptr);
-    list[1] = new flip_normals(new xy_rect(p0.x(), p1.x(), p0.y(), p1.y(), p0.z(), ptr));
-    list[2] = new xz_rect(p0.x(), p1.x(), p0.z(), p1.z(), p1.y(), ptr);
-    list[3] = new flip_normals(new xz_rect(p0.x(), p1.x(), p0.z(), p1.z(), p0.y(), ptr));
-    list[4] = new yz_rect(p0.y(), p1.y(), p0.z(), p1.z(), p1.x(), ptr);
-    list[5] = new flip_normals(new yz_rect(p0.y(), p1.y(), p0.z(), p1.z(), p0.x(), ptr));
-    list_ptr = new hittable_list(list,6);
+    box_min = p0;
+    box_max = p1;
+
+    sides.add(new xy_rect(p0.x(), p1.x(), p0.y(), p1.y(), p1.z(), ptr));
+    sides.add(new flip_normals(new xy_rect(p0.x(), p1.x(), p0.y(), p1.y(), p0.z(), ptr)));
+    sides.add(new xz_rect(p0.x(), p1.x(), p0.z(), p1.z(), p1.y(), ptr));
+    sides.add(new flip_normals(new xz_rect(p0.x(), p1.x(), p0.z(), p1.z(), p0.y(), ptr)));
+    sides.add(new yz_rect(p0.y(), p1.y(), p0.z(), p1.z(), p1.x(), ptr));
+    sides.add(new flip_normals(new yz_rect(p0.y(), p1.y(), p0.z(), p1.z(), p0.x(), ptr)));
 }
 
 bool box::hit(const ray& r, double t0, double t1, hit_record& rec) const {
-    return list_ptr->hit(r, t0, t1, rec);
+    return sides.hit(r, t0, t1, rec);
 }
 
+
 #endif

src/TheRestOfYourLife/bvh.h

@@ -13,12 +13,20 @@
 
 #include "common/rtweekend.h"
 #include "hittable.h"
+#include <algorithm>
 
 
 class bvh_node : public hittable  {
     public:
-        bvh_node() {}
-        bvh_node(hittable **l, int n, double time0, double time1);
+        bvh_node() = delete;
+
+        bvh_node::bvh_node(hittable_list &list, double time0, double time1)
+            : bvh_node(list.objects, 0, 0, time0, time1)
+        {}
+
+        bvh_node(
+            std::vector<hittable*> &objects,
+            size_t start, size_t end, double time0, double time1);
 
         virtual bool hit(const ray& r, double t_min, double t_max, hit_record& rec) const;
         virtual bool bounding_box(double t0, double t1, aabb& output_box) const;
@@ -28,131 +36,82 @@ class bvh_node : public hittable  {
         aabb box;
 };
 
-bool bvh_node::bounding_box(double t0, double t1, aabb& output_box) const {
-    output_box = box;
-    return true;
-}
 
-bool bvh_node::hit(const ray& r, double t_min, double t_max, hit_record& rec) const {
-    if (!box.hit(r, t_min, t_max))
-        return false;
+bool box_compare(const hittable *a, const hittable *b, int axis) {
+    aabb box_a;
+    aabb box_b;
 
-    bool hit_left = left->hit(r, t_min, t_max, rec);
-    bool hit_right = right->hit(r, t_min, hit_left ? rec.t : t_max, rec);
+    if (!a->bounding_box(0,0, box_a) || !b->bounding_box(0,0, box_b))
+        std::cerr << "No bounding box in bvh_node constructor.\n";
 
-    return hit_left || hit_right;
+    return box_a.min().e[axis] < box_b.min().e[axis];
 }
 
-int box_x_compare (const void * a, const void * b) {
-    aabb box_left, box_right;
-    hittable *ah = *(hittable**)a;
-    hittable *bh = *(hittable**)b;
 
-    if (!ah->bounding_box(0,0, box_left) || !bh->bounding_box(0,0, box_right))
-        std::cerr << "no bounding box in bvh_node constructor\n";
+bool box_x_compare (const hittable *a, const hittable *b) { return box_compare(a, b, 0); }
+bool box_y_compare (const hittable *a, const hittable *b) { return box_compare(a, b, 1); }
+bool box_z_compare (const hittable *a, const hittable *b) { return box_compare(a, b, 2); }
 
-    if (box_left.min().x() - box_right.min().x() < 0.0)
-        return -1;
-    else
-        return 1;
-}
 
-int box_y_compare (const void * a, const void * b)
-{
-    aabb box_left, box_right;
-    hittable *ah = *(hittable**)a;
-    hittable *bh = *(hittable**)b;
+bvh_node::bvh_node(
+    std::vector<hittable*> &objects, size_t start, size_t end, double time0, double time1
+) {
+    if (end <= start) {
+        start = 0;
+        end = objects.size();
+    }
 
-    if (!ah->bounding_box(0,0, box_left) || !bh->bounding_box(0,0, box_right))
-        std::cerr << "no bounding box in bvh_node constructor\n";
+    size_t object_span = end - start;
+
+    int axis = random_int(0,2);
+    auto comparator = (axis == 0) ? box_x_compare
+                    : (axis == 1) ? box_y_compare
+                                  : box_z_compare;
+
+    if (object_span == 1) {
+        left = right = objects[start];
+    } else if (object_span == 2) {
+        if (comparator(objects[start], objects[start+1])) {
+            left = objects[start];
+            right = objects[start+1];
+        } else {
+            left = objects[start+1];
+            right = objects[start];
+        }
+    } else {
+        std::sort(objects.begin() + start, objects.begin() + end, comparator);
 
-    if (box_left.min().y() - box_right.min().y() < 0.0)
-        return -1;
-    else
-        return 1;
-}
+        auto mid = start + object_span/2;
+        left = new bvh_node(objects, start, mid, time0, time1);
+        right = new bvh_node(objects, mid, end, time0, time1);
+    }
 
-int box_z_compare (const void * a, const void * b)
-{
     aabb box_left, box_right;
-    hittable *ah = *(hittable**)a;
-    hittable *bh = *(hittable**)b;
 
-    if (!ah->bounding_box(0,0, box_left) || !bh->bounding_box(0,0, box_right))
-        std::cerr << "no bounding box in bvh_node constructor\n";
+    if (  !left->bounding_box (time0, time1, box_left)
+       || !right->bounding_box(time0, time1, box_right)
+    )
+        std::cerr << "No bounding box in bvh_node constructor.\n";
 
-    if (box_left.min().z() - box_right.min().z() < 0.0)
-        return -1;
-    else
-        return 1;
+    box = surrounding_box(box_left, box_right);
 }
 
-bvh_node::bvh_node(hittable **l, int n, double time0, double time1) {
-    aabb *boxes = new aabb[n];
-    auto *left_area = new double[n];
-    auto *right_area = new double[n];
-    aabb main_box;
-    bool dummy = l[0]->bounding_box(time0, time1, main_box);
-    for (int i = 1; i < n; i++) {
-        aabb new_box;
-        bool dummy = l[i]->bounding_box(time0, time1, new_box);
-        main_box = surrounding_box(new_box, main_box);
-    }
-    int axis = main_box.longest_axis();
-    if (axis == 0)
-        qsort(l, n, sizeof(hittable *), box_x_compare);
-    else if (axis == 1)
-        qsort(l, n, sizeof(hittable *), box_y_compare);
-    else
-        qsort(l, n, sizeof(hittable *), box_z_compare);
-    for (int i = 0; i < n; i++)
-        bool dummy = l[i]->bounding_box(time0, time1, boxes[i]);
-    left_area[0] = boxes[0].area();
-    aabb left_box = boxes[0];
-    for (int i = 1; i < n-1; i++) {
-        left_box = surrounding_box(left_box, boxes[i]);
-        left_area[i] = left_box.area();
-    }
-    right_area[n-1] = boxes[n-1].area();
-    aabb right_box = boxes[n-1];
-    for (int i = n-2; i > 0; i--) {
-        right_box = surrounding_box(right_box, boxes[i]);
-        right_area[i] = right_box.area();
-    }
-    auto min_SAH = infinity;
-    int min_SAH_idx;
-    for (int i = 0; i < n-1; i++) {
-        auto SAH = i*left_area[i] + (n-i-1)*right_area[i+1];
-        if (SAH < min_SAH) {
-            min_SAH_idx = i;
-            min_SAH = SAH;
-        }
-    }
 
-    /*
-    if (min_SAH_idx == 0)
-        left = l[0];
-    else
-        left = new bvh_node(l, min_SAH_idx+1, time0, time1);
-    if (min_SAH_idx == n-2)
-        right = l[min_SAH_idx+1];
-    else
-        right = new bvh_node(l + min_SAH_idx+1, n - min_SAH_idx -1, time0, time1);
-    */
-
-    if (n == 1) {
-        left = right = l[0];
-    }
-    else if (n == 2) {
-        left = l[0];
-        right = l[1];
-    }
-    else {
-        left = new bvh_node(l, n/2, time0, time1);
-        right = new bvh_node(l + n/2, n - n/2, time0, time1);
-    }
+bool bvh_node::hit(const ray& r, double t_min, double t_max, hit_record& rec) const {
+    if (!box.hit(r, t_min, t_max))
+        return false;
+
+    bool hit_left = left->hit(r, t_min, t_max, rec);
+    bool hit_right = right->hit(r, t_min, hit_left ? rec.t : t_max, rec);
+
+    return hit_left || hit_right;
+}
 
-    box = main_box;
+
+bool bvh_node::bounding_box(double t0, double t1, aabb& output_box) const {
+    output_box = box;
+    return true;
 }
 
+
 #endif

src/TheRestOfYourLife/hittable_list.h

@@ -11,50 +11,58 @@
 // along with this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
 //==============================================================================================
 
-#include "common/rtweekend.h"
 #include "hittable.h"
+#include <vector>
 
 
 class hittable_list: public hittable  {
     public:
         hittable_list() {}
-        hittable_list(hittable **l, int n) {list = l; list_size = n; }
+        hittable_list(hittable* object) { add(object); }
+
+        void clear()               { objects.clear(); }
+        void add(hittable* object) { objects.push_back(object); }
+
         virtual bool hit(const ray& r, double tmin, double tmax, hit_record& rec) const;
         virtual bool bounding_box(double t0, double t1, aabb& output_box) const;
-        virtual double pdf_value(const vec3& o, const vec3& v) const;
-        virtual vec3 random(const vec3& o) const;
+        virtual double pdf_value(const vec3 &o, const vec3 &v) const;
+        virtual vec3 random(const vec3 &o) const;
 
-        hittable **list;
-        int list_size;
+    public:
+        std::vector<hittable*> objects;
 };
 
-double hittable_list::pdf_value(const vec3& o, const vec3& v) const {
-    auto weight = 1.0/list_size;
-    auto sum = 0.0;
-    for (int i = 0; i < list_size; i++)
-        sum += weight*list[i]->pdf_value(o, v);
-    return sum;
-}
 
-vec3 hittable_list::random(const vec3& o) const {
-    int index = random_int(0, list_size-1);
-    return list[ index ]->random(o);
+bool hittable_list::hit(const ray& r, double t_min, double t_max, hit_record& rec) const {
+    hit_record temp_rec;
+    auto hit_anything = false;
+    auto closest_so_far = t_max;
+
+    for (auto object : objects) {
+        if (object->hit(r, t_min, closest_so_far, temp_rec)) {
+            hit_anything = true;
+            closest_so_far = temp_rec.t;
+            rec = temp_rec;
+        }
+    }
+
+    return hit_anything;
 }
 
 
 bool hittable_list::bounding_box(double t0, double t1, aabb& output_box) const {
-    if (list_size < 1) return false;
+    if (objects.empty()) return false;
 
     aabb temp_box;
-    bool first_true = list[0]->bounding_box(t0, t1, temp_box);
+    bool first_true = objects[0]->bounding_box(t0, t1, temp_box);
 
     if (!first_true)
         return false;
     else
         output_box = temp_box;
 
-    for (int i = 1; i < list_size; i++) {
-        if (list[i]->bounding_box(t0, t1, temp_box))
+    for (auto object : objects) {
+        if (object->bounding_box(t0, t1, temp_box))
             output_box = surrounding_box(output_box, temp_box);
         else
             return false;
@@ -63,19 +71,23 @@ bool hittable_list::bounding_box(double t0, double t1, aabb& output_box) const {
     return true;
 }
 
-bool hittable_list::hit(const ray& r, double t_min, double t_max, hit_record& rec) const {
-    hit_record temp_rec;
-    bool hit_anything = false;
-    double closest_so_far = t_max;
 
-    for (int i = 0; i < list_size; i++) {
-        if (list[i]->hit(r, t_min, closest_so_far, temp_rec)) {
-            hit_anything = true;
-            closest_so_far = temp_rec.t;
-            rec = temp_rec;
-        }
-    }
-    return hit_anything;
+double hittable_list::pdf_value(const vec3& o, const vec3& v) const {
+    auto weight = 1.0/objects.size();
+    auto sum = 0.0;
+
+    for (auto object : objects)
+        sum += weight * object->pdf_value(o, v);
+
+    return sum;
 }
 
+
+vec3 hittable_list::random(const vec3 &o) const {
+    auto int_size = static_cast<int>(objects.size());
+    auto index = static_cast<size_t>(random_int(0, int_size-1));
+    return objects[index]->random(o);
+}
+
+
 #endif