Cycles: simplify handling of ray distance in GPU rendering

All our intersections functions now work with unnormalized ray direction,
which means we no longer need to transform ray distance between world and
object space, they can all remain in world space.

There doesn't seem to be any real performance difference one way or the
other, but it does simplify the code.

6 files changed, 36 insertions, 161 deletions

diff --git a/intern/cycles/kernel/bvh/bvh.h b/intern/cycles/kernel/bvh/bvh.h
index 9972de86c47..387e74b9885 100644
--- a/intern/cycles/kernel/bvh/bvh.h
+++ b/intern/cycles/kernel/bvh/bvh.h
@@ -475,12 +475,7 @@ ccl_device_intersect bool scene_intersect_local(KernelGlobals kg,
         float3 P = ray->P;
         float3 dir = ray->D;
         float3 idir = ray->D;
-        Transform ob_itfm;
-        rtc_ray.tfar = ray->tmax *
-                       bvh_instance_motion_push(kg, local_object, ray, &P, &dir, &idir, &ob_itfm);
-        /* bvh_instance_motion_push() returns the inverse transform but
-         * it's not needed here. */
-        (void)ob_itfm;
+        bvh_instance_motion_push(kg, local_object, ray, &P, &dir, &idir);
 
         rtc_ray.org_x = P.x;
         rtc_ray.org_y = P.y;
@@ -488,6 +483,8 @@ ccl_device_intersect bool scene_intersect_local(KernelGlobals kg,
         rtc_ray.dir_x = dir.x;
         rtc_ray.dir_y = dir.y;
         rtc_ray.dir_z = dir.z;
+        rtc_ray.tnear = ray->tmin;
+        rtc_ray.tfar = ray->tmax;
         RTCScene scene = (RTCScene)rtcGetGeometryUserData(geom);
         kernel_assert(scene);
         if (scene) {
diff --git a/intern/cycles/kernel/bvh/local.h b/intern/cycles/kernel/bvh/local.h
index 017a241ef4a..add61adc126 100644
--- a/intern/cycles/kernel/bvh/local.h
+++ b/intern/cycles/kernel/bvh/local.h
@@ -59,14 +59,10 @@ ccl_device_inline
   const int object_flag = kernel_data_fetch(object_flag, local_object);
   if (!(object_flag & SD_OBJECT_TRANSFORM_APPLIED)) {
 #if BVH_FEATURE(BVH_MOTION)
-    Transform ob_itfm;
-    const float t_world_to_instance = bvh_instance_motion_push(
-        kg, local_object, ray, &P, &dir, &idir, &ob_itfm);
+    bvh_instance_motion_push(kg, local_object, ray, &P, &dir, &idir);
 #else
-    const float t_world_to_instance = bvh_instance_push(kg, local_object, ray, &P, &dir, &idir);
+    bvh_instance_push(kg, local_object, ray, &P, &dir, &idir);
 #endif
-    isect_t *= t_world_to_instance;
-    tmin *= t_world_to_instance;
     object = local_object;
   }
 
diff --git a/intern/cycles/kernel/bvh/shadow_all.h b/intern/cycles/kernel/bvh/shadow_all.h
index db3c91569aa..f37af2a1e65 100644
--- a/intern/cycles/kernel/bvh/shadow_all.h
+++ b/intern/cycles/kernel/bvh/shadow_all.h
@@ -53,23 +53,11 @@ ccl_device_inline
   int object = OBJECT_NONE;
   uint num_hits = 0;
 
-#if BVH_FEATURE(BVH_MOTION)
-  Transform ob_itfm;
-#endif
-
   /* Max distance in world space. May be dynamically reduced when max number of
    * recorded hits is exceeded and we no longer need to find hits beyond the max
    * distance found. */
-  float t_max_world = ray->tmax;
-
-  /* Current maximum distance to the intersection.
-   * Is calculated as a ray length, transformed to an object space when entering
-   * instance node. */
-  float t_max_current = ray->tmax;
-
-  /* Conversion from world to local space for the current instance if any, 1.0
-   * otherwise. */
-  float t_world_to_instance = 1.0f;
+  const float tmax = ray->tmax;
+  float tmax_hits = tmax;
 
   *r_num_recorded_hits = 0;
   *r_throughput = 1.0f;
@@ -90,7 +78,7 @@ ccl_device_inline
 #endif
                                        idir,
                                        tmin,
-                                       t_max_current,
+                                       tmax,
                                        node_addr,
                                        visibility,
                                        dist);
@@ -158,16 +146,8 @@ ccl_device_inline
 
             switch (type & PRIMITIVE_ALL) {
               case PRIMITIVE_TRIANGLE: {
-                hit = triangle_intersect(kg,
-                                         &isect,
-                                         P,
-                                         dir,
-                                         tmin,
-                                         t_max_current,
-                                         visibility,
-                                         prim_object,
-                                         prim,
-                                         prim_addr);
+                hit = triangle_intersect(
+                    kg, &isect, P, dir, tmin, tmax, visibility, prim_object, prim, prim_addr);
                 break;
               }
 #if BVH_FEATURE(BVH_MOTION)
@@ -177,7 +157,7 @@ ccl_device_inline
                                                 P,
                                                 dir,
                                                 tmin,
-                                                t_max_current,
+                                                tmax,
                                                 ray->time,
                                                 visibility,
                                                 prim_object,
@@ -200,16 +180,8 @@ ccl_device_inline
                 }
 
                 const int curve_type = kernel_data_fetch(prim_type, prim_addr);
-                hit = curve_intersect(kg,
-                                      &isect,
-                                      P,
-                                      dir,
-                                      tmin,
-                                      t_max_current,
-                                      prim_object,
-                                      prim,
-                                      ray->time,
-                                      curve_type);
+                hit = curve_intersect(
+                    kg, &isect, P, dir, tmin, tmax, prim_object, prim, ray->time, curve_type);
 
                 break;
               }
@@ -226,16 +198,8 @@ ccl_device_inline
                 }
 
                 const int point_type = kernel_data_fetch(prim_type, prim_addr);
