Adding monostate in front of each variant

Author: Luc Forget

include/box.hpp

@@ -34,12 +34,9 @@ class box {
     auto closest_so_far = max;
     // Checking if the ray hits any of the sides
     for (const auto& side : sides) {
-      if (dev_visit(
-              [&](auto&& arg) {
-                return arg.hit(ctx, r, min, closest_so_far, temp_rec,
-                               temp_material_type);
-              },
-              side)) {
+      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;

include/constant_medium.hpp

@@ -7,7 +7,7 @@
 #include "texture.hpp"
 #include "visit.hpp"
 
-using hittableVolume_t = std::variant<sphere, box>;
+using hittableVolume_t = std::variant<std::monostate, sphere, box>;
 
 /**
  * A ray going through the volume can either make it all the way through
@@ -31,20 +31,14 @@ class constant_medium {
     hit_material_type = phase_function;
     material_t temp_material_type;
     hit_record rec1, rec2;
-    if (!dev_visit(
-            [&](auto&& arg) {
-              return arg.hit(ctx, r, -infinity, infinity, rec1,
-                             temp_material_type);
-            },
-            boundary)) {
+    if (!dev_visit(hittable_hit_visitor(ctx, r, -infinity, infinity, rec1,
+                                        temp_material_type),
+                   boundary)) {
       return false;
     }
 
-    if (!dev_visit(
-            [&](auto&& arg) {
-              return arg.hit(ctx, r, rec1.t + 0.0001f, infinity, rec2,
-                             temp_material_type);
-            },
+    if (!dev_visit(hittable_hit_visitor(ctx, r, rec1.t + 0.0001f, infinity, rec2,
+                             temp_material_type),
             boundary)) {
       return false;
     }

include/hit_record.hpp

@@ -0,0 +1,23 @@
+#ifndef HIT_RECORD_HPP
+#define HIT_RECORD_HPP
+
+#include "rtweekend.hpp"
+
+class hit_record {
+ public:
+  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 */
+  real_t u;
+  real_t v;
+
+  // To set if the hit point is on the front face
+  void set_face_normal(const ray& r, const vec& outward_normal) {
+    front_face = dot(r.direction(), outward_normal) < 0;
+    normal = front_face ? outward_normal : vec {} - outward_normal;
+  }
+};
+#endif

include/hitable.hpp

@@ -1,26 +1,49 @@
 #ifndef HITTABLE_H
 #define HITTABLE_H
 
-#include "ray.hpp"
+#include <variant>
+
+#include "hit_record.hpp"
+#include "material.hpp"
 #include "rtweekend.hpp"
 #include "vec.hpp"
 
-class hit_record {
+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:
-  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 */
-  real_t u;
-  real_t v;
-
-  // To set if the hit point is on the front face
-  void set_face_normal(const ray& r, const vec& outward_normal) {
-    front_face = dot(r.direction(), outward_normal) < 0;
-    normal = front_face ? outward_normal : vec {} - outward_normal;
+  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"
+#include "ray.hpp"
+#include "rectangle.hpp"
+#include "sphere.hpp"
+#include "triangle.hpp"
+
+using hittable_t = std::variant<std::monostate, sphere, xy_rect, triangle, box,
+                                constant_medium>;
 #endif

include/material.hpp

@@ -3,7 +3,7 @@
 
 #include <iostream>
 
-#include "hitable.hpp"
+#include "hit_record.hpp"
 #include "texture.hpp"
 #include "vec.hpp"
 #include "visit.hpp"
@@ -22,8 +22,7 @@ struct lambertian_material {
     scattered = ray(rec.p, scatter_direction, r_in.time());
     // Attenuation of the ray hitting the object is modified based on the color
     // at hit point
-    attenuation *=
-        dev_visit([&](auto&& arg) { return arg.value(ctx, rec); }, albedo);
+    attenuation *= dev_visit(texture_value_visitor(ctx, rec), albedo);
     return true;
   }
   color emitted(auto&, const hit_record& rec) { return color(0, 0, 0); }
@@ -77,8 +76,7 @@ struct dielectric_material {
     real_t sin_theta = sycl::sqrt(1.0f - cos_theta * cos_theta);
     bool cannot_refract = refraction_ratio * sin_theta > 1.0f;
     vec direction;
-    if (cannot_refract ||
-        reflectance(cos_theta, refraction_ratio) > rng.real())
+    if (cannot_refract || reflectance(cos_theta, refraction_ratio) > rng.real())
       direction = reflect(unit_direction, rec.normal);
     else
       direction = refract(unit_direction, rec.normal, refraction_ratio);
@@ -104,7 +102,7 @@ struct lightsource_material {
   template <typename... T> bool scatter(T&...) const { return false; }
 
   color emitted(auto& ctx, const hit_record& rec) {
-    return dev_visit([&](auto&& arg) { return arg.value(ctx, rec); }, emit);
+    return dev_visit(texture_value_visitor(ctx, rec), emit);
   }
 
   texture_t emit;
@@ -120,8 +118,7 @@ struct isotropic_material {
                color& attenuation, ray& scattered) const {
     auto& rng = ctx.rng;
     scattered = ray(rec.p, rng.in_unit_ball(), r_in.time());
-    attenuation *=
-        dev_visit([&](auto&& arg) { return arg.value(ctx, rec); }, albedo);
+    attenuation *= dev_visit(texture_value_visitor(ctx, rec), albedo);
     return true;
   }
 
@@ -131,7 +128,54 @@ struct isotropic_material {
 };
 
 using material_t =
-    std::variant<lambertian_material, metal_material, dielectric_material,
-                 lightsource_material, isotropic_material>;
+    std::variant<std::monostate, lambertian_material, metal_material,
+                 dielectric_material, lightsource_material, isotropic_material>;
+
+struct material_emitted_visitor {
+ private:
+  task_context& ctx;
+  const hit_record& rec;
+
+ public:
+  material_emitted_visitor(task_context& ctx, hit_record& rec)
+      : ctx { ctx }
+      , rec { rec } {}
+
+  template <typename M> color operator()(M&& material) {
+    return material.emitted(ctx, rec);
+  }
+
+  color operator()(std::monostate) {
+    assert(false && "unreachable");
+    return { 0.f, 0.f, 0.f };
+  }
+};
+
+struct material_scatter_visitor {
+ private:
+  task_context& ctx;
+  const ray& r_in;
+  const hit_record& rec;
+  color& attenuation;
+  ray& scattered;
+
+ public:
+  material_scatter_visitor(auto& ctx, const ray& r_in, const hit_record& rec,
+                           color& attenuation, ray& scattered)
+      : ctx { ctx }
+      , r_in { r_in }
+      , rec { rec }
+      , attenuation { attenuation }
+      , scattered { scattered } {}
+
+  template <typename M> bool operator()(M&& material) {
+    return material.scatter(ctx, r_in, rec, attenuation, scattered);
+  }
+
+  bool operator()(std::monostate) {
+    assert(false && "unreachable");
+    return false;
+  }
+};
 
 #endif

include/render.hpp

@@ -3,25 +3,17 @@
 #include <variant>
 #include <vector>
 
-#include "box.hpp"
 #include "build_parameters.hpp"
 #include "camera.hpp"
-#include "constant_medium.hpp"
 #include "hitable.hpp"
 #include "material.hpp"
 #include "ray.hpp"
-#include "rectangle.hpp"
 #include "rtweekend.hpp"
-#include "sphere.hpp"
 #include "sycl.hpp"
 #include "texture.hpp"
-#include "triangle.hpp"
 #include "vec.hpp"
 #include "visit.hpp"
 
-using hittable_t =
-    std::variant<sphere, xy_rect, triangle, box, constant_medium>;
-
 template <int width, int height, int samples, int depth>
 inline auto render_pixel(auto& ctx, int x_coord, int y_coord, camera const& cam,
                          auto& hittable_acc, auto fb_acc) {
@@ -35,12 +27,9 @@ inline auto render_pixel(auto& ctx, int x_coord, int y_coord, camera const& cam,
       auto closest_so_far = infinity;
       // Checking if the ray hits any of the spheres
       for (auto i = 0; i < hittable_acc.get_count(); i++) {
-        if (dev_visit(
-                [&](auto&& arg) {
-                  return arg.hit(ctx, r, 0.001f, closest_so_far, temp_rec,
-                                 temp_material_type);
-                },
-                hittable_acc[i])) {
+        if (dev_visit(hittable_hit_visitor(ctx, r, 0.001f, closest_so_far,
+                                           temp_rec, temp_material_type),
+                      hittable_acc[i])) {
           hit_anything = true;
           closest_so_far = temp_rec.t;
           rec = temp_rec;
@@ -58,14 +47,10 @@ inline auto render_pixel(auto& ctx, int x_coord, int y_coord, camera const& cam,
     for (auto i = 0; i < depth; i++) {
       hit_record rec;
       if (hit_world(cur_ray, rec, material_type)) {
-        emitted = dev_visit([&](auto&& arg) { return arg.emitted(ctx, rec); },
-                            material_type);
-        if (dev_visit(
-                [&](auto&& arg) {
-                  return arg.scatter(ctx, cur_ray, rec, cur_attenuation,
-                                     scattered);
-                },
-                material_type)) {
+        emitted = dev_visit(material_emitted_visitor(ctx, rec), material_type);
+        if (dev_visit(material_scatter_visitor(ctx, cur_ray, rec,
+                                               cur_attenuation, scattered),
+                      material_type)) {
           // On hitting the object, the ray gets scattered
           cur_ray = scattered;
         } else {

include/texture.hpp

@@ -1,6 +1,6 @@
 #ifndef RT_SYCL_TEXTURE_HPP
 #define RT_SYCL_TEXTURE_HPP
-#include "hitable.hpp"
+#include "hit_record.hpp"
 #include "rtweekend.hpp"
 #include "vec.hpp"
 #include <array>
@@ -151,7 +151,25 @@ struct image_texture {
   }
 };
 
-using texture_t = std::variant<checker_texture, solid_texture, image_texture>;
+using texture_t = std::variant<std::monostate, checker_texture, solid_texture, image_texture>;
+
+struct texture_value_visitor {
+  private:
+    task_context& ctx;
+    const hit_record& rec;
+
+  public:
+    texture_value_visitor(task_context& ctx, const hit_record& rec):ctx{ctx}, rec{rec}{}
+    template<typename T>
+    color operator()(T&& texture) {
+      return texture.value(ctx, rec);
+    }
+
+    color operator()(std::monostate) {
+      assert(false && "unreachable");
+      return {0.f,0.f,0.f};
+    }
+};
 
 // Start filled with the fallback texture (solid blue) for texture load error
 std::vector<uint8_t> image_texture::texture_data { 0, 0, 1 };