Switch theRestOfYourLife code to std::shared_ptr

Author: hollasch

src/TheRestOfYourLife/aarect.h

@@ -19,7 +19,8 @@ class xy_rect: public hittable {
     public:
         xy_rect() {}
 
-        xy_rect(double _x0, double _x1, double _y0, double _y1, double _k, material *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,15 +30,16 @@ 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)
+        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;
@@ -64,15 +66,16 @@ class xz_rect: public hittable {
             return random_point - origin;
         }
 
-        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)
+        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;
@@ -82,7 +85,7 @@ class yz_rect: public hittable {
             return true;
         }
 
-        material  *mp;
+        shared_ptr<material> mp;
         double y0, y1, z0, z1, k;
 };
 

src/TheRestOfYourLife/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,27 @@ 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/TheRestOfYourLife/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/TheRestOfYourLife/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;
@@ -50,7 +50,7 @@ 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;
@@ -62,15 +62,16 @@ class flip_face : public hittable {
         virtual bool bounding_box(double t0, double t1, aabb& output_box) const {
             return ptr->bounding_box(t0, t1, output_box);
         }
-        hittable *ptr;
+        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;
+        shared_ptr<hittable> ptr;
         vec3 offset;
 };
 
@@ -98,20 +99,20 @@ 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/TheRestOfYourLife/hittable_list.h

@@ -18,18 +18,18 @@
 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;
         virtual double pdf_value(const vec3 &o, const vec3 &v) const;
         virtual vec3 random(const vec3 &o) const;
 
     public:
-        std::vector<hittable*> objects;
+        std::vector<shared_ptr<hittable>> objects;
 };
 
 

src/TheRestOfYourLife/main.cc

@@ -19,7 +19,7 @@
 #include <iostream>
 
 
-vec3 ray_color(const ray& r, hittable& world, hittable& light_shape, int depth) {
+vec3 ray_color(const ray& r, hittable& world, shared_ptr<hittable> light_shape, int depth) {
     hit_record rec;
 
     // If we've exceeded the ray bounce limit, no more light is gathered.
@@ -40,11 +40,10 @@ vec3 ray_color(const ray& r, hittable& world, hittable& light_shape, int depth)
         return srec.attenuation * ray_color(srec.specular_ray, world, light_shape, depth-1);
     }
 
-    hittable_pdf plight(&light_shape, rec.p);
-    mixture_pdf p(&plight, srec.pdf_ptr);
+    auto plight = make_shared<hittable_pdf>(light_shape, rec.p);
+    mixture_pdf p(plight, srec.pdf_ptr);
     ray scattered = ray(rec.p, p.generate(), r.time());
     auto pdf_val = p.value(scattered.direction());
-    delete srec.pdf_ptr;
 
     return emitted
          + srec.attenuation * rec.mat_ptr->scattering_pdf(r, rec, scattered)
@@ -56,25 +55,25 @@ vec3 ray_color(const ray& r, hittable& world, hittable& light_shape, int depth)
 hittable_list cornell_box(camera& cam, double aspect) {
     hittable_list world;
 
-    auto red = new lambertian(new constant_texture(vec3(0.65, 0.05, 0.05)));
-    auto white = new lambertian(new constant_texture(vec3(0.73, 0.73, 0.73)));
-    auto green = new lambertian(new constant_texture(vec3(0.12, 0.45, 0.15)));
-    auto light = new diffuse_light(new constant_texture(vec3(15, 15, 15)));
-
-    world.add(new flip_face(new yz_rect(0, 555, 0, 555, 555, green)));
-    world.add(new yz_rect(0, 555, 0, 555, 0, red));
-    world.add(new flip_face(new xz_rect(213, 343, 227, 332, 554, light)));
-    world.add(new flip_face(new xz_rect(0, 555, 0, 555, 555, white)));
-    world.add(new xz_rect(0, 555, 0, 555, 0, white));
-    world.add(new flip_face(new xy_rect(0, 555, 0, 555, 555, white)));
-
-    hittable* box1 = new box(vec3(0,0,0), vec3(165,330,165), white);
-    box1 = new rotate_y(box1, 15);
-    box1 = new translate(box1, vec3(265,0,295));
+    auto red = make_shared<lambertian>(make_shared<constant_texture>(vec3(0.65, 0.05, 0.05)));
+    auto white = make_shared<lambertian>(make_shared<constant_texture>(vec3(0.73, 0.73, 0.73)));
+    auto green = make_shared<lambertian>(make_shared<constant_texture>(vec3(0.12, 0.45, 0.15)));
+    auto light = make_shared<diffuse_light>(make_shared<constant_texture>(vec3(15, 15, 15)));
+
+    world.add(make_shared<flip_face>(make_shared<yz_rect>(0, 555, 0, 555, 555, green)));
+    world.add(make_shared<yz_rect>(0, 555, 0, 555, 0, red));
+    world.add(make_shared<flip_face>(make_shared<xz_rect>(213, 343, 227, 332, 554, light)));
+    world.add(make_shared<flip_face>(make_shared<xz_rect>(0, 555, 0, 555, 555, white)));
+    world.add(make_shared<xz_rect>(0, 555, 0, 555, 0, white));
+    world.add(make_shared<flip_face>(make_shared<xy_rect>(0, 555, 0, 555, 555, white)));
+
+    shared_ptr<hittable> box1 = make_shared<box>(vec3(0,0,0), vec3(165,330,165), white);
+    box1 = make_shared<rotate_y>(box1, 15);
+    box1 = make_shared<translate>(box1, vec3(265,0,295));
     world.add(box1);
 
-    material *glass = new dielectric(1.5);
-    world.add(new sphere(vec3(190,90,190), 90 , glass));
+    auto glass = make_shared<dielectric>(1.5);
+    world.add(make_shared<sphere>(vec3(190,90,190), 90 , glass));
 
     vec3 lookfrom(278, 278, -800);
     vec3 lookat(278, 278, 0);
@@ -104,9 +103,9 @@ int main() {
 
     auto world = cornell_box(cam, aspect);
 
-    hittable_list lights;
-    lights.add(new xz_rect(213, 343, 227, 332, 554, 0));
-    lights.add(new sphere(vec3(190, 90, 190), 90, 0));
+    auto lights = make_shared<hittable_list>();
+    lights->add(make_shared<xz_rect>(213, 343, 227, 332, 554, shared_ptr<material>()));
+    lights->add(make_shared<sphere>(vec3(190, 90, 190), 90, shared_ptr<material>()));
 
     for (int j = ny-1; j >= 0; --j) {
         std::cerr << "\rScanlines remaining: " << j << ' ' << std::flush;