Added Bounding Volume Heirarchies to optimize ray-object intersection

Author: neerajsamtani

aabb.h

@@ -0,0 +1,56 @@
+#ifndef AABBH
+#define AABBH
+
+#include "hittable.h"
+#include "ray.h"
+
+// Return the min and max for float values
+inline float ffmin(float a, float b) { return a < b ? a : b; }
+inline float ffmax(float a, float b) { return a > b ? a : b; }
+
+// An AABB is bounded by a vector of min x, min y, min z
+// and a vector of max x, max y, max z of all the objects in it
+class aabb {
+	public:
+		aabb() {}
+		aabb(const vec3& a, const vec3& b) { _min = a; _max = b;}
+
+		vec3 min() const {return _min; }
+		vec3 max() const {return _max; }
+
+		bool hit(const ray& r, float tmin, float tmax) const;
+
+		vec3 _min;
+		vec3 _max;
+};
+
+// Check if ray r hits the bouding box
+// The t values for the intersection in the x, y, and z axis must
+// all overlap for the ray to intersect the box
+inline bool aabb::hit(const ray& r, float tmin, float tmax) const {
+	for (int a = 0; a < 3; a++) {
+		float invD = 1.0f / r.direction()[a];
+		float t0 = (min()[a] - r.origin()[a]) * invD;
+		float t1 = (max()[a] - r.origin()[a]) * invD;
+		if (invD < 0.0f)
+			std::swap(t0, t1);
+		tmin = t0 > tmin ? t0 : tmin;
+		tmax = t1 < tmax ? t1 : tmax;
+		if (tmax <= tmin)
+			return false;
+	}
+	return true;
+}
+
+// Create an AABB which bounds box0 and box1
+aabb surrounding_box(aabb box0, aabb box1) {
+	vec3 small( ffmin(box0.min().x(), box1.min().x()),
+				ffmin(box0.min().y(), box1.min().y()),
+				ffmin(box0.min().z(), box1.min().z()));
+	vec3 big  ( ffmax(box0.max().x(), box1.max().x()),
+				ffmax(box0.max().y(), box1.max().y()),
+				ffmax(box0.max().z(), box1.max().z()));
+	return aabb(small,big);
+}
+
+#endif

bvh.h

@@ -0,0 +1,116 @@
+#ifndef BVHH
+#define BVHH
+
+#include "hittable.h"
+#include "random.h"
+
+// A node in the BVH tree
+class bvh_node : public hittable  {
+    public:
+        bvh_node() {}
+        bvh_node(hittable **l, int n, float time0, float time1);
+        virtual bool hit(const ray& r, float tmin, float tmax, hit_record& rec) const;
+        virtual bool bounding_box(float t0, float t1, aabb& box) const;
+        hittable *left;
+        hittable *right;
+        aabb box;
+};
+
+// Each node has a corresponding bouding box
+bool bvh_node::bounding_box(float t0, float t1, aabb& b) const {
+    b = box;
+    return true;
+}
+
+// Check whether the ray r hits the left or right child of the bvh_node
+bool bvh_node::hit(const ray& r, float t_min, float t_max, hit_record& rec) const {
+    if (box.hit(r, t_min, t_max)) {
+        hit_record left_rec, right_rec;
+        bool hit_left = left->hit(r, t_min, t_max, left_rec);
+        bool hit_right = right->hit(r, t_min, t_max, right_rec);
+        if (hit_left && hit_right) {
+            if (left_rec.t < right_rec.t) 
+                rec = left_rec;
+            else 
+                rec = right_rec;
+            return true;
+        }
+        else if (hit_left) {
+            rec = left_rec;
+            return true;
+        }
+        else if (hit_right) {
+            rec = right_rec;
+            return true;
+        }
+        else 
+            return false;
+    }
+    else return false;
+}
+
+
+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;
+        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;
+}
+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 ( box_left.min().z() - box_right.min().z() < 0.0  )
+            return -1;
+        else
+            return 1;
+}
+
+// Construct the bvh node
+bvh_node::bvh_node(hittable **l, int n, float time0, float time1) {
+    int axis = int(3*random_double());
+    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);
+    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);
+    }
+    aabb box_left, box_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);
+}
+
+#endif

gen-sphere.cpp

