Update book2 to shared_ptr

Author: hollasch

books/RayTracingTheNextWeek.html

@@ -30,6 +30,7 @@ class xy_rect: public hittable {
             return true;
         }
 
+    public:
         shared_ptr<material> mp;
         double x0, x1, y0, y1, k;
 };
@@ -49,6 +50,7 @@ class xz_rect: public hittable {
             return true;
         }
 
+    public:
         shared_ptr<material> mp;
         double x0, x1, z0, z1, k;
 };
@@ -68,6 +70,7 @@ class yz_rect: public hittable {
             return true;
         }
 
+    public:
         shared_ptr<material> mp;
         double y0, y1, z0, z1, k;
 };

src/TheNextWeek/aarect.h

@@ -31,6 +31,7 @@ class constant_medium : public hittable  {
             return boundary->bounding_box(t0, t1, output_box);
         }
 
+    public:
         shared_ptr<hittable> boundary;
         double density;
         shared_ptr<material> phase_function;

src/TheNextWeek/constant_medium.h

@@ -40,12 +40,14 @@ struct hit_record {
     }
 };
 
+
 class hittable {
     public:
         virtual bool hit(const ray& r, double t_min, double t_max, hit_record& rec) const = 0;
         virtual bool bounding_box(double t0, double t1, aabb& output_box) const = 0;
 };
 
