Merge branch 'get_rid_of_raystack' into raytracing

devshgraphicsprogramming · devshgraphicsprogramming · commit 9cec232e75fe · 2021-03-09T10:30:17.000+01:00
diff --git a/examples_tests/42.FragmentShaderPathTracer/common.glsl b/examples_tests/42.FragmentShaderPathTracer/common.glsl
@@ -346,9 +346,6 @@ struct Ray_t
     MutableRay_t _mutable;
     Payload_t _payload;
 };
-#define MAX_STACK_SIZE 1
-int stackPtr = 0;
-Ray_t rayStack[MAX_STACK_SIZE];
 
 
 bool anyHitProgram(in ImmutableRay_t _immutable)
@@ -381,15 +378,15 @@ vec2 SampleSphericalMap(vec3 v)
     return uv;
 }
 
-void missProgram() 
+void missProgram(in ImmutableRay_t _immutable, inout Payload_t _payload)
 {
-    vec3 finalContribution = rayStack[stackPtr]._payload.throughput; 
+    vec3 finalContribution = _payload.throughput; 
     //#define USE_ENVMAP
     // true miss
-    if (rayStack[stackPtr]._immutable.maxT>=FLT_MAX)
+    if (_immutable.maxT>=FLT_MAX)
     {
         #ifdef USE_ENVMAP
-	        vec2 uv = SampleSphericalMap(rayStack[stackPtr]._immutable.direction);
+	        vec2 uv = SampleSphericalMap(_immutable.direction);
             finalContribution *= textureLod(envMap, uv, 0.0).rgb;
         #else
         const vec3 kConstantEnvLightRadiance = vec3(0.15, 0.21, 0.3);
@@ -398,9 +395,9 @@ void missProgram()
     }
     else
     {
-        finalContribution *= rayStack[stackPtr]._payload.otherTechniqueHeuristic;
+        finalContribution *= _payload.otherTechniqueHeuristic;
     }
-    rayStack[stackPtr]._payload.accumulation += finalContribution;
+    _payload.accumulation += finalContribution;
 }
 
 #include <nbl/builtin/glsl/bxdf/brdf/diffuse/oren_nayar.glsl>
@@ -503,8 +500,8 @@ mat2x3 rand3d(in uint protoDimension, in uint _sample, inout nbl_glsl_xoroshiro6
     return retval;
 }
 
