Switch theNextWeek to using std::shared_ptr

Author: hollasch

src/TheNextWeek/aarect.h

@@ -19,8 +19,9 @@ class xy_rect: public hittable {
     public:
         xy_rect() {}
 
-        xy_rect(double _x0, double _x1, double _y0, double _y1, double _k, material *mat)
-            : x0(_x0), x1(_x1), y0(_y0), y1(_y1), k(_k), mp(mat) {};
+        xy_rect(
+            double _x0, double _x1, double _y0, double _y1, double _k, shared_ptr<material> mat
+        ) : x0(_x0), x1(_x1), y0(_y0), y1(_y1), k(_k), mp(mat) {};
 
         virtual bool hit(const ray& r, double t0, double t1, hit_record& rec) const;
 
@@ -29,16 +30,17 @@ class xy_rect: public hittable {
             return true;
         }
 
-        material  *mp;
+        shared_ptr<material> mp;
         double x0, x1, y0, y1, k;
 };
 
 class xz_rect: public hittable {
     public:
         xz_rect() {}
 
-        xz_rect(double _x0, double _x1, double _z0, double _z1, double _k, material *mat)
-            : x0(_x0), x1(_x1), z0(_z0), z1(_z1), k(_k), mp(mat) {};
+        xz_rect(
+            double _x0, double _x1, double _z0, double _z1, double _k, shared_ptr<material> mat
+        ) : x0(_x0), x1(_x1), z0(_z0), z1(_z1), k(_k), mp(mat) {};
 
         virtual bool hit(const ray& r, double t0, double t1, hit_record& rec) const;
 
@@ -47,16 +49,17 @@ class xz_rect: public hittable {
             return true;
         }
 
-        material  *mp;
+        shared_ptr<material> mp;
         double x0, x1, z0, z1, k;
 };
 
 class yz_rect: public hittable {
     public:
         yz_rect() {}
 
-        yz_rect(double _y0, double _y1, double _z0, double _z1, double _k, material *mat)
-            : y0(_y0), y1(_y1), z0(_z0), z1(_z1), k(_k), mp(mat) {};
+        yz_rect(
+            double _y0, double _y1, double _z0, double _z1, double _k, shared_ptr<material> mat
+        ) : y0(_y0), y1(_y1), z0(_z0), z1(_z1), k(_k), mp(mat) {};
 
         virtual bool hit(const ray& r, double t0, double t1, hit_record& rec) const;
 
@@ -65,7 +68,7 @@ class yz_rect: public hittable {
             return true;
         }
 
-        material  *mp;
+        shared_ptr<material> mp;
         double y0, y1, z0, z1, k;
 };
 

src/TheNextWeek/box.h

@@ -19,7 +19,7 @@
 class box: public hittable  {
     public:
         box() {}
-        box(const vec3& p0, const vec3& p1, material *ptr);
+        box(const vec3& p0, const vec3& p1, shared_ptr<material> ptr);
 
         virtual bool hit(const ray& r, double t0, double t1, hit_record& rec) const;
 
@@ -28,21 +28,28 @@ class box: public hittable  {
             return true;
         }
 
+    public:
         vec3 box_min;
         vec3 box_max;
         hittable_list sides;
 };
 
