hitvec nextWeek: hittable_list to std::vector

Author: hollasch

src/TheNextWeek/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/TheNextWeek/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, list.objects.size(), 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,95 +36,77 @@ 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";
 
-    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;
+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 (!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 (box_left.min().y() - box_right.min().y() < 0.0)
-        return -1;
-    else
-        return 1;
-}
+bvh_node::bvh_node(
+    std::vector<hittable*>& objects, size_t start, size_t end, double time0, double time1
+) {
+    int axis = random_int(0,2);
+    auto comparator = (axis == 0) ? box_x_compare
+                    : (axis == 1) ? box_y_compare
+                                  : box_z_compare;
+
+    size_t object_span = end - start;
+
+    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);
+
+        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) {
-    int axis = random_int(0,2);
 
-    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);
+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;
 
-    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 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);
 
-    aabb box_left, box_right;
+    return hit_left || hit_right;
+}
 
-    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";
 
-    box = surrounding_box(box_left, box_right);
+bool bvh_node::bounding_box(double t0, double t1, aabb& output_box) const {
+    output_box = box;
+    return true;
 }
 
+
 #endif

src/TheNextWeek/hittable_list.h

@@ -11,34 +11,56 @@
 // 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;
 
-        hittable **list;
-        int list_size;
+    public:
+        std::vector<hittable*> objects;
 };
 
+
+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;
@@ -47,19 +69,5 @@ 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;
-}
 
 #endif