super simple: medium tracking, HG volumetric scattering and test render under render-mx-medium-vdf

Author: ThyOwen

src/cmake/testing.cmake

@@ -371,7 +371,8 @@ macro (osl_add_all_tests)
                 render-mx-generalized-schlick render-mx-generalized-schlick-glass
                 render-mx-layer
                 render-mx-sheen
-                render-microfacet render-oren-nayar
+                render-mx-medium-vdf
+		render-microfacet render-oren-nayar
                 render-spi-thinlayer
                 render-uv render-veachmis render-ward
                 render-raytypes

src/testrender/CMakeLists.txt

@@ -5,6 +5,7 @@
 # The 'testrender' executable
 set (testrender_srcs
      shading.cpp
+     volume.cpp
      simpleraytracer.cpp
      scene.cpp
      bvh.cpp

src/testrender/shading.cpp

@@ -167,6 +167,8 @@ struct MxDielectric : public bsdl::mtx::DielectricLobe<BSDLLobe> {
     }
 };
 
+
+
 #ifndef __CUDACC__
 // Helper to register BSDL closures
 struct BSDLtoOSL {
@@ -1649,36 +1651,40 @@ process_medium_closure(const ShaderGlobalsType& sg, float path_roughness,
             const ClosureComponent* comp = closure->as_comp();
             Color3 cw                    = weight * comp->w;
             const auto& params           = *comp->as<MxAnisotropicVdfParams>();
-            result.sigma_t               = cw * params.extinction;
-            result.sigma_s               = params.albedo * result.sigma_t;
-            result.medium_g              = params.anisotropy;
+            result.medium_data.sigma_t               = cw * params.extinction;
+            result.medium_data.sigma_s               = params.albedo * result.medium_data.sigma_t;
+            result.medium_data.medium_g              = params.anisotropy;
             closure                      = nullptr;
             break;
         }
         case MX_MEDIUM_VDF_ID: {
             const ClosureComponent* comp = closure->as_comp();
             Color3 cw                    = weight * comp->w;
             const auto& params           = *comp->as<MxMediumVdfParams>();
-            result.sigma_t = { -OIIO::fast_log(params.transmission_color.x),
-                               -OIIO::fast_log(params.transmission_color.y),
-                               -OIIO::fast_log(params.transmission_color.z) };
-            // NOTE: closure weight scales the extinction parameter
-            result.sigma_t *= cw / params.transmission_depth;
-            result.sigma_s  = params.albedo * result.sigma_t;
-            result.medium_g = params.anisotropy;
-            // TODO: properly track a medium stack here ...
-            result.refraction_ior = sg.backfacing ? 1.0f / params.ior
-                                                  : params.ior;
-            result.priority       = params.priority;
-            closure               = nullptr;
+            
+            result.medium_data.sigma_t = Color3(
+                -OIIO::fast_log(params.transmission_color.x),
+                -OIIO::fast_log(params.transmission_color.y),
+                -OIIO::fast_log(params.transmission_color.z)
+            );
+            
+            result.medium_data.sigma_t *= cw / params.transmission_depth;
+            result.medium_data.sigma_s  = params.albedo * result.medium_data.sigma_t;
+            result.medium_data.medium_g = params.anisotropy;
+            
+            // Track IOR and priority here
+            result.medium_data.refraction_ior = sg.backfacing ? 1.0f / params.ior
+                                                              : params.ior;
+            result.medium_data.priority = params.priority;
+            closure = nullptr;
             break;
         }
         case MxDielectric::closureid(): {
             const ClosureComponent* comp     = closure->as_comp();
             const MxDielectric::Data& params = *comp->as<MxDielectric::Data>();
             if (!is_black(weight * comp->w * params.refr_tint)) {
                 // TODO: properly track a medium stack here ...
-                result.refraction_ior = sg.backfacing ? 1.0f / params.IOR
+                result.medium_data.refraction_ior = sg.backfacing ? 1.0f / params.IOR
                                                       : params.IOR;
             }
             closure = nullptr;
@@ -1694,7 +1700,7 @@ process_medium_closure(const ShaderGlobalsType& sg, float path_roughness,
                                       0.0f, 0.99f);
                 float sqrt_F0 = sqrtf(avg_F0);
                 float ior     = (1 + sqrt_F0) / (1 - sqrt_F0);
-                result.refraction_ior = sg.backfacing ? 1.0f / ior : ior;
+                result.medium_data.refraction_ior = sg.backfacing ? 1.0f / ior : ior;
             }
             closure = nullptr;
             break;
@@ -1868,7 +1874,7 @@ process_bsdf_closure(const ShaderGlobalsType& sg, float path_roughness,
                     else
                         ok = result.bsdf.add_bsdf<MxMicrofacet<
                             MxGeneralizedSchlickParams, GGXDist, true>>(
-                            cw, params, result.refraction_ior);
+                            cw, params, result.medium_data.refraction_ior);
                     break;
                 };
                 case MX_TRANSLUCENT_ID: {

src/testrender/shading.h

@@ -16,6 +16,7 @@
 
 #include "optics.h"
 #include "sampling.h"
+#include "volume.h"
 
 
 OSL_NAMESPACE_BEGIN
@@ -454,15 +455,13 @@ struct CompositeBSDF {
     int num_bsdfs, num_bytes;
 };
 
+struct MediumProperties;
+
+
 struct ShadingResult {
     Color3 Le          = Color3(0.0f);
     CompositeBSDF bsdf = {};
-    // medium data
-    Color3 sigma_s       = Color3(0.0f);
-    Color3 sigma_t       = Color3(0.0f);
-    float medium_g       = 0.0f;  // volumetric anisotropy
-    float refraction_ior = 1.0f;
-    int priority         = 0;
+    MediumProperties medium_data = {};
 };
 
 void

src/testrender/simpleraytracer.cpp

@@ -17,6 +17,7 @@ namespace pugi = OIIO::pugi;
 #    include "raytracer.h"
 #    include "shading.h"
 #    include "simpleraytracer.h"
+#    include "volume.h"
 #endif
 
 #include <cmath>
@@ -968,11 +969,66 @@ SimpleRaytracer::subpixel_radiance(float x, float y, Sampler& sampler,
     int prev_id    = -1;
     float bsdf_pdf = inf;  // camera ray has only one possible direction
 
+    MediumStack medium_stack;
+
     for (int b = 0; b <= max_bounces; b++) {
         ShaderGlobalsType sg;
-
         // trace the ray against the scene
         Intersection hit = scene.intersect(r, inf, prev_id);
+        
+        const MediumProperties* current_volume = medium_stack.current();
+        bool in_medium = medium_stack.in_medium();
+
+        //determine whether ray is in a medium
+        float t_volume = inf;
+        if (in_medium && current_volume && !current_volume->is_vacuum()) {
+            Vec3 rand_vol = sampler.get();
+            t_volume = current_volume->sample_distance(rand_vol.x);
+        }
+
+        //is there volume scattering
+        bool volume_scatter = in_medium && (t_volume < hit.t);
+        float t_event = volume_scatter ? t_volume : hit.t;
+        
+        //apply volumetric transmittance up to the event
+        if (in_medium && current_volume && !current_volume->is_vacuum()) {
+            Color3 transmittance = current_volume->transmittance(t_event);
+            path_weight *= transmittance;
+            
+            //early exit if transmittance kills the path
+            if (!(path_weight.x > 0) && !(path_weight.y > 0) && !(path_weight.z > 0)) {
+                break;
+            }
+        }
+        
+        // do volume scattering
+        if (volume_scatter) {
+            r.origin = r.origin + r.direction * t_volume;
+            
+            Vec3 rand_phase = sampler.get();
+            HenyeyGreenstein phase_func(current_volume->medium_g);
+            //IsotropicPhase phase_func;
+            PhaseFunction::Sample phase_sample = phase_func.sample(-r.direction, rand_phase.x, rand_phase.y);
+            
+            if (phase_sample.pdf <= 0.0f) {
+                break;
+            }
+            
+            //single scattering albedo = sigma_s / sigma_t
+            Color3 albedo = Color3(
+                current_volume->sigma_s.x / current_volume->sigma_t.x,
+                current_volume->sigma_s.y / current_volume->sigma_t.y,
+                current_volume->sigma_s.z / current_volume->sigma_t.z
+            );
+            
+            path_weight *= albedo * phase_sample.weight;
+            
+            r.direction = phase_sample.wi;
+            bsdf_pdf = phase_sample.pdf;
+
+            continue;
+        }
+        
         if (hit.t == inf) {
             // we hit nothing? check background shader
             if (backgroundShaderID >= 0) {
@@ -1018,8 +1074,9 @@ SimpleRaytracer::subpixel_radiance(float x, float y, Sampler& sampler,
         int shaderID = scene.shaderid(hit.id);
 
 #ifndef __CUDACC__
-        if (shaderID < 0 || !m_shaders[shaderID].surf)
+        if (shaderID < 0 || !m_shaders[shaderID].surf) {
             break;  // no shader attached? done
+        }
 
         // execute shader and process the resulting list of closures
         shadingsys->execute(*ctx, *m_shaders[shaderID].surf, sg);
@@ -1032,7 +1089,7 @@ SimpleRaytracer::subpixel_radiance(float x, float y, Sampler& sampler,
         bool last_bounce = b == max_bounces;
         process_closure(sg, r.roughness, result, (const ClosureColor*)sg.Ci,
                         last_bounce);
-
+        
 #ifndef __CUDACC__
         const size_t lightprims_size = m_lightprims.size();
 #endif
@@ -1076,16 +1133,17 @@ SimpleRaytracer::subpixel_radiance(float x, float y, Sampler& sampler,
             float bg_pdf   = 0;
             Vec3 bg        = background.sample(xi, yi, bg_dir, bg_pdf);
             BSDF::Sample b = result.bsdf.eval(-sg.I, bg_dir.val());
-            Color3 contrib = path_weight * b.weight * bg
-                             * MIS::power_heuristic<MIS::WEIGHT_WEIGHT>(bg_pdf,
+            Color3 contrib = path_weight * b.weight * 
+                             bg * MIS::power_heuristic<MIS::WEIGHT_WEIGHT>(bg_pdf,
                                                                         b.pdf);
             if ((contrib.x + contrib.y + contrib.z) > 0) {
                 ShaderGlobalsType shadow_sg;
                 Ray shadow_ray          = Ray(sg.P, bg_dir.val(), radius, 0, 0,
                                               Ray::SHADOW);
                 Intersection shadow_hit = scene.intersect(shadow_ray, inf,
-                                                          hit.id);
-                if (shadow_hit.t == inf)  // ray reached the background?
+                                                          hit.id);                
+                    
+                if (shadow_hit.t == inf) // ray reached the background?
                     path_radiance += contrib;
             }
         }
@@ -1114,27 +1172,21 @@ SimpleRaytracer::subpixel_radiance(float x, float y, Sampler& sampler,
                     Ray shadow_ray = Ray(sg.P, sample.dir, radius, 0, 0,
                                          Ray::SHADOW);
                     // trace a shadow ray and see if we actually hit the target
-                    // in this tiny renderer, tracing a ray is probably cheaper than evaluating the light shader
                     Intersection shadow_hit
                         = scene.intersect(shadow_ray, sample.dist, hit.id, lid);
 
 #ifndef __CUDACC__
                     const bool did_hit = shadow_hit.t == sample.dist;
 #else
-                    // The hit distance on the device is not as precise as on
-                    // the CPU, so we need to allow a little wiggle room. An
-                    // epsilon of 1e-3f empirically gives results that closely
-                    // match the CPU for the test scenes, so that's what we're
-                    // using.
                     const bool did_hit = fabsf(shadow_hit.t - sample.dist)
                                          < 1e-3f;
-#endif
+#endif  
+                    
                     if (did_hit) {
-                        // setup a shader global for the point on the light
+                        
                         globals_from_hit(light_sg, shadow_ray, sample.dist, lid,
                                          sample.u, sample.v);
 #ifndef __CUDACC__
-                        // execute the light shader (for emissive closures only)
                         shadingsys->execute(*ctx, *m_shaders[shaderID].surf,
                                             light_sg);
 #else
@@ -1143,7 +1195,7 @@ SimpleRaytracer::subpixel_radiance(float x, float y, Sampler& sampler,
                         ShadingResult light_result;
                         process_closure(light_sg, r.roughness, light_result,
                                         (const ClosureColor*)light_sg.Ci, true);
-                        // accumulate contribution
+                        
                         path_radiance += contrib * light_result.Le;
                     }
                 }
@@ -1160,12 +1212,22 @@ SimpleRaytracer::subpixel_radiance(float x, float y, Sampler& sampler,
         // Just simply use roughness as spread slope
         r.spread    = std::max(r.spread, p.roughness);
         r.roughness = p.roughness;
-        if (!(path_weight.x > 0) && !(path_weight.y > 0)
-            && !(path_weight.z > 0))
+        
+        if (!result.medium_data.is_vacuum()) {
+            bool entering = !sg.backfacing;
+        
+            if (entering) {
+                medium_stack.push(result.medium_data);
+            } else {
+                medium_stack.pop();
+            }
+        }
+
+        if (!(path_weight.x > 0) && !(path_weight.y > 0) && !(path_weight.z > 0) && b > 10)
             break;  // filter out all 0's or NaNs
         prev_id  = hit.id;
         r.origin = sg.P;
-    }
+    }    
     return path_radiance;
 }
 

src/testrender/volume.cpp

@@ -0,0 +1,8 @@
+#include "volume.h"
+#include "sampling.h"
+
+
+OSL_NAMESPACE_BEGIN
+
+
+OSL_NAMESPACE_END