Clean up internal raytracing API a bit.

1 files changed, 74 insertions, 60 deletions

diff --git a/libdimension/raytrace.c b/libdimension/raytrace.c
index 7906df0..6d9d0d9 100644
--- a/libdimension/raytrace.c
+++ b/libdimension/raytrace.c
@@ -215,10 +215,16 @@ dmnsn_raytrace_scene_multithread_thread(void *ptr)
  * Raytracing algorithm
  */
 
+typedef struct dmnsn_raytrace_state {
+  const dmnsn_scene *scene;
+  const dmnsn_intersection *intersection;
+  dmnsn_kD_splay_tree *kD_splay_tree;
+} dmnsn_raytrace_state;
+
 /* Main helper for dmnsn_raytrace_scene_impl - shoot a ray */
-static dmnsn_color dmnsn_raytrace_shoot(dmnsn_line ray, dmnsn_scene *scene,
-                                        dmnsn_kD_splay_tree *kD_splay_tree,
-                                        dmnsn_color color, unsigned int level);
+static dmnsn_color dmnsn_raytrace_shoot(dmnsn_raytrace_state *state,
+                                        dmnsn_line ray, dmnsn_color background,
+                                        unsigned int level);
 
 /* Actually raytrace a scene */
 static int
@@ -226,28 +232,31 @@ dmnsn_raytrace_scene_impl(dmnsn_progress *progress, dmnsn_scene *scene,
                           dmnsn_kD_splay_tree *kD_splay_tree,
                           unsigned int index, unsigned int threads)
 {
-  unsigned int x, y;
-  unsigned int width, height;
-  dmnsn_line ray;
-  dmnsn_color color;
+  dmnsn_raytrace_state state = {
+    .scene = scene,
+    .kD_splay_tree = kD_splay_tree
+  };
 
-  width  = scene->canvas->x;
-  height = scene->canvas->y;
+  unsigned int width  = scene->canvas->x;
+  unsigned int height = scene->canvas->y;
 
   /* Iterate through each pixel */
+  unsigned int y;
   for (y = index; y < height; y += threads) {
+    unsigned int x;
     for (x = 0; x < width; ++x) {
       /* Set the pixel to the background color */
-      color = scene->background;
+      dmnsn_color color = scene->background;
 
       if (scene->quality & DMNSN_RENDER_OBJECTS) {
         /* Get the ray corresponding to the (x,y)'th pixel */
-        ray = (*scene->camera->ray_fn)(scene->camera,
-                                       ((double)x)/(scene->canvas->x - 1),
-                                       ((double)y)/(scene->canvas->y - 1));
+        dmnsn_line ray = (*scene->camera->ray_fn)(
+          scene->camera,
+          ((double)x)/(scene->canvas->x - 1),
+          ((double)y)/(scene->canvas->y - 1)
+        );
         /* Shoot a ray */
-        color = dmnsn_raytrace_shoot(ray, scene, kD_splay_tree, color,
-                                     10);
+        color = dmnsn_raytrace_shoot(&state, ray, color, 10);
       }
 
       dmnsn_set_pixel(scene->canvas, x, y, color);
@@ -259,6 +268,7 @@ dmnsn_raytrace_scene_impl(dmnsn_progress *progress, dmnsn_scene *scene,
   return 0;
 }
 
+/* Add epsilon*l.n to l.x0, to avoid self-intersections */
 static dmnsn_line
 dmnsn_line_add_epsilon(dmnsn_line l)
 {
@@ -272,25 +282,26 @@ dmnsn_line_add_epsilon(dmnsn_line l)
 }
 
 static dmnsn_color
-dmnsn_raytrace_pigment(dmnsn_intersection *intersection, dmnsn_scene *scene)
+dmnsn_raytrace_pigment(const dmnsn_raytrace_state *state)
 {
   /* Default to black if there's no texture/pigment */
   dmnsn_color color = dmnsn_black;
 
   /* Use the default texture if given a NULL texture */
-  const dmnsn_texture *texture = intersection->texture ? intersection->texture
-                                                       : scene->default_texture;
+  const dmnsn_texture *texture
+    = state->intersection->texture ? state->intersection->texture
+                                   : state->scene->default_texture;
 
   if (texture) {
     /* Use the default pigment if given a NULL pigment */
     const dmnsn_pigment *pigment
       = texture->pigment ? texture->pigment
-                         : scene->default_texture->pigment;
+                         : state->scene->default_texture->pigment;
 
     if (pigment) {
       color = (*pigment->pigment_fn)(
         pigment,
-        dmnsn_line_point(intersection->ray, intersection->t)
+        dmnsn_line_point(state->intersection->ray, state->intersection->t)
       );
     }
   }
@@ -300,35 +311,41 @@ dmnsn_raytrace_pigment(dmnsn_intersection *intersection, dmnsn_scene *scene)
 
 /* Get the color of a light ray at an intersection point */
 static bool
-dmnsn_raytrace_light_ray(dmnsn_intersection *intersection, dmnsn_scene *scene,
-                         dmnsn_kD_splay_tree *kD_splay_tree,
+dmnsn_raytrace_light_ray(const dmnsn_raytrace_state *state,
                          const dmnsn_light *light, dmnsn_color *color,
                          unsigned int level)
 {
   *color = dmnsn_black;
 
-  dmnsn_vector x0 = dmnsn_line_point(intersection->ray, intersection->t);
+  dmnsn_vector x0 = dmnsn_line_point(state->intersection->ray,
+                                     state->intersection->t);
   dmnsn_line shadow_ray = dmnsn_new_line(x0, dmnsn_vector_sub(light->x0, x0));
   /* Add epsilon to avoid hitting ourselves with the shadow ray */
   shadow_ray = dmnsn_line_add_epsilon(shadow_ray);
 
   /* Search for an object in the way of the light source */
-  if (dmnsn_vector_dot(shadow_ray.n, intersection->normal) < 0.0)
+  if (dmnsn_vector_dot(shadow_ray.n, state->intersection->normal) < 0.0)
     return false;
 
   *color = (*light->light_fn)(light, x0);
 
-  dmnsn_intersection *shadow_caster;
   while (level) {
     --level;
-    shadow_caster = dmnsn_kD_splay_search(kD_splay_tree, shadow_ray);
+
+    dmnsn_intersection *shadow_caster = dmnsn_kD_splay_search(
+      state->kD_splay_tree,
+      shadow_ray
+    );
 
     if (!shadow_caster || shadow_caster->t > 1.0) {
       dmnsn_delete_intersection(shadow_caster);
       break;
     }
 
-    dmnsn_color pigment = dmnsn_raytrace_pigment(shadow_caster, scene);
+    dmnsn_raytrace_state shadow_state = *state;
+    shadow_state.intersection = shadow_caster;
+
+    dmnsn_color pigment = dmnsn_raytrace_pigment(&shadow_state);
     if (pigment.filter || pigment.trans) {
       *color = dmnsn_color_filter(*color, pigment);
       shadow_ray.x0 = dmnsn_line_point(shadow_ray, shadow_caster->t);
@@ -347,18 +364,19 @@ dmnsn_raytrace_light_ray(dmnsn_intersection *intersection, dmnsn_scene *scene,
 }
 
 static dmnsn_color
-dmnsn_raytrace_lighting(dmnsn_intersection *intersection, dmnsn_scene *scene,
-                        dmnsn_kD_splay_tree *kD_splay_tree, dmnsn_color color,
+dmnsn_raytrace_lighting(const dmnsn_raytrace_state *state, dmnsn_color color,
                         unsigned int level)
 {
   /* Use the default texture if given a NULL texture */
-  const dmnsn_texture *texture = intersection->texture ? intersection->texture
-                                                       : scene->default_texture;
+  const dmnsn_texture *texture
+    = state->intersection->texture ? state->intersection->texture
+                                   : state->scene->default_texture;
 
   const dmnsn_finish *finish = NULL;
   if (texture) {
     /* Use the default finish if given a NULL finish */
-    finish = texture->finish ? texture->finish : scene->default_texture->finish;
+    finish = texture->finish ? texture->finish
+                             : state->scene->default_texture->finish;
   }
 
   /* The illuminated color */
@@ -366,28 +384,28 @@ dmnsn_raytrace_lighting(dmnsn_intersection *intersection, dmnsn_scene *scene,
   if (finish && finish->ambient_fn)
     illum = (*finish->ambient_fn)(finish, color);
 
-  dmnsn_vector x0 = dmnsn_line_point(intersection->ray, intersection->t);
+  dmnsn_vector x0 = dmnsn_line_point(state->intersection->ray,
+                                     state->intersection->t);
 
   const dmnsn_light *light;
   unsigned int i;
 
   /* Iterate over each light */
-  for (i = 0; i < dmnsn_array_size(scene->lights); ++i) {
-    dmnsn_array_get(scene->lights, i, &light);
+  for (i = 0; i < dmnsn_array_size(state->scene->lights); ++i) {
+    dmnsn_array_get(state->scene->lights, i, &light);
 
     dmnsn_color light_color;
-    if (dmnsn_raytrace_light_ray(intersection, scene, kD_splay_tree, light,
-                                 &light_color, level))
-    {
-      if (scene->quality & DMNSN_RENDER_FINISH
+    if (dmnsn_raytrace_light_ray(state, light, &light_color, level)) {
+      if (state->scene->quality & DMNSN_RENDER_FINISH
           && finish && finish->finish_fn)
       {
         dmnsn_vector ray = dmnsn_vector_normalize(
           dmnsn_vector_sub(light->x0, x0)
         );
-        dmnsn_vector normal = intersection->normal;
-        dmnsn_vector viewer
-          = dmnsn_vector_normalize(dmnsn_vector_negate(intersection->ray.n));
+        dmnsn_vector normal = state->intersection->normal;
+        dmnsn_vector viewer = dmnsn_vector_normalize(
+          dmnsn_vector_negate(state->intersection->ray.n)
+        );
 
         /* Get this light's color contribution to the object */
         dmnsn_color contrib = (*finish->finish_fn)(finish,
@@ -405,22 +423,24 @@ dmnsn_raytrace_lighting(dmnsn_intersection *intersection, dmnsn_scene *scene,
 
 /* Shoot a ray, and calculate the color, using `color' as the background */
 static dmnsn_color
-dmnsn_raytrace_shoot(dmnsn_line ray, dmnsn_scene *scene,
-                     dmnsn_kD_splay_tree *kD_splay_tree, dmnsn_color background,
-                     unsigned int level)
+dmnsn_raytrace_shoot(dmnsn_raytrace_state *state, dmnsn_line ray,
+                     dmnsn_color background, unsigned int level)
 {
   if (level <= 0)
     return dmnsn_black;
   --level;
 
-  dmnsn_intersection *intersection = dmnsn_kD_splay_search(kD_splay_tree, ray);
+  dmnsn_intersection *intersection
+    = dmnsn_kD_splay_search(state->kD_splay_tree, ray);
 
   dmnsn_color color = background;
   if (intersection) {
+    state->intersection = intersection;
+
     /* Get the pigment of the object */
     dmnsn_color pigment = dmnsn_black;
-    if (scene->quality & DMNSN_RENDER_PIGMENT) {
-      pigment = dmnsn_raytrace_pigment(intersection, scene);
+    if (state->scene->quality & DMNSN_RENDER_PIGMENT) {
+      pigment = dmnsn_raytrace_pigment(state);
     }
     color = pigment;
     color.filter = 0.0;
@@ -428,12 +448,8 @@ dmnsn_raytrace_shoot(dmnsn_line ray, dmnsn_scene *scene,
 
     /* Account for finishes and shadows */
     dmnsn_color illum = pigment;
-    if (scene->quality & DMNSN_RENDER_LIGHTS) {
-      illum = dmnsn_raytrace_lighting(intersection,
-                                      scene,
-                                      kD_splay_tree,
-                                      pigment,
-                                      level);
+    if (state->scene->quality & DMNSN_RENDER_LIGHTS) {
+      illum = dmnsn_raytrace_lighting(state, pigment, level);
     }
     color = illum;
     color.filter = 0.0;
@@ -441,7 +457,7 @@ dmnsn_raytrace_shoot(dmnsn_line ray, dmnsn_scene *scene,
 
     /* Account for translucency */
     dmnsn_color trans = illum;
-    if (scene->quality & DMNSN_RENDER_TRANSLUCENCY
+    if (state->scene->quality & DMNSN_RENDER_TRANSLUCENCY
         && (pigment.filter || pigment.trans))
     {
       trans = dmnsn_color_mul(1.0 - pigment.filter - pigment.trans, illum);
@@ -454,11 +470,9 @@ dmnsn_raytrace_shoot(dmnsn_line ray, dmnsn_scene *scene,
       );
       trans_ray = dmnsn_line_add_epsilon(trans_ray);
 
-      dmnsn_color rec = dmnsn_raytrace_shoot(trans_ray,
-                                             scene,
-                                             kD_splay_tree,
-                                             background,
-                                             level);
+      dmnsn_raytrace_state recursive_state = *state;
+      dmnsn_color rec
+        = dmnsn_raytrace_shoot(&recursive_state, trans_ray, background, level);
       dmnsn_color filtered = dmnsn_color_filter(rec, pigment);
       trans = dmnsn_color_add(trans, filtered);
     }