Stratified sampling. Fix type casts and embree namespace

Author: dedoardo

src/bvh/bvh_embree.cpp

@@ -53,6 +53,7 @@
 #  include "util/util_logging.h"
 #  include "util/util_progress.h"
 #  include "util/util_stats.h"
+#  include "util/util_hash.h"
 
 CCL_NAMESPACE_BEGIN
 
@@ -256,10 +257,23 @@ static void rtc_filter_occluded_func_thick_curve(const RTC_NAMESPACE::RTCFilterF
   rtc_filter_occluded_func(args);
 }
 
+/* Generate a pseudo random bit sequence trying to keep disjoint spans uncorrelated.
+  https://research.nvidia.com/publication/stratified-sampling-stochastic-transparency
+*/
+inline float get_opacity_stratified(uint rng_pixel_sample, uint rng_surface) {
+  // pixel_id + sample * num_samples
+  uint x = reverse_bits_32(rng_pixel_sample) + rng_surface;
+  x = x ^ (x * 0x6C50B47Cu);
+  x = x ^ (x * 0xB82F1E52u);
+  x = x ^ (x * 0xC7AFE638u);
+  x = x ^ (x * 0x8D22F6E6u);
+  return (float)(x * 0x1p-32);
+}
+
 static void rtc_filter_func_transparent_points(const RTC_NAMESPACE::RTCFilterFunctionNArguments *args)
 {
-  const RTC_NAMESPACE::RTCRay *ray = (RTCRay *)args->ray;
-  RTC_NAMESPACE::RTCHit *hit = (RTCHit *)args->hit;
+  const RTC_NAMESPACE::RTCRay *ray = (RTC_NAMESPACE::RTCRay *)args->ray;
+  RTC_NAMESPACE::RTCHit *hit = (RTC_NAMESPACE::RTCHit *)args->hit;
   CCLIntersectContext *ctx = ((IntersectContext *)args->context)->userRayExt;
   KernelGlobals *kg = ctx->kg;
 
@@ -275,8 +289,7 @@ static void rtc_filter_func_transparent_points(const RTC_NAMESPACE::RTCFilterFun
   const float opacity = kernel_tex_fetch(__points_opacity, opacity_offset);
 
   /* Unique random number per ray per geometry */
-  uint hash = (uint&)ctx->ps_rng_transparent;
-  const float rand_opacity = cmj_randfloat(hash, cmj_hash(object, prim));
+  const float rand_opacity = cmj_randfloat(ctx->rng_transparent, cmj_hash(object, prim));
 
   if (rand_opacity > opacity) {
     *args->valid = 0;

src/kernel/bvh/bvh.h

@@ -155,7 +155,7 @@ ccl_device_intersect bool scene_intersect(KernelGlobals *kg,
                                           const Ray *ray,
                                           const uint visibility,
                                           Intersection *isect,
-                                          float ps_rng = 0.0f)
+                                          uint rng_transparent)
 {
   PROFILING_INIT(kg, PROFILING_INTERSECT);
 
@@ -203,7 +203,7 @@ ccl_device_intersect bool scene_intersect(KernelGlobals *kg,
     isect->t = ray->t;
     CCLIntersectContext ctx(kg, CCLIntersectContext::RAY_REGULAR);
     IntersectContext rtc_ctx(&ctx);
-    ctx.ps_rng_transparent = ps_rng;
+    ctx.rng_transparent = rng_transparent;
     RTC_NAMESPACE::RTCRayHit ray_hit;
     kernel_embree_setup_rayhit(*ray, ray_hit, visibility);
     rtcIntersect1(kernel_data.bvh.scene, &rtc_ctx.context, &ray_hit);

src/kernel/bvh/bvh_embree.h

@@ -50,7 +50,7 @@ struct CCLIntersectContext {
   uint *lcg_state;
 
   /* for transparent rays */
-  float ps_rng_transparent;
+  uint rng_transparent;
 
   CCLIntersectContext(KernelGlobals *kg_, RayType type_)
   {
@@ -62,7 +62,7 @@ struct CCLIntersectContext {
     local_isect = NULL;
     local_object_id = -1;
     lcg_state = NULL;
-    ps_rng_transparent = 0;
+    rng_transparent = 0;
   }
 };
 

src/kernel/geom/geom_point_intersect.h

@@ -78,7 +78,7 @@ ccl_device_forceinline bool point_intersect_test_disc(const float4 point,
   }
 
   /* Self-intersection */
-  const float avoidance_factor = 2.0 * radius * rd;
+  const float avoidance_factor = 2.0f * radius * rd;
   if (projC0 < avoidance_factor) {
     return false;
   }

src/kernel/kernel_path.h

@@ -70,8 +70,9 @@ ccl_device_forceinline bool kernel_path_scene_intersect(KernelGlobals *kg,
   }
 
   // const float rand_transparency = path_state_rng_1D_hash(kg, state, state->rng_hash);
-  const float rand_transparency = path_state_rng_1D(kg, state, PRNG_UNUSED_0);
-  bool hit = scene_intersect(kg, ray, visibility, isect, rand_transparency);
+  const float rng_transparent = path_state_rng_1D(kg, state, PRNG_UNUSED_0);
+  // const uint rng_transparent = state->sample + state->rng_hash * kernel_data.integrator.aa_samples;
+  bool hit = scene_intersect(kg, ray, visibility, isect, (uint&)rng_transparent);
 
 #ifdef __KERNEL_DEBUG__
   if (state->flag & PATH_RAY_CAMERA) {

src/kernel/kernel_shadow.h

@@ -95,7 +95,7 @@ ccl_device bool shadow_blocked_opaque(KernelGlobals *kg,
                                       Intersection *isect,
                                       float3 *shadow)
 {
-  const bool blocked = scene_intersect(kg, ray, visibility & PATH_RAY_SHADOW_OPAQUE, isect);
+  const bool blocked = scene_intersect(kg, ray, visibility & PATH_RAY_SHADOW_OPAQUE, isect, 0);
 #ifdef __VOLUME__
   if (!blocked && state->volume_stack[0].shader != SHADER_NONE) {
     /* Apply attenuation from current volume shader. */

src/kernel/svm/svm_ao.h

@@ -72,7 +72,7 @@ ccl_device_noinline float svm_ao(KernelGlobals *kg,
     }
     else {
       Intersection isect;
-      if (!scene_intersect(kg, &ray, PATH_RAY_SHADOW_OPAQUE, &isect)) {
+      if (!scene_intersect(kg, &ray, PATH_RAY_SHADOW_OPAQUE, &isect, 0)) {
         unoccluded++;
       }
     }