First commit of code from Ray Tracing the Next Week

Author: Peter Shirley

aabb.h

@@ -0,0 +1,51 @@
+#ifndef AABBH
+#define AABBH
+#include "ray.h"
+#include "hitable.h"
+
+inline float ffmin(float a, float b) { return a < b ? a : b; }
+inline float ffmax(float a, float b) { return a > b ? a : b; }
+
+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 {
+            for (int a = 0; a < 3; a++) {
+                float t0 = ffmin((_min[a] - r.origin()[a]) / r.direction()[a],  
+                                (_max[a] - r.origin()[a]) / r.direction()[a]);
+                float t1 = ffmax((_min[a] - r.origin()[a]) / r.direction()[a],  
+                                (_max[a] - r.origin()[a]) / r.direction()[a]);
+                tmin = ffmax(t0, tmin);
+                tmax = ffmin(t1, tmax);
+                if (tmax <= tmin)
+                    return false;
+            }
+            return true;
+        }
+
+        vec3 _min;
+        vec3 _max;
+};
+
+aabb surrounding_box(aabb box0, aabb box1) {
+    vec3 small( fmin(box0.min().x(), box1.min().x()),
+                fmin(box0.min().y(), box1.min().y()),
+                fmin(box0.min().z(), box1.min().z()));
+    vec3 big  ( fmax(box0.max().x(), box1.max().x()),
+                fmax(box0.max().y(), box1.max().y()),
+                fmax(box0.max().z(), box1.max().z()));
+    return aabb(small,big);
+}
+
+
+#endif
+
+
+
+
+

aarect.h

@@ -0,0 +1,97 @@
+#ifndef AARECTH
+#define AARECTH
+
+#include "hitable.h"
+
+class xy_rect: public hitable  {
+    public:
+        xy_rect() {}
+        xy_rect(float _x0, float _x1, float _y0, float _y1, float _k, material *mat) : x0(_x0), x1(_x1), y0(_y0), y1(_y1), k(_k), mp(mat) {};
+        virtual bool hit(const ray& r, float t0, float t1, hit_record& rec) const;
+        virtual bool bounding_box(float t0, float t1, aabb& box) const {
+               box =  aabb(vec3(x0,y0, k-0.0001), vec3(x1, y1, k+0.0001));
+               return true; }
+        material  *mp;
+        float x0, x1, y0, y1, k;
+};
+
+class xz_rect: public hitable  {
+    public:
+        xz_rect() {}
+        xz_rect(float _x0, float _x1, float _z0, float _z1, float _k, material *mat) : x0(_x0), x1(_x1), z0(_z0), z1(_z1), k(_k), mp(mat) {};
+        virtual bool hit(const ray& r, float t0, float t1, hit_record& rec) const;
+        virtual bool bounding_box(float t0, float t1, aabb& box) const {
+               box =  aabb(vec3(x0,k-0.0001,z0), vec3(x1, k+0.0001, z1));
+               return true; }
+        material  *mp;
+        float x0, x1, z0, z1, k;
+};
+
+class yz_rect: public hitable  {
+    public:
+        yz_rect() {}
+        yz_rect(float _y0, float _y1, float _z0, float _z1, float _k, material *mat) : y0(_y0), y1(_y1), z0(_z0), z1(_z1), k(_k), mp(mat) {};
+        virtual bool hit(const ray& r, float t0, float t1, hit_record& rec) const;
+        virtual bool bounding_box(float t0, float t1, aabb& box) const {
+               box =  aabb(vec3(k-0.0001, y0, z0), vec3(k+0.0001, y1, z1));
+               return true; }
+        material  *mp;
+        float y0, y1, z0, z1, k;
+};
+
+
+
+
+bool xy_rect::hit(const ray& r, float t0, float t1, hit_record& rec) const {
+    float t = (k-r.origin().z()) / r.direction().z();
+    if (t < t0 || t > t1)
+        return false;
+    float x = r.origin().x() + t*r.direction().x();
+    float y = r.origin().y() + t*r.direction().y();
+    if (x < x0 || x > x1 || y < y0 || y > y1) 
+        return false;
+    rec.u = (x-x0)/(x1-x0);
+    rec.v = (y-y0)/(y1-y0); 
+    rec.t = t;
+    rec.mat_ptr = mp;
+    rec.p = r.point_at_parameter(t);
+    rec.normal = vec3(0, 0, 1);
+    return true;
+}
+
+
+bool xz_rect::hit(const ray& r, float t0, float t1, hit_record& rec) const {
+    float t = (k-r.origin().y()) / r.direction().y();
+    if (t < t0 || t > t1)
+        return false;
+    float x = r.origin().x() + t*r.direction().x();
+    float z = r.origin().z() + t*r.direction().z();
+    if (x < x0 || x > x1 || z < z0 || z > z1) 
+        return false;
+    rec.u = (x-x0)/(x1-x0);
+    rec.v = (z-z0)/(z1-z0); 
+    rec.t = t;
+    rec.mat_ptr = mp;
+    rec.p = r.point_at_parameter(t);
+    rec.normal = vec3(0, 1, 0);
+    return true;
+}
+
+bool yz_rect::hit(const ray& r, float t0, float t1, hit_record& rec) const {
+    float t = (k-r.origin().x()) / r.direction().x();
+    if (t < t0 || t > t1)
+        return false;
+    float y = r.origin().y() + t*r.direction().y();
+    float z = r.origin().z() + t*r.direction().z();
+    if (y < y0 || y > y1 || z < z0 || z > z1) 
+        return false;
+    rec.u = (y-y0)/(y1-y0);
+    rec.v = (z-z0)/(z1-z0); 
+    rec.t = t;
+    rec.mat_ptr = mp;
+    rec.p = r.point_at_parameter(t);
+    rec.normal = vec3(1, 0, 0);
+    return true;
+}
+
+#endif