-                hit = point_intersect(kg,
-                                      &isect,
-                                      P,
-                                      dir,
-                                      tmin,
-                                      t_max_current,
-                                      prim_object,
-                                      prim,
-                                      ray->time,
-                                      point_type);
+                hit = point_intersect(
+                    kg, &isect, P, dir, tmin, tmax, prim_object, prim, ray->time, point_type);
                 break;
               }
 #endif /* BVH_FEATURE(BVH_POINTCLOUD) */
@@ -247,9 +211,6 @@ ccl_device_inline
 
             /* shadow ray early termination */
             if (hit) {
-              /* Convert intersection distance to world space. */
-              isect.t /= t_world_to_instance;
-
               /* detect if this surface has a shader with transparent shadows */
               /* todo: optimize so primitive visibility flag indicates if
                * the primitive has a transparent shadow shader? */
@@ -281,7 +242,7 @@ ccl_device_inline
               if (record_intersection) {
                 /* Test if we need to record this transparent intersection. */
                 const uint max_record_hits = min(max_hits, INTEGRATOR_SHADOW_ISECT_SIZE);
-                if (*r_num_recorded_hits < max_record_hits || isect.t < t_max_world) {
+                if (*r_num_recorded_hits < max_record_hits || isect.t < tmax_hits) {
                   /* If maximum number of hits was reached, replace the intersection with the
                    * highest distance. We want to find the N closest intersections. */
                   const uint num_recorded_hits = min(*r_num_recorded_hits, max_record_hits);
@@ -303,7 +264,7 @@ ccl_device_inline
                     }
 
                     /* Limit the ray distance and stop counting hits beyond this. */
-                    t_max_world = max(isect.t, max_t);
+                    tmax_hits = max(isect.t, max_t);
                   }
 
                   integrator_state_write_shadow_isect(state, &isect, isect_index);
@@ -321,16 +282,11 @@ ccl_device_inline
           object = kernel_data_fetch(prim_object, -prim_addr - 1);
 
 #if BVH_FEATURE(BVH_MOTION)
-          t_world_to_instance = bvh_instance_motion_push(
-              kg, object, ray, &P, &dir, &idir, &ob_itfm);
+          bvh_instance_motion_push(kg, object, ray, &P, &dir, &idir);
 #else
-          t_world_to_instance = bvh_instance_push(kg, object, ray, &P, &dir, &idir);
+          bvh_instance_push(kg, object, ray, &P, &dir, &idir);
 #endif
 
-          /* Convert intersection to object space. */
-          t_max_current *= t_world_to_instance;
-          tmin *= t_world_to_instance;
-
           ++stack_ptr;
           kernel_assert(stack_ptr < BVH_STACK_SIZE);
           traversal_stack[stack_ptr] = ENTRYPOINT_SENTINEL;
@@ -345,17 +301,12 @@ ccl_device_inline
 
       /* Instance pop. */
 #if BVH_FEATURE(BVH_MOTION)
-      bvh_instance_motion_pop(kg, object, ray, &P, &dir, &idir, FLT_MAX, &ob_itfm);
+      bvh_instance_motion_pop(kg, object, ray, &P, &dir, &idir);
 #else
-      bvh_instance_pop(kg, object, ray, &P, &dir, &idir, FLT_MAX);
+      bvh_instance_pop(kg, object, ray, &P, &dir, &idir);
 #endif
 
-      /* Restore world space ray length. */
-      tmin = ray->tmin;
-      t_max_current = ray->tmax;
-
       object = OBJECT_NONE;
-      t_world_to_instance = 1.0f;
       node_addr = traversal_stack[stack_ptr];
       --stack_ptr;
     }
diff --git a/intern/cycles/kernel/bvh/traversal.h b/intern/cycles/kernel/bvh/traversal.h
index 0ff38bf02de..9069d16912b 100644
--- a/intern/cycles/kernel/bvh/traversal.h
+++ b/intern/cycles/kernel/bvh/traversal.h
@@ -43,13 +43,9 @@ ccl_device_noinline bool BVH_FUNCTION_FULL_NAME(BVH)(KernelGlobals kg,
   float3 P = ray->P;
   float3 dir = bvh_clamp_direction(ray->D);
   float3 idir = bvh_inverse_direction(dir);
-  float tmin = ray->tmin;
+  const float tmin = ray->tmin;
   int object = OBJECT_NONE;
 
-#if BVH_FEATURE(BVH_MOTION)
-  Transform ob_itfm;
-#endif
-
   isect->t = ray->tmax;
   isect->u = 0.0f;
   isect->v = 0.0f;
@@ -223,15 +219,11 @@ ccl_device_noinline bool BVH_FUNCTION_FULL_NAME(BVH)(KernelGlobals kg,
           object = kernel_data_fetch(prim_object, -prim_addr - 1);
 
 #if BVH_FEATURE(BVH_MOTION)
-          const float t_world_to_instance = bvh_instance_motion_push(
-              kg, object, ray, &P, &dir, &idir, &ob_itfm);
+          bvh_instance_motion_push(kg, object, ray, &P, &dir, &idir);
 #else
-          const float t_world_to_instance = bvh_instance_push(kg, object, ray, &P, &dir, &idir);
+          bvh_instance_push(kg, object, ray, &P, &dir, &idir);
 #endif
 
-          isect->t *= t_world_to_instance;
-          tmin *= t_world_to_instance;
-
           ++stack_ptr;
           kernel_assert(stack_ptr < BVH_STACK_SIZE);
           traversal_stack[stack_ptr] = ENTRYPOINT_SENTINEL;
@@ -246,11 +238,10 @@ ccl_device_noinline bool BVH_FUNCTION_FULL_NAME(BVH)(KernelGlobals kg,
 
       /* instance pop */
 #if BVH_FEATURE(BVH_MOTION)
-      isect->t = bvh_instance_motion_pop(kg, object, ray, &P, &dir, &idir, isect->t, &ob_itfm);
+      bvh_instance_motion_pop(kg, object, ray, &P, &dir, &idir);
 #else
-      isect->t = bvh_instance_pop(kg, object, ray, &P, &dir, &idir, isect->t);
+      bvh_instance_pop(kg, object, ray, &P, &dir, &idir);
 #endif
-      tmin = ray->tmin;
 
       object = OBJECT_NONE;
       node_addr = traversal_stack[stack_ptr];
diff --git a/intern/cycles/kernel/bvh/volume.h b/intern/cycles/kernel/bvh/volume.h
index bd4e508ecac..cc3915b4bf7 100644
--- a/intern/cycles/kernel/bvh/volume.h
+++ b/intern/cycles/kernel/bvh/volume.h
@@ -46,13 +46,9 @@ ccl_device_inline
   float3 P = ray->P;
   float3 dir = bvh_clamp_direction(ray->D);
   float3 idir = bvh_inverse_direction(dir);
-  float tmin = ray->tmin;
+  const float tmin = ray->tmin;
   int object = OBJECT_NONE;
 
-#if BVH_FEATURE(BVH_MOTION)
-  Transform ob_itfm;
-#endif
-
   isect->t = ray->tmax;
   isect->u = 0.0f;
   isect->v = 0.0f;
@@ -189,15 +185,11 @@ ccl_device_inline
           int object_flag = kernel_data_fetch(object_flag, object);
           if (object_flag & SD_OBJECT_HAS_VOLUME) {
 #if BVH_FEATURE(BVH_MOTION)
-            const float t_world_to_instance = bvh_instance_motion_push(
-                kg, object, ray, &P, &dir, &idir, &ob_itfm);
+            bvh_instance_motion_push(kg, object, ray, &P, &dir, &idir);
 #else
-            const float t_world_to_instance = bvh_instance_push(kg, object, ray, &P, &dir, &idir);
+            bvh_instance_push(kg, object, ray, &P, &dir, &idir);
 #endif
 
-            isect->t *= t_world_to_instance;
-            tmin *= t_world_to_instance;
-
             ++stack_ptr;
             kernel_assert(stack_ptr < BVH_STACK_SIZE);
             traversal_stack[stack_ptr] = ENTRYPOINT_SENTINEL;
@@ -219,13 +211,11 @@ ccl_device_inline
 
       /* instance pop */
 #if BVH_FEATURE(BVH_MOTION)
-      isect->t = bvh_instance_motion_pop(kg, object, ray, &P, &dir, &idir, isect->t, &ob_itfm);
+      bvh_instance_motion_pop(kg, object, ray, &P, &dir, &idir);
 #else
-      isect->t = bvh_instance_pop(kg, object, ray, &P, &dir, &idir, isect->t);
+      bvh_instance_pop(kg, object, ray, &P, &dir, &idir);
 #endif
 
-      tmin = ray->tmin;
-
       object = OBJECT_NONE;
       node_addr = traversal_stack[stack_ptr];
       --stack_ptr;
diff --git a/intern/cycles/kernel/bvh/volume_all.h b/intern/cycles/kernel/bvh/volume_all.h
index c6eeb07a14d..5cdea3e354c 100644
--- a/intern/cycles/kernel/bvh/volume_all.h
+++ b/intern/cycles/kernel/bvh/volume_all.h
@@ -47,14 +47,10 @@ ccl_device_inline
   float3 P = ray->P;
   float3 dir = bvh_clamp_direction(ray->D);
   float3 idir = bvh_inverse_direction(dir);
-  float tmin = ray->tmin;
+  const float tmin = ray->tmin;
   int object = OBJECT_NONE;
   float isect_t = ray->tmax;
 
-#if BVH_FEATURE(BVH_MOTION)
-  Transform ob_itfm;
-#endif
-
   int num_hits_in_instance = 0;
 
   uint num_hits = 0;
@@ -159,18 +155,6 @@ ccl_device_inline
                   num_hits_in_instance++;
                   isect_array->t = isect_t;
                   if (num_hits == max_hits) {
-                    if (object != OBJECT_NONE) {
-#if BVH_FEATURE(BVH_MOTION)
-                      float t_fac = 1.0f / len(transform_direction(&ob_itfm, dir));
-#else
-                      Transform itfm = object_fetch_transform(
-                          kg, object, OBJECT_INVERSE_TRANSFORM);
-                      float t_fac = 1.0f / len(transform_direction(&itfm, dir));
-#endif
-                      for (int i = 0; i < num_hits_in_instance; i++) {
-                        (isect_array - i - 1)->t *= t_fac;
-                      }
-                    }
                     return num_hits;
                   }
                 }
@@ -212,18 +196,6 @@ ccl_device_inline
                   num_hits_in_instance++;
                   isect_array->t = isect_t;
                   if (num_hits == max_hits) {
-                    if (object != OBJECT_NONE) {
-#  if BVH_FEATURE(BVH_MOTION)
-                      float t_fac = 1.0f / len(transform_direction(&ob_itfm, dir));
-#  else
-                      Transform itfm = object_fetch_transform(
-                          kg, object, OBJECT_INVERSE_TRANSFORM);
-                      float t_fac = 1.0f / len(transform_direction(&itfm, dir));
-#  endif
-                      for (int i = 0; i < num_hits_in_instance; i++) {
-                        (isect_array - i - 1)->t *= t_fac;
-                      }
-                    }
                     return num_hits;
                   }
                 }
@@ -242,15 +214,11 @@ ccl_device_inline
           int object_flag = kernel_data_fetch(object_flag, object);
           if (object_flag & SD_OBJECT_HAS_VOLUME) {
 #if BVH_FEATURE(BVH_MOTION)
-            const float t_world_to_instance = bvh_instance_motion_push(
-                kg, object, ray, &P, &dir, &idir, &ob_itfm);
+            bvh_instance_motion_push(kg, object, ray, &P, &dir, &idir);
 #else
-            const float t_world_to_instance = bvh_instance_push(kg, object, ray, &P, &dir, &idir);
+            bvh_instance_push(kg, object, ray, &P, &dir, &idir);
 #endif
 
-            isect_t *= t_world_to_instance;
-            tmin *= t_world_to_instance;
-
             num_hits_in_instance = 0;
             isect_array->t = isect_t;
 
@@ -274,29 +242,11 @@ ccl_device_inline
       kernel_assert(object != OBJECT_NONE);
 
       /* Instance pop. */
-      if (num_hits_in_instance) {
-        float t_fac;
 #if BVH_FEATURE(BVH_MOTION)
-        bvh_instance_motion_pop_factor(kg, object, ray, &P, &dir, &idir, &t_fac, &ob_itfm);
+      bvh_instance_motion_pop(kg, object, ray, &P, &dir, &idir);
 #else
-        bvh_instance_pop_factor(kg, object, ray, &P, &dir, &idir, &t_fac);
+      bvh_instance_pop(kg, object, ray, &P, &dir, &idir);
 #endif
-        /* Scale isect->t to adjust for instancing. */
-        for (int i = 0; i < num_hits_in_instance; i++) {
-          (isect_array - i - 1)->t *= t_fac;
-        }
-      }
-      else {
-#if BVH_FEATURE(BVH_MOTION)
-        bvh_instance_motion_pop(kg, object, ray, &P, &dir, &idir, FLT_MAX, &ob_itfm);
-#else
-        bvh_instance_pop(kg, object, ray, &P, &dir, &idir, FLT_MAX);
-#endif
-      }
-
-      tmin = ray->tmin;
-      isect_t = ray->tmax;
-      isect_array->t = isect_t;
 
       object = OBJECT_NONE;
       node_addr = traversal_stack[stack_ptr];