-box::box(const vec3& p0, const vec3& p1, material *ptr) {
+
+box::box(const vec3& p0, const vec3& p1, shared_ptr<material> ptr) {
     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_face(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_face(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_face(new yz_rect(p0.y(), p1.y(), p0.z(), p1.z(), p0.x(), ptr)));
+    sides.add(make_shared<xy_rect>(p0.x(), p1.x(), p0.y(), p1.y(), p1.z(), ptr));
+    sides.add(make_shared<flip_face>(
+        make_shared<xy_rect>(p0.x(), p1.x(), p0.y(), p1.y(), p0.z(), ptr)));
+
+    sides.add(make_shared<xz_rect>(p0.x(), p1.x(), p0.z(), p1.z(), p1.y(), ptr));
+    sides.add(make_shared<flip_face>(
+        make_shared<xz_rect>(p0.x(), p1.x(), p0.z(), p1.z(), p0.y(), ptr)));
+
+    sides.add(make_shared<yz_rect>(p0.y(), p1.y(), p0.z(), p1.z(), p1.x(), ptr));
+    sides.add(make_shared<flip_face>(
+        make_shared<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 {

src/TheNextWeek/bvh.h

@@ -25,20 +25,20 @@ class bvh_node : public hittable  {
         {}
 
         bvh_node(
-            std::vector<hittable*>& objects,
+            std::vector<shared_ptr<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;
 
     public:
-        hittable *left;
-        hittable *right;
+        shared_ptr<hittable> left;
+        shared_ptr<hittable> right;
         aabb box;
 };
 
 
-inline bool box_compare(const hittable* a, const hittable* b, int axis) {
+inline bool box_compare(const shared_ptr<hittable> a, const shared_ptr<hittable> b, int axis) {
     aabb box_a;
     aabb box_b;
 
@@ -49,13 +49,22 @@ inline bool box_compare(const hittable* a, const hittable* b, int axis) {
 }
 
 
-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); }
+bool box_x_compare (const shared_ptr<hittable> a, const shared_ptr<hittable> b) {
+    return box_compare(a, b, 0);
+}
+
+bool box_y_compare (const shared_ptr<hittable> a, const shared_ptr<hittable> b) {
+    return box_compare(a, b, 1);
+}
+
+bool box_z_compare (const shared_ptr<hittable> a, const shared_ptr<hittable> b) {
+    return box_compare(a, b, 2);
+}
 
 
 bvh_node::bvh_node(
-    std::vector<hittable*>& objects, size_t start, size_t end, double time0, double time1
+    std::vector<shared_ptr<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
@@ -78,8 +87,8 @@ bvh_node::bvh_node(
         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);
+        left = make_shared<bvh_node>(objects, start, mid, time0, time1);
+        right = make_shared<bvh_node>(objects, mid, end, time0, time1);
     }
 
     aabb box_left, box_right;

src/TheNextWeek/constant_medium.h

@@ -19,8 +19,10 @@
 
 class constant_medium : public hittable  {
     public:
-        constant_medium(hittable *b, double d, texture *a) : boundary(b), density(d) {
-            phase_function = new isotropic(a);
+        constant_medium(shared_ptr<hittable> b, double d, shared_ptr<texture> a)
+            : boundary(b), density(d)
+        {
+            phase_function = make_shared<isotropic>(a);
         }
 
         virtual bool hit(const ray& r, double t_min, double t_max, hit_record& rec) const;
@@ -29,9 +31,9 @@ class constant_medium : public hittable  {
             return boundary->bounding_box(t0, t1, output_box);
         }
 
-        hittable *boundary;
+        shared_ptr<hittable> boundary;
         double density;
-        material *phase_function;
+        shared_ptr<material> phase_function;
 };
 
 

src/TheNextWeek/hittable.h

@@ -28,7 +28,7 @@ void get_sphere_uv(const vec3& p, double& u, double& v) {
 struct hit_record {
     vec3 p;
     vec3 normal;
-    material *mat_ptr;
+    shared_ptr<material> mat_ptr;
     double t;
     double u;
     double v;
@@ -48,7 +48,8 @@ class hittable {
 
 class flip_face : public hittable {
     public:
-        flip_face(hittable *p) : ptr(p) {}
+        flip_face(shared_ptr<hittable> p) : ptr(p) {}
+
         virtual bool hit(const ray& r, double t_min, double t_max, hit_record& rec) const {
             if (ptr->hit(r, t_min, t_max, rec)) {
                 rec.front_face = !rec.front_face;
@@ -57,18 +58,24 @@ class flip_face : public hittable {
             else
                 return false;
         }
+
         virtual bool bounding_box(double t0, double t1, aabb& output_box) const {
             return ptr->bounding_box(t0, t1, output_box);
         }
-        hittable *ptr;
+
+    public:
+        shared_ptr<hittable> ptr;
 };
 
 class translate : public hittable {
     public:
-        translate(hittable *p, const vec3& displacement) : ptr(p), offset(displacement) {}
+        translate(shared_ptr<hittable> p, const vec3& displacement)
+            : ptr(p), offset(displacement) {}
         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;
-        hittable *ptr;
+
+    public:
+        shared_ptr<hittable> ptr;
         vec3 offset;
 };
 
@@ -96,20 +103,21 @@ bool translate::bounding_box(double t0, double t1, aabb& output_box) const {
 
 class rotate_y : public hittable {
     public:
-        rotate_y(hittable *p, double angle);
+        rotate_y(shared_ptr<hittable> p, double angle);
         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 {
             output_box = bbox;
             return hasbox;
         }
-        hittable *ptr;
+
+        shared_ptr<hittable> ptr;
         double sin_theta;
         double cos_theta;
         bool hasbox;
         aabb bbox;
 };
 
-rotate_y::rotate_y(hittable *p, double angle) : ptr(p) {
+rotate_y::rotate_y(shared_ptr<hittable> p, double angle) : ptr(p) {
     auto radians = degrees_to_radians(angle);
     sin_theta = sin(radians);
     cos_theta = cos(radians);

src/TheNextWeek/hittable_list.h

@@ -18,16 +18,16 @@
 class hittable_list: public hittable  {
     public:
         hittable_list() {}
-        hittable_list(hittable* object) { add(object); }
+        hittable_list(shared_ptr<hittable> object) { add(object); }
 
-        void clear()               { objects.clear(); }
-        void add(hittable* object) { objects.push_back(object); }
+        void clear() { objects.clear(); }
+        void add(shared_ptr<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;
 
     public:
-        std::vector<hittable*> objects;
+        std::vector<shared_ptr<hittable>> objects;
 };