First commit of code from Ray Tracing the Rest of Your Life

Author: Peter Shirley

aabb.h

@@ -0,0 +1,70 @@
+#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;
+        }
+
+        float area() const {
+               float a = _max.x() - _min.x();
+               float b = _max.y() - _min.y();
+               float c = _max.z() - _min.z();
+               return 2*(a*b + b*c + c*a);
+        }
+
+        int longest_axis() const {
+               float a = _max.x() - _min.x();
+               float b = _max.y() - _min.y();
+               float c = _max.z() - _min.z();
+               if (a > b && a > c)
+                   return 0;
+               else if (b > c)
+                   return 1;
+               else 
+                   return 2;
+        }
+
+        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,113 @@
+#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; 
+        }
+        virtual float  pdf_value(const vec3& o, const vec3& v) const {
+            hit_record rec;
+            if (this->hit(ray(o, v), 0.001, FLT_MAX, rec)) {
+                float area = (x1-x0)*(z1-z0);
+                float distance_squared = rec.t * rec.t * v.squared_length();
+                float cosine = fabs(dot(v, rec.normal) / v.length());
+                return  distance_squared / (cosine * area);
+            }
+            else
+                return 0;
+        }
+        virtual vec3 random(const vec3& o) const { 
+            vec3 random_point = vec3(x0 + drand48()*(x1-x0), k,  z0 + drand48()*(z1-z0)); 
+            return random_point - o;
+        }
+        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

bucamera.h

@@ -0,0 +1,41 @@
+#ifndef CAMERAH
+#define CAMERAH
+
+#include "ray.h"
+
+class camera {
+    public:
+        camera() {
+            lower_left_corner = vec3(-2.0, -1.0, -1.0);
+            horizontal = vec3(4.0, 0.0, 0.0); 
+            vertical = vec3(0.0, 2.0, 0.0); 
+            /*
+            lower_left_corner = vec3(-.1, -0.05, -1.0);
+            horizontal = vec3(0.2, 0.0, 0.0); 
+            vertical = vec3(0.0, 0.1, 0.0); 
+            */
+            origin = vec3(0.0, 0.0, 0.0);
+        }
+
+        camera(vec3 lookfrom,  vec3 lookat, vec3 view_up,  float aspect,  float vfov,  float aperture, float distance_to_focus) {
+            origin = lookfrom;
+            w = unit_vector(lookfrom - lookat;
+            u = unit_vector(cross(vup, w));
+            v = cross(w, u);
+            ZZ
+        }
+        ray get_ray(float s, float t) { return ray(origin, lower_left_corner + s*horizontal + t*vertical - origin); }
+
+        vec3 origin;
+        vec3 lower_left_corner;
+        vec3 horizontal;
+        vec3 vertical;
+        vec3 u, v, w;
+        float radius;
+};
+
+#endif
+
+
+
+