-bool traceRay(in ImmutableRay_t _immutable);
-void closestHitProgram(in ImmutableRay_t _immutable, inout nbl_glsl_xoroshiro64star_state_t scramble_state);
+bool traceRay(in ImmutableRay_t _immutable, inout MutableRay_t _mutable);
+bool closestHitProgram(inout Ray_t ray, inout nbl_glsl_xoroshiro64star_state_t scramble_state);
 
 void main()
 {
@@ -534,11 +531,11 @@ void main()
     {
         nbl_glsl_xoroshiro64star_state_t scramble_state = scramble_start_state;
 
-        stackPtr = 0;
+        Ray_t ray;
         // raygen
         {
-            rayStack[stackPtr]._immutable.origin = camPos;
-            rayStack[stackPtr]._immutable.maxT = FLT_MAX;
+            ray._immutable.origin = camPos;
+            ray._immutable.maxT = FLT_MAX;
 
             vec4 tmp = NDC;
             // apply stochastic reconstruction filter
@@ -550,41 +547,42 @@ void main()
             tmp.xy += pixOffsetParam*nbl_glsl_BoxMullerTransform(remappedRand,1.5);
             // for depth of field we could do another stochastic point-pick
             tmp = invMVP*tmp;
-            rayStack[stackPtr]._immutable.direction = normalize(tmp.xyz/tmp.w-camPos);
+            ray._immutable.direction = normalize(tmp.xyz/tmp.w-camPos);
             
-            rayStack[stackPtr]._immutable.typeDepthSampleIx = bitfieldInsert(i,1,DEPTH_BITS_OFFSET,DEPTH_BITS_COUNT);
+            ray._immutable.typeDepthSampleIx = bitfieldInsert(i,1,DEPTH_BITS_OFFSET,DEPTH_BITS_COUNT);
 
             #if defined(TRIANGLE_METHOD)||defined(RECTANGLE_METHOD)
-                rayStack[stackPtr]._immutable.normalAtOrigin = vec3(0.0,0.0,0.0);
-                rayStack[stackPtr]._immutable.wasBSDFAtOrigin = false;
+                ray._immutable.normalAtOrigin = vec3(0.0,0.0,0.0);
+                ray._immutable.wasBSDFAtOrigin = false;
             #endif
 
-            rayStack[stackPtr]._payload.accumulation = vec3(0.0);
-            rayStack[stackPtr]._payload.otherTechniqueHeuristic = 0.0; // needed for direct eye-light paths
-            rayStack[stackPtr]._payload.throughput = vec3(1.0);
+            ray._payload.accumulation = vec3(0.0);
+            ray._payload.otherTechniqueHeuristic = 0.0; // needed for direct eye-light paths
+            ray._payload.throughput = vec3(1.0);
             #ifdef KILL_DIFFUSE_SPECULAR_PATHS
-            rayStack[stackPtr]._payload.hasDiffuse = false;
+            ray._payload.hasDiffuse = false;
             #endif
         }
 
         // trace
-        while (stackPtr!=-1)
+        for (int j=1; j<=MAX_DEPTH; j+=2)
         {
-            ImmutableRay_t _immutable = rayStack[stackPtr]._immutable;
-            bool anyHitType = traceRay(_immutable);
+            const ImmutableRay_t _immutable = ray._immutable;
+            bool anyHitType = traceRay(_immutable,ray._mutable);
                 
-            if (rayStack[stackPtr]._mutable.intersectionT>=_immutable.maxT)
+            if (ray._mutable.intersectionT>=_immutable.maxT)
             {
-                missProgram();
+                missProgram(_immutable,ray._payload);
+                break;
             }
             else if (!anyHitType)
             {
-                closestHitProgram(_immutable,scramble_state);
+                if (closestHitProgram(ray,scramble_state))
+                    break;
             }
-            stackPtr--;
         }
 
-        vec3 accumulation = rayStack[0]._payload.accumulation;
+        vec3 accumulation = ray._payload.accumulation;
 
         float rcpSampleSize = 1.0/float(i+1);
         color += (accumulation-color)*rcpSampleSize;
diff --git a/examples_tests/42.FragmentShaderPathTracer/litBySphere.frag b/examples_tests/42.FragmentShaderPathTracer/litBySphere.frag
@@ -10,7 +10,7 @@
 
 
 
-bool traceRay(in ImmutableRay_t _immutable)
+bool traceRay(in ImmutableRay_t _immutable, inout MutableRay_t _mutable)
 {
     const bool anyHit = bitfieldExtract(_immutable.typeDepthSampleIx,31,1)!=0;
 
@@ -28,8 +28,8 @@ bool traceRay(in ImmutableRay_t _immutable)
         //if (anyHit && closerIntersection && anyHitProgram(_immutable))
            //break;
     }
-    rayStack[stackPtr]._mutable.objectID = objectID;
-    rayStack[stackPtr]._mutable.intersectionT = intersectionT;
+    _mutable.objectID = objectID;
+    _mutable.intersectionT = intersectionT;
     // hit
     return anyHit;
 }
@@ -82,18 +82,18 @@ nbl_glsl_LightSample nbl_glsl_light_generate_and_remainder_and_pdf(out vec3 rema
 }
 
 
-void closestHitProgram(in ImmutableRay_t _immutable, inout nbl_glsl_xoroshiro64star_state_t scramble_state)
+bool closestHitProgram(inout Ray_t ray, inout nbl_glsl_xoroshiro64star_state_t scramble_state)
 {
-    const MutableRay_t mutable = rayStack[stackPtr]._mutable;
+    const MutableRay_t _mutable = ray._mutable;
 
-    Sphere sphere = spheres[mutable.objectID];
-    vec3 intersection = _immutable.origin+_immutable.direction*mutable.intersectionT;
+    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 = -_immutable.direction;
+        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);
@@ -105,22 +105,22 @@ void closestHitProgram(in ImmutableRay_t _immutable, inout nbl_glsl_xoroshiro64s
     const uint bsdfLightIDs = sphere.bsdfLightIDs;
     const uint lightID = bitfieldExtract(bsdfLightIDs,16,16);
 
-    vec3 throughput = rayStack[stackPtr]._payload.throughput;
+    vec3 throughput = ray._payload.throughput;
     
     // finish MIS
     if (lightID!=INVALID_ID_16BIT) // has emissive
     {
         float lightPdf;
-        vec3 lightVal = nbl_glsl_light_deferred_eval_and_prob(lightPdf,sphere,_immutable.origin,interaction,lights[lightID]);
-        rayStack[stackPtr]._payload.accumulation += throughput*lightVal/(1.0+lightPdf*lightPdf*rayStack[stackPtr]._payload.otherTechniqueHeuristic);
+        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);
     }
     
-    const int sampleIx = bitfieldExtract(_immutable.typeDepthSampleIx,0,DEPTH_BITS_OFFSET);
-    const int depth = bitfieldExtract(_immutable.typeDepthSampleIx,DEPTH_BITS_OFFSET,DEPTH_BITS_COUNT);
+    const int sampleIx = bitfieldExtract(ray._immutable.typeDepthSampleIx,0,DEPTH_BITS_OFFSET);
+    const int depth = bitfieldExtract(ray._immutable.typeDepthSampleIx,DEPTH_BITS_OFFSET,DEPTH_BITS_COUNT);
 
     // check if we even have a BSDF at all
     uint bsdfID = bitfieldExtract(bsdfLightIDs,0,16);
-    if (depth<MAX_DEPTH && bsdfID!=INVALID_ID_16BIT)
+    if (bsdfID!=INVALID_ID_16BIT)
     {
         // common preload
         BSDFNode bsdf = bsdfs[bsdfID];
@@ -129,11 +129,11 @@ void closestHitProgram(in ImmutableRay_t _immutable, inout nbl_glsl_xoroshiro64s
         #ifdef KILL_DIFFUSE_SPECULAR_PATHS
         if (BSDFNode_isNotDiffuse(bsdf))
         {
-            if (rayStack[stackPtr]._payload.hasDiffuse)
-                return;
+            if (ray._payload.hasDiffuse)
+                return true;
         }
         else
-            rayStack[stackPtr]._payload.hasDiffuse = true;
+            ray._payload.hasDiffuse = true;
         #endif
 
 
@@ -189,21 +189,22 @@ void closestHitProgram(in ImmutableRay_t _immutable, inout nbl_glsl_xoroshiro64s
         const float lumaThroughputThreshold = bsdfPdfThreshold;
         if (bsdfPdf>bsdfPdfThreshold && (!doNEE || bsdfPdf<FLT_MAX) && getLuma(throughput)>lumaThroughputThreshold)
         {
-            rayStack[stackPtr]._payload.throughput = throughput*rcpChoiceProb;
+            ray._payload.throughput = throughput*rcpChoiceProb;
 
             float heuristicFactor = rcpChoiceProb-1.0; // weightNonGenerator/weightGenerator
             heuristicFactor /= doNEE ? lightPdf:bsdfPdf; // weightNonGenerator/(weightGenerator*probGenerated)
             heuristicFactor *= heuristicFactor; // (weightNonGenerator/(weightGenerator*probGenerated))^2
             if (doNEE)
                 heuristicFactor = 1.0/(1.0/bsdfPdf+heuristicFactor*bsdfPdf); // numerically stable, don't touch
-            rayStack[stackPtr]._payload.otherTechniqueHeuristic = heuristicFactor;
+            ray._payload.otherTechniqueHeuristic = heuristicFactor;
                     
             // trace new ray
-            rayStack[stackPtr]._immutable.origin = intersection+_sample.L*(doNEE ? maxT:1.0/*kSceneSize*/)*getStartTolerance(depth);
-            rayStack[stackPtr]._immutable.maxT = maxT;
-            rayStack[stackPtr]._immutable.direction = _sample.L;
-            rayStack[stackPtr]._immutable.typeDepthSampleIx = bitfieldInsert(sampleIx,depth+2,DEPTH_BITS_OFFSET,DEPTH_BITS_COUNT)|(doNEE ? ANY_HIT_FLAG:0);
-            stackPtr++;
+            ray._immutable.origin = intersection+_sample.L*(doNEE ? maxT:1.0/*kSceneSize*/)*getStartTolerance(depth);
+            ray._immutable.maxT = maxT;
+            ray._immutable.direction = _sample.L;
+            ray._immutable.typeDepthSampleIx = bitfieldInsert(sampleIx,depth+2,DEPTH_BITS_OFFSET,DEPTH_BITS_COUNT)|(doNEE ? ANY_HIT_FLAG:0);
+            return false;
         }
     }
+    return true;
 }
