MediumStack stores Medium sub classes similar to CompositeBSDF. PhaseFunction has been deleted.

Author: ThyOwen

src/testrender/CMakeLists.txt

@@ -35,6 +35,8 @@ if (OSL_USE_OPTIX)
         sampling.h
         shading.h
         shading.cpp
+        volume.h
+        volume.cpp
         simpleraytracer.cpp
         )
 

src/testrender/shading.cpp

@@ -167,8 +167,6 @@ struct MxDielectric : public bsdl::mtx::DielectricLobe<BSDLLobe> {
     }
 };
 
-
-
 #ifndef __CUDACC__
 // Helper to register BSDL closures
 struct BSDLtoOSL {
@@ -1675,7 +1673,7 @@ process_medium_closure(const ShaderGlobalsType& sg, float path_roughness,
             // Track IOR and priority here
             result.medium_data.refraction_ior = sg.backfacing ? 1.0f / params.ior
                                                               : params.ior;
-            result.medium_data.priority = params.priority;
+            //result.medium_data.priority = params.priority;
             closure = nullptr;
             break;
         }

src/testrender/shading.h

@@ -16,8 +16,6 @@
 
 #include "optics.h"
 #include "sampling.h"
-#include "volume.h"
-
 
 OSL_NAMESPACE_BEGIN
 
@@ -262,6 +260,7 @@ struct EnergyCompensatedOrenNayar;
 struct ZeltnerBurleySheen;
 struct CharlieSheen;
 struct SpiThinLayer;
+struct HenyeyGreenstein;
 
 // StaticVirtual generates a switch/case dispatch method for us given
 // a list of possible subtypes. We just need to forward declare them.
@@ -271,7 +270,8 @@ using AbstractBSDF = bsdl::StaticVirtual<
     MicrofacetBeckmannBoth, MicrofacetGGXRefl, MicrofacetGGXRefr,
     MicrofacetGGXBoth, MxConductor, MxDielectric, MxBurleyDiffuse,
     EnergyCompensatedOrenNayar, ZeltnerBurleySheen, CharlieSheen,
-    MxGeneralizedSchlickOpaque, MxGeneralizedSchlick, SpiThinLayer>;
+    MxGeneralizedSchlickOpaque, MxGeneralizedSchlick, SpiThinLayer,
+    HenyeyGreenstein>;
 
 // Then we just need to inherit from AbstractBSDF
 
@@ -455,13 +455,84 @@ struct CompositeBSDF {
     int num_bsdfs, num_bytes;
 };
 
-struct MediumProperties;
+struct VolumeParams {
+    Color3 sigma_t       = Color3(0.0f); // extinction coefficient
+    Color3 sigma_s       = Color3(0.0f); //scattering 
+    float medium_g       = 0.0f;  // volumetric anisotropy
+    float refraction_ior = 1.0f;
+    //int priority         = 0;
 
+    OSL_HOSTDEVICE bool is_vacuum() const
+    {
+        return sigma_t.x <= 0.0f && sigma_t.y <= 0.0f && sigma_t.z <= 0.0f;
+    }
+
+    OSL_HOSTDEVICE bool operator==(const VolumeParams &rhs) const {
+        return refraction_ior == rhs.refraction_ior &&
+            medium_g == rhs.medium_g &&
+            sigma_t.x == rhs.sigma_t.x &&
+            sigma_t.y == rhs.sigma_t.y &&
+            sigma_t.z == rhs.sigma_t.z &&
+            sigma_s.x == rhs.sigma_s.x &&
+            sigma_s.y == rhs.sigma_s.y &&
+            sigma_s.z == rhs.sigma_s.z;
+    }
+
+    OSL_HOSTDEVICE float max_sigma_t() const
+    {
+        return std::max(std::max(sigma_t.x, sigma_t.y), sigma_t.z);
+    }
+};
 
 struct ShadingResult {
     Color3 Le          = Color3(0.0f);
     CompositeBSDF bsdf = {};
-    MediumProperties medium_data = {};
+    VolumeParams medium_data = {};
+};
+
+struct HenyeyGreenstein final : public BSDF {
+    const float g;
+    OSL_HOSTDEVICE HenyeyGreenstein(float g) 
+        : BSDF(this),
+        g(g) 
+    {
+    }
+
+    static OSL_HOSTDEVICE float PhaseHG(float cos_theta, float g) {
+        const float denom = 1 + g * g + 2 * g * cos_theta;
+        return (1 - g * g) / (4 * M_PI * denom * sqrtf(denom));
+    }
+
+    OSL_HOSTDEVICE Sample eval(const Vec3& wo, const Vec3& wi) const 
+    {
+        const float pdf = PhaseHG(dot(wo, wi), g);
+        return { wi, Color3(pdf), pdf, 0.0f };
+    }
+
+    OSL_HOSTDEVICE Sample sample(const Vec3& wo, float rx, float ry, float rz) const 
+    {
+        TangentFrame frame = TangentFrame::from_normal(wo);
+
+        float cos_theta;
+        if (abs(g) < 1e-3f) {
+            cos_theta = 1.0f - 2.0f * rx;
+        } else {
+            float sqr_term = (1 - g * g) / (1 - g + 2 * g * rx);
+            cos_theta = (1 + g * g - sqr_term * sqr_term) / (2 * g);
+            cos_theta = OIIO::clamp(cos_theta, -1.0f, 1.0f);
+        }
+
+        float sin_theta =  sqrtf(OIIO::clamp(1.0f - cos_theta * cos_theta, 0.0f, 1.0f));
+        float phi = 2 * M_PI * ry;
+        Vec3 local_wi = Vec3(sin_theta * cosf(phi), sin_theta * sinf(phi), cos_theta);
+
+        Vec3 wi = frame.toworld(local_wi);
+        float pdf_val = PhaseHG(cos_theta, g);
+
+        Color3 weight = Color3(1.0f);
+        return { wi, weight, pdf_val, 0.0f };
+    }
+
 };
 
 void

src/testrender/simpleraytracer.cpp

@@ -975,58 +975,45 @@ SimpleRaytracer::subpixel_radiance(float x, float y, Sampler& sampler,
         ShaderGlobalsType sg;
         // trace the ray against the scene
         Intersection hit = scene.intersect(r, inf, prev_id);
-        
-        const MediumProperties* current_volume = medium_stack.current();
+
+        const HomogeneousVolume* volume = static_cast<const HomogeneousVolume*>(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);
-        }
+        if (in_medium && volume && !volume->is_vacuum()) {
+            Medium::Sample medium_sample = volume->sample(r, sampler, hit);
 
-        //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;
+            path_weight *= medium_sample.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.origin = r.origin + r.direction * medium_sample.t;
+
 
-            r.direction = phase_sample.wi;
-            bsdf_pdf = phase_sample.pdf;
+            if (medium_sample.scatter) {
+
+                Vec3 rand_phase = sampler.get();
+                HenyeyGreenstein phase_func(volume->medium_g);
+                BSDF::Sample phase_sample = phase_func.sample(-r.direction, rand_phase.x, rand_phase.y, rand_phase.z);
+
+                if (phase_sample.pdf <= 0.0f) {
+                    break;
+                }
 
-            continue;
+                Color3 albedo = Color3(
+                    volume->sigma_s.x / volume->sigma_t.x,
+                    volume->sigma_s.y / volume->sigma_t.y,
+                    volume->sigma_s.z / 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) {
@@ -1217,9 +1204,9 @@ SimpleRaytracer::subpixel_radiance(float x, float y, Sampler& sampler,
             bool entering = !sg.backfacing;
 
             if (entering) {
-                medium_stack.push(result.medium_data);
+                medium_stack.push_medium<HomogeneousVolume>(result.medium_data);
             } else {
-                medium_stack.pop();
+                medium_stack.pop_medium();
             }
         }
 

src/testrender/volume.cpp

@@ -1,8 +1,13 @@
+// Copyright Contributors to the Open Shading Language project.
+// SPDX-License-Identifier: BSD-3-Clause
+// https://github.com/AcademySoftwareFoundation/OpenShadingLanguage
+
 #include "volume.h"
-#include "sampling.h"
 
 
 OSL_NAMESPACE_BEGIN
 
+//OSL_HOSTDEVICE BSDF::Sample HomogeneousVolume::sample(Ray &r, Sampler &sampler, Intersection& hit, Color3& path_weight) 
+
 
-OSL_NAMESPACE_END
+OSL_NAMESPACE_END