prepare for MIS (reimplement NEE)

Author: devshgraphicsprogramming

examples_tests/42.FragmentShaderPathTracer/common.glsl

@@ -484,7 +484,7 @@ mat2x3 rand3d(in uint protoDimension, in uint _sample, inout nbl_glsl_xoroshiro6
     return retval;
 }
 
-int traceRay(inout float intersectionT, in ImmutableRay_t _immutable);
+int traceRay(inout float intersectionT, in vec3 origin, in vec3 direction);
 bool closestHitProgram(in uint depth, in uint _sample, inout Ray_t ray, inout nbl_glsl_xoroshiro64star_state_t scramble_state);
 
 void main()
@@ -552,7 +552,7 @@ void main()
             for (int d=1; d<=MAX_DEPTH && hit && rayAlive; d+=2)
             {
                 ray._mutable.intersectionT = FLT_MAX;
-                ray._mutable.objectID = traceRay(ray._mutable.intersectionT,ray._immutable);
+                ray._mutable.objectID = traceRay(ray._mutable.intersectionT,ray._immutable.origin,ray._immutable.direction);
                 hit = ray._mutable.objectID!=-1;
                 if (hit)
                     rayAlive = closestHitProgram(3u, i, ray, scramble_state);

examples_tests/42.FragmentShaderPathTracer/litBySphere.frag

@@ -10,12 +10,12 @@
 
 
 
-int traceRay(inout float intersectionT, in ImmutableRay_t _immutable)
+int traceRay(inout float intersectionT, in vec3 origin, in vec3 direction)
 {
 	int objectID = -1;
 	for (int i=0; i<SPHERE_COUNT; i++)
     {
-        float t = Sphere_intersect(spheres[i],_immutable.origin,_immutable.direction);
+        float t = Sphere_intersect(spheres[i],origin,direction);
         bool closerIntersection = t>0.0 && t<intersectionT;
 
 		objectID = closerIntersection ? i:objectID;
@@ -36,6 +36,7 @@ vec3 nbl_glsl_light_deferred_eval_and_prob(out float pdf, in Sphere sphere, in v
     pdf = scene_getLightChoicePdf(light)/Sphere_getSolidAngle(sphere,origin);
     return Light_getRadiance(light);
 }
+#endif
 
 nbl_glsl_LightSample nbl_glsl_light_generate_and_remainder_and_pdf(out vec3 remainder, out float pdf, out float newRayMaxT, in vec3 origin, in nbl_glsl_AnisotropicViewSurfaceInteraction interaction, in vec3 u, in uint depth)
 {
@@ -75,7 +76,6 @@ nbl_glsl_LightSample nbl_glsl_light_generate_and_remainder_and_pdf(out vec3 rema
 
     return nbl_glsl_createLightSample(L,interaction);
 }
-#endif
 
 bool closestHitProgram(in uint depth, in uint _sample, inout Ray_t ray, inout nbl_glsl_xoroshiro64star_state_t scramble_state)
 {
@@ -85,7 +85,7 @@ bool closestHitProgram(in uint depth, in uint _sample, inout Ray_t ray, inout nb
     const uint bsdfLightIDs = sphere.bsdfLightIDs;
 
     vec3 throughput = ray._payload.throughput;
-#if 1
+#if 0
     // add emissive
     const uint lightID = bitfieldExtract(bsdfLightIDs,16,16);
     if (lightID!=INVALID_ID_16BIT) // has emissive
@@ -109,9 +109,8 @@ bool closestHitProgram(in uint depth, in uint _sample, inout Ray_t ray, inout nb
         //rand
         mat2x3 epsilon = rand3d(depth,_sample,scramble_state);
 
-        // intersection stuffs
+        // interaction stuffs
         const vec3 intersection = ray._immutable.origin+ray._immutable.direction*_mutable.intersectionT;
-    
         nbl_glsl_AnisotropicViewSurfaceInteraction interaction;
         {
             nbl_glsl_IsotropicViewSurfaceInteraction isotropic;
@@ -125,28 +124,45 @@ bool closestHitProgram(in uint depth, in uint _sample, inout Ray_t ray, inout nb
             interaction = nbl_glsl_calcAnisotropicInteraction(isotropic);
         }
 
-
-    
-
-        nbl_glsl_AnisotropicMicrofacetCache _cache;
-
-        // do I need this?
+        // thresholds
+        const float bsdfPdfThreshold = 0.0001;
+        const float lumaContributionThreshold = getLuma(nbl_glsl_eotf_sRGB(vec3(1.0)/255.0)); // OETF smallest perceptible value
         const vec3 throughputCIE_Y = transpose(nbl_glsl_sRGBtoXYZ)[1]*throughput;
         const float monochromeEta = dot(throughputCIE_Y,BSDFNode_getEta(bsdf)[0])/(throughputCIE_Y.r+throughputCIE_Y.g+throughputCIE_Y.b);
-            
+           
+        // do NEE
+        float rcpNEEProb = 1.0;
+        if (true)
+        {
+            vec3 neeContrib; float lightPdf, t;
+            nbl_glsl_LightSample _sample = nbl_glsl_light_generate_and_remainder_and_pdf(neeContrib,lightPdf,t,intersection,interaction,epsilon[1],depth);
+            // We don't allow non watertight transmitters in this renderer
+            bool validPath = _sample.NdotL>0.0;
+            // but if we allowed non-watertight transmitters (single water surface), it would make sense just to apply this line by itself
+            nbl_glsl_AnisotropicMicrofacetCache _cache;
+            validPath = validPath && nbl_glsl_calcAnisotropicMicrofacetCache(_cache,interaction,_sample,monochromeEta);
+            if (validPath)
+            {
+                float bsdfPdf;
+                neeContrib *= nbl_glsl_bsdf_cos_remainder_and_pdf(bsdfPdf,_sample,interaction,bsdf,monochromeEta,_cache)*throughput;
+                if (bsdfPdf<FLT_MAX && getLuma(neeContrib)>lumaContributionThreshold && traceRay(t,intersection+_sample.L*t*getStartTolerance(depth),_sample.L)==-1)
+                    ray._payload.accumulation += neeContrib*bsdfPdf;
+            }
+        }
+        
         // sample BSDF
         float bsdfPdf; vec3 bsdfSampleL;
         {
+            nbl_glsl_AnisotropicMicrofacetCache _cache;
             nbl_glsl_LightSample _sample = nbl_glsl_bsdf_cos_generate(interaction,epsilon[0],bsdf,monochromeEta,_cache);
             // the value of the bsdf divided by the probability of the sample being generated
             throughput *= nbl_glsl_bsdf_cos_remainder_and_pdf(bsdfPdf,_sample,interaction,bsdf,monochromeEta,_cache);
             //
             bsdfSampleL = _sample.L;
         }
 
-        const float bsdfPdfThreshold = 0.0001;
-        // OETF smallest perceptible value
-        const float lumaThroughputThreshold = getLuma(nbl_glsl_eotf_sRGB(vec3(1.0)/255.0));
+        // additional threshold
+        const float lumaThroughputThreshold = lumaContributionThreshold;
         if (bsdfPdf>bsdfPdfThreshold && getLuma(throughput)>lumaThroughputThreshold)
         {
             ray._payload.throughput = throughput;
@@ -159,105 +175,27 @@ bool closestHitProgram(in uint depth, in uint _sample, inout Ray_t ray, inout nb
     }
     return false;
 }
-#if 0
-bool closestHitProgram(in uint depth, in uint _sample, inout Ray_t ray, inout nbl_glsl_xoroshiro64star_state_t scramble_state)
-{
-    const MutableRay_t _mutable = ray._mutable;
-
-    Sphere sphere = spheres[_mutable.objectID];
-    vec3 intersection = ray._immutable.origin+ray._immutable.direction*_mutable.intersectionT;
-    
-    nbl_glsl_AnisotropicViewSurfaceInteraction interaction;
-    {
-        nbl_glsl_IsotropicViewSurfaceInteraction isotropic;
-
-        isotropic.V.dir = -ray._immutable.direction;
-        //isotropic.V.dPosdScreen = screw that
-        isotropic.N = Sphere_getNormal(sphere,intersection);
-        isotropic.NdotV = dot(isotropic.V.dir,isotropic.N);
-        isotropic.NdotV_squared = isotropic.NdotV*isotropic.NdotV;
-
-        interaction = nbl_glsl_calcAnisotropicInteraction(isotropic);
-    }
-
-    const uint bsdfLightIDs = sphere.bsdfLightIDs;
-    const uint lightID = bitfieldExtract(bsdfLightIDs,16,16);
-
-    vec3 throughput = ray._payload.throughput;
-    
+#if 0    
     // finish MIS
     if (lightID!=INVALID_ID_16BIT) // has emissive
     {
         float lightPdf;
         vec3 lightVal = nbl_glsl_light_deferred_eval_and_prob(lightPdf,sphere,ray._immutable.origin,interaction,lights[lightID]);
-        ray._payload.accumulation += throughput*lightVal/(1.0+lightPdf*lightPdf*ray._payload.otherTechniqueHeuristic);
+        ray._payload.accumulation += ray._payload.throughput*lightVal/(1.0+lightPdf*lightPdf*ray._payload.otherTechniqueHeuristic);
     }
 
-    // check if we even have a BSDF at all
-    uint bsdfID = bitfieldExtract(bsdfLightIDs,0,16);
-    if (bsdfID!=INVALID_ID_16BIT)
-    {
-        // common preload
-        BSDFNode bsdf = bsdfs[bsdfID];
-        uint opType = BSDFNode_getType(bsdf);
 
-        #ifdef KILL_DIFFUSE_SPECULAR_PATHS
-        if (BSDFNode_isNotDiffuse(bsdf))
-        {
-            if (ray._payload.hasDiffuse)
-                return true;
-        }
-        else
-            ray._payload.hasDiffuse = true;
-        #endif
+
 
 
         const float bsdfGeneratorProbability = BSDFNode_getMISWeight(bsdf);
-        mat2x3 epsilon = rand3d(depth,_sample,scramble_state);
-    
-        float rcpChoiceProb;
         const bool doNEE = nbl_glsl_partitionRandVariable(bsdfGeneratorProbability,epsilon[0].z,rcpChoiceProb);
-    
 
         float maxT;
         // the probability of generating a sample w.r.t. the light generator only possible and used when it was generated with it!
         float lightPdf;
         nbl_glsl_LightSample _sample;
-        nbl_glsl_AnisotropicMicrofacetCache _cache;
-        if (doNEE)
-        {
-            vec3 lightRemainder;
-            _sample = nbl_glsl_light_generate_and_remainder_and_pdf(
-                lightRemainder,lightPdf,maxT,
-                intersection,interaction,epsilon[0],
-                depth
-            );
-            throughput *= lightRemainder;
-        }
-
-        bool validPath = true;
-        const vec3 throughputCIE_Y = transpose(nbl_glsl_sRGBtoXYZ)[1]*throughput;
-        const float monochromeEta = dot(throughputCIE_Y,BSDFNode_getEta(bsdf)[0])/(throughputCIE_Y.r+throughputCIE_Y.g+throughputCIE_Y.b);
-        if (doNEE)
-        {
-            // if we allowed non-watertight transmitters (single water surface), it would make sense just to apply this line.
-            validPath = nbl_glsl_calcAnisotropicMicrofacetCache(_cache,interaction,_sample,monochromeEta);
-            // but we don't allow non watertight transmitters in this renderer
-            validPath = validPath && _sample.NdotL>0.0;
-        }
-        else
-        {
-            maxT = FLT_MAX;
-            _sample = nbl_glsl_bsdf_cos_generate(interaction,epsilon[0],bsdf,monochromeEta,_cache);
-        }
 
-        // do a cool trick and always compute the bsdf parts this way! (no divergence)
-        float bsdfPdf;
-        // the value of the bsdf divided by the probability of the sample being generated
-        if (validPath)
-            throughput *= nbl_glsl_bsdf_cos_remainder_and_pdf(bsdfPdf,_sample,interaction,bsdf,monochromeEta,_cache);
-        else
-            throughput = vec3(0.0);
 
         // OETF smallest perceptible value
         const float bsdfPdfThreshold = getLuma(nbl_glsl_eotf_sRGB(vec3(1.0)/255.0));
@@ -280,7 +218,4 @@ bool closestHitProgram(in uint depth, in uint _sample, inout Ray_t ray, inout nb
             ray._immutable.anyHit = doNEE;
             return false;
         }
-    }
-    return true;
-}
 #endif