Refactoring

Author: Luc Forget

include/box.hpp

@@ -1,10 +1,12 @@
 #ifndef BOX_HPP
 #define BOX_HPP
 
+#include <array>
+
+#include "primitives.hpp"
 #include "rectangle.hpp"
-#include "rtweekend.hpp"
-#include "visit.hpp"
 
+namespace raytracer::scene {
 /// This class implements a axis aligned cuboid using 6 rectangles
 class box {
  public:
@@ -17,39 +19,19 @@ class box {
       , box_max { p1 }
       , material_type { mat_type } {
     /// Add six sides of the box based on box_min and box_max to sides
-    sides[0] = xy_rect(p0.x(), p1.x(), p0.y(), p1.y(), p1.z(), mat_type);
-    sides[1] = xy_rect(p0.x(), p1.x(), p0.y(), p1.y(), p0.z(), mat_type);
-    sides[2] = xz_rect(p0.x(), p1.x(), p0.z(), p1.z(), p1.y(), mat_type);
-    sides[3] = xz_rect(p0.x(), p1.x(), p0.z(), p1.z(), p0.y(), mat_type);
-    sides[4] = yz_rect(p0.y(), p1.y(), p0.z(), p1.z(), p1.x(), mat_type);
-    sides[5] = yz_rect(p0.y(), p1.y(), p0.z(), p1.z(), p0.x(), mat_type);
-  }
-
-  /// Compute ray interaction with the box
-  bool hit(auto& ctx, const ray& r, real_t min, real_t max, hit_record& rec,
-           material_t& hit_material_type) const {
-    hit_record temp_rec;
-    material_t temp_material_type;
-    auto hit_anything = false;
-    auto closest_so_far = max;
-    // Checking if the ray hits any of the sides
-    for (const auto& side : sides) {
-      if (dev_visit(hittable_hit_visitor(ctx, r, min, closest_so_far, temp_rec,
-                                         temp_material_type),
-                    side)) {
-        hit_anything = true;
-        closest_so_far = temp_rec.t;
-        rec = temp_rec;
-        hit_material_type = temp_material_type;
-      }
-    }
-    return hit_anything;
+    sides[0] = xy_rect(p0.x(), p1.x(), p0.y(), p1.y(), p1.z(), material_type);
+    sides[1] = xy_rect(p0.x(), p1.x(), p0.y(), p1.y(), p0.z(), material_type);
+    sides[2] = xz_rect(p0.x(), p1.x(), p0.z(), p1.z(), p1.y(), material_type);
+    sides[3] = xz_rect(p0.x(), p1.x(), p0.z(), p1.z(), p0.y(), material_type);
+    sides[4] = yz_rect(p0.y(), p1.y(), p0.z(), p1.z(), p1.x(), material_type);
+    sides[5] = yz_rect(p0.y(), p1.y(), p0.z(), p1.z(), p0.x(), material_type);
   }
 
   point box_min;
   point box_max;
   material_t material_type;
   std::array<rectangle_t, 6> sides;
 };
+} // namespace raytracer::scene
 
 #endif

include/build_parameters.hpp

@@ -1,6 +1,6 @@
 #ifndef BUILD_PARAMETERS_HPP
 #define BUILD_PARAMETERS_HPP
-namespace buildparams {
+namespace raytracer::buildparams {
 
 #ifdef USE_SINGLE_TASK
 constexpr bool use_single_task = true;

include/camera.hpp

@@ -3,9 +3,11 @@
 
 #include <cmath>
 
+#include "localrandom.hpp"
+#include "primitives.hpp"
 #include "ray.hpp"
-#include "rtweekend.hpp"
 
+namespace raytracer {
 /** Camera model
 
         This implements:
@@ -90,7 +92,7 @@ class camera {
           viewport local coordinates (s,t) based on viewport
           width, height and focus distance
   */
-  ray get_ray(real_t s, real_t t, LocalPseudoRNG& rng) const {
+  ray get_ray(real_t s, real_t t, random::LocalPseudoRNG& rng) const {
     vec rd = lens_radius * rng.in_unit_disk();
     vec offset = u * rd.x() + v * rd.y();
     return { origin + offset,
@@ -99,5 +101,5 @@ class camera {
              rng.real(time0, time1) };
   }
 };
-
+} // namespace raytracer
 #endif

include/constant_medium.hpp

@@ -5,7 +5,8 @@
 #include "material.hpp"
 #include "sphere.hpp"
 #include "texture.hpp"
-#include "visit.hpp"
+
+namespace raytracer::scene {
 
 using hittableVolume_t = std::variant<std::monostate, sphere, box>;
 
@@ -25,54 +26,9 @@ class constant_medium {
       , neg_inv_density { -1 / d }
       , phase_function { isotropic_material { a } } {}
 
-  bool hit(auto& ctx, const ray& r, real_t min, real_t max, hit_record& rec,
-           material_t& hit_material_type) const {
-    auto& rng = ctx.rng;
-    hit_material_type = phase_function;
-    material_t temp_material_type;
-    hit_record rec1, rec2;
-    if (!dev_visit(hittable_hit_visitor(ctx, r, -infinity, infinity, rec1,
-                                        temp_material_type),
-                   boundary)) {
-      return false;
-    }
-
-    if (!dev_visit(hittable_hit_visitor(ctx, r, rec1.t + 0.0001f, infinity, rec2,
-                             temp_material_type),
-            boundary)) {
-      return false;
-    }
-
-    if (rec1.t < min)
-      rec1.t = min;
-    if (rec2.t > max)
-      rec2.t = max;
-    if (rec1.t >= rec2.t)
-      return false;
-    if (rec1.t < 0)
-      rec1.t = 0;
-
-    const auto ray_length = sycl::length(r.direction());
-    /// Distance between the two hitpoints affect of probability
-    /// of the ray hitting a smoke particle
-    const auto distance_inside_boundary = (rec2.t - rec1.t) * ray_length;
-    const auto hit_distance = neg_inv_density * sycl::log(rng.real());
-
-    /// With lower density, hit_distance has higher probabilty
-    /// of being greater than distance_inside_boundary
-    if (hit_distance > distance_inside_boundary)
-      return false;
-
-    rec.t = rec1.t + hit_distance / ray_length;
-    rec.p = r.at(rec.t);
-
-    rec.normal = vec { 1, 0, 0 }; // arbitrary
-    rec.front_face = true;        // also arbitrary
-    return true;
-  }
-
   hittableVolume_t boundary;
   real_t neg_inv_density;
   material_t phase_function;
 };
+} // namespace raytracer::scene
 #endif

include/hit_record.hpp

@@ -1,16 +1,17 @@
 #ifndef HIT_RECORD_HPP
 #define HIT_RECORD_HPP
 
-#include "rtweekend.hpp"
+#include "primitives.hpp"
 
+namespace raytracer::visitor {
 class hit_record {
  public:
-  real_t t;         //
+  real_t t;
   point p;         // hit point
   vec normal;      // normal at hit point
   bool front_face; // to check if hit point is on the outer surface
   /*local coordinates for rectangles
-  and mercator coordintes for spheres */
+  and mercator coordinates for spheres */
   real_t u;
   real_t v;
 
@@ -20,4 +21,5 @@ class hit_record {
     normal = front_face ? outward_normal : vec {} - outward_normal;
   }
 };
+} // namespace raytracer::visitor
 #endif

include/hitable.hpp

@@ -5,37 +5,6 @@
 
 #include "hit_record.hpp"
 #include "material.hpp"
-#include "rtweekend.hpp"
-#include "vec.hpp"
-
-struct hittable_hit_visitor {
- private:
-  task_context& ctx;
-  const ray& r;
-  real_t min;
-  real_t max;
-  hit_record& rec;
-  material_t& hit_material_type;
-
- public:
-  hittable_hit_visitor(task_context& ctx, const ray& r, real_t min, real_t max,
-                       hit_record& rec, material_t& hit_material_type)
-      : ctx { ctx }
-      , r { r }
-      , min { min }
-      , max { max }
-      , rec { rec }
-      , hit_material_type { hit_material_type } {}
-
-  template <typename H> bool operator()(H&& hittable) {
-    return hittable.hit(ctx, r, min, max, rec, hit_material_type);
-  }
-
-  bool operator()(std::monostate) {
-    assert(fase && "unreachable");
-    return false;
-  }
-};
 
 #include "box.hpp"
 #include "constant_medium.hpp"
@@ -44,6 +13,8 @@ struct hittable_hit_visitor {
 #include "sphere.hpp"
 #include "triangle.hpp"
 
+namespace raytracer::scene {
 using hittable_t = std::variant<std::monostate, sphere, xy_rect, triangle, box,
                                 constant_medium>;
+}
 #endif