@@ -86,8 +86,8 @@ hittable *random_scene() {
 int main()
 {
 	// Image is 200x100 pixels
-	int nx = 800;
-	int ny = 400;
+	int nx = 200;
+	int ny = 100;
 	// Number of samples
 	int ns = 100;
 	// Standard formatting of a .ppm file

hittable.h

@@ -2,6 +2,7 @@
 #define HITTABLEH
 
 #include "ray.h"
+#include "aabb.h"
 
 class material;
 
@@ -22,6 +23,7 @@ class hittable
 {
 public:
 	virtual bool hit(const ray& r, float t_min, float t_max, hit_record& rec) const = 0;
+	virtual bool bounding_box(float t0, float t1, aabb& box) const = 0;
 };
 
 #endif

hittable_list.h

@@ -2,6 +2,7 @@
 #define HITTABLELISTH
 
 #include "hittable.h"
+#include "aabb.h"
 
 // Class for list of hitable items
 class hittable_list : public hittable
@@ -14,6 +15,7 @@ class hittable_list : public hittable
 		list_size = n;
 	}
 	virtual bool hit(const ray& r, float t_min, float t_max, hit_record& rec) const;
+	virtual bool bounding_box(float t0, float t1, aabb& box) const;
 	// List of pointers to hitable item pointers
 	hittable **list;
 	int list_size;
@@ -40,4 +42,24 @@ bool hittable_list::hit(const ray& r, float t_min, float t_max, hit_record& rec)
 	return hit_anything;
 }
 
+// Create an AABB to bound all items in the list
+// t0 and t1 are needed to bound moving objects
+bool hittable_list::bounding_box(float t0, float t1, aabb& box) const {
+	if (list_size < 1) return false;
+	aabb temp_box;
+	bool first_true = list[0]->bounding_box(t0, t1, temp_box);
+	if (!first_true)
+		return false;
+	else
+		box = temp_box;
+	for (int i = 1; i < list_size; i++) {
+		if(list[i]->bounding_box(t0, t1, temp_box)) {
+			box = surrounding_box(box, temp_box);
+		}
+		else
+			return false;
+	}
+	return true;
+}
+
 #endif

moving_sphere.h

@@ -2,6 +2,7 @@
 #define MOVINGSPHEREH
 
 #include "hittable.h"
+#include "aabb.h"
 
 class moving_sphere: public hittable {
 	public:
@@ -10,7 +11,7 @@ class moving_sphere: public hittable {
 		  : center0(cen0), center1(cen1), time0(t0), time1(t1), radius(r), mat_ptr(m)
 			{};
 		virtual bool hit(const ray& r, float tmin, float tmax, hit_record& rec) const;
-		// virtual bool bounding_box(float t0, float t1, aabb& box) const;
+		virtual bool bounding_box(float t0, float t1, aabb& box) const;
 		vec3 center(float time) const;
 		// Center at time0 and time1
 		vec3 center0, center1;
@@ -20,12 +21,13 @@ class moving_sphere: public hittable {
 		material *mat_ptr;
 };
 
-// Center at time
+// Find where the center of the sphere is at `time`
 vec3 moving_sphere::center(float time) const{
 	return center0 + ((time - time0) / (time1 - time0))*(center1 - center0);
 }
 
 // Find the positive solution of the interection of the ray and the sphere
+// The position of the center of the sphere depends on the ray's time
 bool moving_sphere::hit(
 	const ray& r, float t_min, float t_max, hit_record& rec) const {
 	vec3 oc = r.origin() - center(r.time());
@@ -54,4 +56,15 @@ bool moving_sphere::hit(
 	return false;
 }
 
+// Create a static AABB which always bounds the sphere
+// at any point in its motion
+bool moving_sphere::bounding_box(float t0, float t1, aabb& box) const {
+	aabb box0(center(t0) - vec3(radius, radius, radius),
+			  center(t0) + vec3(radius, radius, radius));
+	aabb box1(center(t1) - vec3(radius, radius, radius),
+			  center(t1) + vec3(radius, radius, radius));
+	box = surrounding_box(box0, box1);
+	return true;
+}
+
 #endif

sphere.h

@@ -2,6 +2,7 @@
 #define SPHEREH
 
 #include "hittable.h"
+#include "aabb.h"
 
 class sphere: public hittable
 {
@@ -14,6 +15,7 @@ class sphere: public hittable
 		mat_ptr = m;
 	}
 	virtual bool hit(const ray& r, float t_min, float t_max, hit_record& rec) const;
+	virtual bool bounding_box(float t0, float t1, aabb& box) const;
 	vec3 center;
 	float radius;
 	material *mat_ptr;
@@ -52,4 +54,13 @@ bool sphere::hit(const ray& r, float t_min, float t_max, hit_record& rec) const
 	return false;
 }
 
+// Create an AABB for the sphere
+// Since this sphere doesn't move, t0 and t1 aren't required
+// They are just part of the function definition
+bool sphere::bounding_box(float t0, float t1, aabb& box) const {
+	box = aabb(center - vec3(radius, radius, radius),
+			   center + vec3(radius, radius, radius));
+	return true;
+}
+
 #endif