box.h

@@ -0,0 +1,36 @@
+#ifndef BOXH
+#define BOXH
+
+#include "aarect.h"
+#include "hitable_list.h"
+
+class box: public hitable  {
+    public:
+        box() {}
+        box(const vec3& p0, const vec3& p1, material *ptr);
+        virtual bool hit(const ray& r, float t0, float t1, hit_record& rec) const;
+        virtual bool bounding_box(float t0, float t1, aabb& box) const {
+               box =  aabb(pmin, pmax);
+               return true; }
+        vec3 pmin, pmax;
+        hitable *list_ptr;
+};
+
+box::box(const vec3& p0, const vec3& p1, material *ptr) {
+    pmin = p0;
+    pmax = p1;
+    hitable **list = new hitable*[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 hitable_list(list,6);
+}
+
+bool box::hit(const ray& r, float t0, float t1, hit_record& rec) const {
+    return list_ptr->hit(r, t0, t1, rec);
+}
+
+#endif

bvh.h

@@ -0,0 +1,114 @@
+#ifndef BVHH
+#define BVHH
+
+#include "hitable.h"
+
+class bvh_node : public hitable  {
+    public:
+        bvh_node() {}
+        bvh_node(hitable **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;
+        hitable *left;
+        hitable *right;
+        aabb box;
+};
+
+
+bool bvh_node::bounding_box(float t0, float t1, aabb& b) const {
+    b = box;
+    return true;
+}
+
+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;
+        hitable *ah = *(hitable**)a;
+        hitable *bh = *(hitable**)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;
+        hitable *ah = *(hitable**)a;
+        hitable *bh = *(hitable**)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;
+        hitable *ah = *(hitable**)a;
+        hitable *bh = *(hitable**)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;
+}
+
+
+bvh_node::bvh_node(hitable **l, int n, float time0, float time1) {
+    int axis = int(3*drand48());
+    if (axis == 0)
+       qsort(l, n, sizeof(hitable *), box_x_compare);
+    else if (axis == 1)
+       qsort(l, n, sizeof(hitable *), box_y_compare);
+    else
+       qsort(l, n, sizeof(hitable *), 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
+

camera.h

@@ -0,0 +1,52 @@
+#ifndef CAMERAH
+#define CAMERAH
+#include "ray.h"
+
+vec3 random_in_unit_disk() {
+    vec3 p;
+    do {
+        p = 2.0*vec3(drand48(),drand48(),0) - vec3(1,1,0);
+    } while (dot(p,p) >= 1.0);
+    return p;
+}
+
+class camera {
+    public:
+        // new:  add t0 and t1
+        camera(vec3 lookfrom, vec3 lookat, vec3 vup, float vfov, float aspect, float aperture, float focus_dist, float t0, float t1) { // vfov is top to bottom in degrees
+            time0 = t0;
+            time1 = t1;
+            lens_radius = aperture / 2;
+            float theta = vfov*M_PI/180;
+            float half_height = tan(theta/2);
+            float half_width = aspect * half_height;
+            origin = lookfrom;
+            w = unit_vector(lookfrom - lookat);
+            u = unit_vector(cross(vup, w));
+            v = cross(w, u);
+            lower_left_corner = origin  - half_width*focus_dist*u -half_height*focus_dist*v - focus_dist*w;
+            horizontal = 2*half_width*focus_dist*u;
+            vertical = 2*half_height*focus_dist*v;
+        }
+
+        // new: add time to construct ray
+        ray get_ray(float s, float t) {
+            vec3 rd = lens_radius*random_in_unit_disk();
+            vec3 offset = u * rd.x() + v * rd.y();
+            float time = time0 + drand48()*(time1-time0);
+            return ray(origin + offset, lower_left_corner + s*horizontal + t*vertical - origin - offset, time); 
+        }
+
+        vec3 origin;
+        vec3 lower_left_corner;
+        vec3 horizontal;
+        vec3 vertical;
+        vec3 u, v, w;
+        float time0, time1;  // new variables for shutter open/close times
+        float lens_radius;
+};
+#endif
+
+
+
+