+
 class flip_face : public hittable {
     public:
         flip_face(shared_ptr<hittable> p) : ptr(p) {}
@@ -67,10 +69,12 @@ class flip_face : public hittable {
         shared_ptr<hittable> ptr;
 };
 
+
 class translate : public hittable {
     public:
         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;
 
@@ -79,6 +83,7 @@ class translate : public hittable {
         vec3 offset;
 };
 
+
 bool translate::hit(const ray& r, double t_min, double t_max, hit_record& rec) const {
     ray moved_r(r.origin() - offset, r.direction(), r.time());
     if (ptr->hit(moved_r, t_min, t_max, rec)) {
@@ -90,6 +95,7 @@ bool translate::hit(const ray& r, double t_min, double t_max, hit_record& rec) c
         return false;
 }
 
+
 bool translate::bounding_box(double t0, double t1, aabb& output_box) const {
     if (ptr->bounding_box(t0, t1, output_box)) {
         output_box = aabb(
@@ -101,22 +107,26 @@ bool translate::bounding_box(double t0, double t1, aabb& output_box) const {
         return false;
 }
 
+
 class rotate_y : public hittable {
     public:
         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;
         }
 
+    public:
         shared_ptr<hittable> ptr;
         double sin_theta;
         double cos_theta;
         bool hasbox;
         aabb bbox;
 };
 
+
 rotate_y::rotate_y(shared_ptr<hittable> p, double angle) : ptr(p) {
     auto radians = degrees_to_radians(angle);
     sin_theta = sin(radians);
@@ -145,6 +155,7 @@ rotate_y::rotate_y(shared_ptr<hittable> p, double angle) : ptr(p) {
     bbox = aabb(min, max);
 }
 
+
 bool rotate_y::hit(const ray& r, double t_min, double t_max, hit_record& rec) const {
     vec3 origin = r.origin();
     vec3 direction = r.direction();

src/TheNextWeek/hittable.h

@@ -46,14 +46,14 @@ vec3 ray_color(const ray& r, hittable& world, int depth) {
 
 
 hittable_list random_scene() {
-    hittable_list objects;
+    hittable_list world;
 
     auto checker = make_shared<checker_texture>(
         make_shared<constant_texture>(vec3(0.2, 0.3, 0.1)),
         make_shared<constant_texture>(vec3(0.9, 0.9, 0.9))
     );
 
-    objects.add(make_shared<sphere>(vec3(0,-1000,0), 1000, make_shared<lambertian>(checker)));
+    world.add(make_shared<sphere>(vec3(0,-1000,0), 1000, make_shared<lambertian>(checker)));
 
     for (int a = -10; a < 10; a++) {
         for (int b = -10; b < 10; b++) {
@@ -63,33 +63,33 @@ hittable_list random_scene() {
                 if (choose_mat < 0.8) {
                     // diffuse
                     auto albedo = vec3::random() * vec3::random();
-                    objects.add(make_shared<moving_sphere>(
+                    world.add(make_shared<moving_sphere>(
                         center, center + vec3(0, random_double(0,.5), 0), 0.0, 1.0, 0.2,
                         make_shared<lambertian>(make_shared<constant_texture>(albedo))
                     ));
                 } else if (choose_mat < 0.95) {
                     // metal
                     auto albedo = vec3::random(.5, 1);
                     auto fuzz = random_double(0, .5);
-                    objects.add(
+                    world.add(
                         make_shared<sphere>(center, 0.2, make_shared<metal>(albedo, fuzz)));
                 } else {
                     // glass
-                    objects.add(make_shared<sphere>(center, 0.2, make_shared<dielectric>(1.5)));
+                    world.add(make_shared<sphere>(center, 0.2, make_shared<dielectric>(1.5)));
                 }
             }
         }
     }
 
-    objects.add(make_shared<sphere>(vec3(0, 1, 0), 1.0, make_shared<dielectric>(1.5)));
-    objects.add(make_shared<sphere>(
+    world.add(make_shared<sphere>(vec3(0, 1, 0), 1.0, make_shared<dielectric>(1.5)));
+    world.add(make_shared<sphere>(
         vec3(-4, 1, 0), 1.0,
         make_shared<lambertian>(make_shared<constant_texture>(vec3(0.4, 0.2, 0.1)))
     ));
-    objects.add(
+    world.add(
         make_shared<sphere>(vec3(4, 1, 0), 1.0, make_shared<metal>(vec3(0.7, 0.6, 0.5), 0.0)));
 
-    return hittable_list(make_shared<bvh_node>(objects, 0.0, 1.0));
+    return hittable_list(make_shared<bvh_node>(world, 0.0, 1.0));
 }
 
 
@@ -121,7 +121,7 @@ hittable_list two_perlin_spheres() {
 
 hittable_list earth() {
     int nx, ny, nn;
-    unsigned char *texture_data = stbi_load("earthmap.jpg", &nx, &ny, &nn, 0);
+    unsigned char* texture_data = stbi_load("earthmap.jpg", &nx, &ny, &nn, 0);
 
     auto earth_surface =
         make_shared<lambertian>(make_shared<image_texture>(texture_data, nx, ny));

src/TheNextWeek/main.cc

@@ -67,6 +67,7 @@ class dielectric : public material {
             return true;
         }
 
+    public:
         double ref_idx;
 };
 
@@ -85,6 +86,7 @@ class diffuse_light : public material {
             return emit->value(u, v, p);
         }
 
+    public:
         shared_ptr<texture> emit;
 };
 
@@ -101,6 +103,7 @@ class isotropic : public material {
             return true;
         }
 
+    public:
         shared_ptr<texture> albedo;
 };
 
@@ -118,6 +121,7 @@ class lambertian : public material {
             return true;
         }
 
+    public:
         shared_ptr<texture> albedo;
 };
 
@@ -135,6 +139,7 @@ class metal : public material {
             return (dot(scattered.direction(), rec.normal) > 0);
         }
 
+    public:
         vec3 albedo;
         double fuzz;
 };

src/TheNextWeek/material.h

@@ -15,7 +15,7 @@
 #include "hittable.h"
 
 
-class moving_sphere: public hittable  {
+class moving_sphere : public hittable {
     public:
         moving_sphere() {}
         moving_sphere(
@@ -28,16 +28,19 @@ class moving_sphere: public hittable  {
 
         vec3 center(double time) const;
 
+    public:
         vec3 center0, center1;
         double time0, time1;
         double radius;
         shared_ptr<material> mat_ptr;
 };
 
+
 vec3 moving_sphere::center(double time) const{
     return center0 + ((time - time0) / (time1 - time0))*(center1 - center0);
 }
 
+
 bool moving_sphere::bounding_box(double t0, double t1, aabb& output_box) const {
     aabb box0(
         center(t0) - vec3(radius, radius, radius),

src/TheNextWeek/moving_sphere.h

@@ -30,6 +30,7 @@ inline double perlin_interp(vec3 c[2][2][2], double u, double v, double w) {
     return accum;
 }
 
+
 class perlin {
     public:
         double noise(const vec3& p) const {
@@ -48,6 +49,7 @@ class perlin {
                         ];
             return perlin_interp(c, u, v, w);
         }
+
         double turb(const vec3& p, int depth=7) const {
             auto accum = 0.0;
             vec3 temp_p = p;
@@ -59,12 +61,15 @@ class perlin {
             }
             return fabs(accum);
         }
+
+    public:
         static vec3 *ranvec;
         static int *perm_x;
         static int *perm_y;
         static int *perm_z;
 };
 
+
 static vec3* perlin_generate() {
     vec3 *p = new vec3[256];
     for (int i = 0; i < 256; ++i) {
@@ -73,6 +78,7 @@ static vec3* perlin_generate() {
     return p;
 }
 
+
 void permute(int *p, int n) {
     for (int i = n-1; i > 0; i--) {
         int target = random_int(0,i);
@@ -83,6 +89,7 @@ void permute(int *p, int n) {
     return;
 }
 
+
 static int* perlin_generate_perm() {
     int * p = new int[256];
     for (int i = 0; i < 256; i++)
@@ -91,9 +98,11 @@ static int* perlin_generate_perm() {
     return p;
 }
 
+
 vec3 *perlin::ranvec = perlin_generate();
 int *perlin::perm_x = perlin_generate_perm();
 int *perlin::perm_y = perlin_generate_perm();
 int *perlin::perm_z = perlin_generate_perm();
 
+
 #endif

src/common/perlin.h

@@ -30,6 +30,7 @@ class constant_texture : public texture {
             return color;
         }
 
+    public:
         vec3 color;
 };
 
@@ -47,6 +48,7 @@ class checker_texture : public texture {
                 return even->value(u, v, p);
         }
 
+    public:
         shared_ptr<texture> odd;
         shared_ptr<texture> even;
 };
@@ -63,6 +65,7 @@ class noise_texture : public texture {
             return vec3(1,1,1)*0.5*(1 + sin(scale*p.z() + 10*noise.turb(p)));
         }
 
+    public:
         perlin noise;
         double scale;
 };
@@ -72,6 +75,7 @@ class image_texture : public texture {
     public:
         image_texture() {}
         image_texture(unsigned char *pixels, int A, int B) : data(pixels), nx(A), ny(B) {}
+
         ~image_texture() {
             delete data;
         }