RWMC setup

Author: Przemog1

31_HLSLPathTracer/app_resources/hlsl/pathtracer.hlsl

@@ -265,32 +265,37 @@ struct Unidirectional
         // #endif
     }
 
+    measure_type getSingleSampleMeasure(uint32_t sampleID, uint32_t depth, NBL_CONST_REF_ARG(scene_type) scene)
+    {
+        vector3_type uvw = rand3d(0u, sampleID, randGen.rng());    // TODO: take from scramblebuf?
+        ray_type ray = rayGen.generate(uvw);
+
+        // bounces
+        bool hit = true;
+        bool rayAlive = true;
+        for (int d = 1; (d <= depth) && hit && rayAlive; d += 2)
+        {
+            ray.intersectionT = numeric_limits<scalar_type>::max;
+            ray.objectID = intersector_type::traceRay(ray, scene);
+
+            hit = ray.objectID.id != -1;
+            if (hit)
+                rayAlive = closestHitProgram(1, sampleID, ray, scene);
+        }
+        if (!hit)
+            missProgram(ray);
+
+        return ray.payload.accumulation;
+    }
+
     // Li
     measure_type getMeasure(uint32_t numSamples, uint32_t depth, NBL_CONST_REF_ARG(scene_type) scene)
     {
         measure_type Li = (measure_type)0.0;
         scalar_type meanLumaSq = 0.0;
         for (uint32_t i = 0; i < numSamples; i++)
         {
-            vector3_type uvw = rand3d(0u, i, randGen.rng());    // TODO: take from scramblebuf?
-            ray_type ray = rayGen.generate(uvw);
-
-            // bounces
-            bool hit = true;
-            bool rayAlive = true;
-            for (int d = 1; (d <= depth) && hit && rayAlive; d += 2)
-            {
-                ray.intersectionT = numeric_limits<scalar_type>::max;
-                ray.objectID = intersector_type::traceRay(ray, scene);
-
-                hit = ray.objectID.id != -1;
-                if (hit)
-                    rayAlive = closestHitProgram(1, i, ray, scene);
-            }
-            if (!hit)
-                missProgram(ray);
-
-            measure_type accumulation = ray.payload.accumulation;
+            measure_type accumulation = getSingleSampleMeasure(i, depth, scene);
             scalar_type rcpSampleSize = 1.0 / (i + 1);
             Li += (accumulation - Li) * rcpSampleSize;
 
@@ -302,6 +307,22 @@ struct Unidirectional
         return Li;
     }
 
+    void generateCascades(int32_t2 coords, uint32_t numSamples, uint32_t depth, NBL_CONST_REF_ARG(scene_type) scene)
+    {
+        measure_type Li = (measure_type)0.0;
+        scalar_type meanLumaSq = 0.0;
+        for (uint32_t i = 0; i < numSamples; i++)
+        {
+            measure_type accumulation = getSingleSampleMeasure(i, depth, scene);
+            scalar_type rcpSampleSize = 1.0 / (i + 1);
+            Li += (accumulation - Li) * rcpSampleSize;
+        }
+
+        cascade[uint3(coords.x, coords.y, 0)] = float4(Li.r, 0.0f, 0.0f, 0.0f);
+        cascade[uint3(coords.x, coords.y, 1)] = float4(0.0f, Li.g, 0.0f, 0.0f);
+        cascade[uint3(coords.x, coords.y, 2)] = float4(0.0f, 0.0f, Li.b, 0.0f);
+    }
+
     NBL_CONSTEXPR_STATIC_INLINE uint32_t MAX_DEPTH_LOG2 = 4u;
     NBL_CONSTEXPR_STATIC_INLINE uint32_t MAX_SAMPLES_LOG2 = 10u;
 

31_HLSLPathTracer/app_resources/hlsl/render.comp.hlsl

@@ -217,9 +217,17 @@ void main(uint32_t3 threadID : SV_DispatchThreadID)
 
     pathtracer_type pathtracer = pathtracer_type::create(ptCreateParams);
 
-    float32_t3 color = pathtracer.getMeasure(pc.sampleCount, pc.depth, scene);
-    float32_t4 pixCol = float32_t4(color, 1.0);
-    outImage[coords] = pixCol;
+    bool useRWMC = true; // TODO: move to push constants if we keep it
+    if(!useRWMC)
+    {
+        float32_t3 color = pathtracer.getMeasure(pc.sampleCount, pc.depth, scene);
+        float32_t4 pixCol = float32_t4(color, 1.0);
+        outImage[coords] = pixCol;
+    }
+    else
+    {
+        pathtracer.generateCascades(coords, pc.sampleCount, pc.depth, scene);
+    }
 
 #ifdef PERSISTENT_WORKGROUPS
     }

31_HLSLPathTracer/app_resources/hlsl/render_common.hlsl

@@ -19,5 +19,6 @@ struct SPushConstants
 [[vk::combinedImageSampler]][[vk::binding(2, 2)]] SamplerState scrambleSampler;
 
 [[vk::image_format("rgba16f")]][[vk::binding(0, 0)]] RWTexture2D<float32_t4> outImage;
+[[vk::image_format("rgba16f")]][[vk::binding(1, 0)]] RWTexture2DArray<float32_t4> cascade;
 
 #endif

31_HLSLPathTracer/app_resources/hlsl/reweighting.hlsl

@@ -0,0 +1,38 @@
+#include "nbl/builtin/hlsl/cpp_compat.hlsl"
+
+[[vk::image_format("rgba16f")]] [[vk::binding(0, 0)]] RWTexture2D<float32_t4> outImage;
+[[vk::image_format("rgba16f")]] [[vk::binding(1, 0)]] RWTexture2DArray<float32_t4> cascade;
+
+using namespace nbl;
+using namespace hlsl;
+
+NBL_CONSTEXPR uint32_t WorkgroupSize = 512;
+NBL_CONSTEXPR uint32_t MAX_DEPTH_LOG2 = 4;
+NBL_CONSTEXPR uint32_t MAX_SAMPLES_LOG2 = 10;
+
+int32_t2 getCoordinates()
+{
+    uint32_t width, height;
+    outImage.GetDimensions(width, height);
+    return int32_t2(glsl::gl_GlobalInvocationID().x % width, glsl::gl_GlobalInvocationID().x / width);
+}
+
+float calculateLumaRec709(float32_t4 color)
+{
+    return 0.2126 * color.r + 0.7152 * color.g + 0.0722 * color.b;
+}
+
+[numthreads(WorkgroupSize, 1, 1)]
+void main(uint32_t3 threadID : SV_DispatchThreadID)
+{
+    const int32_t2 coords = getCoordinates();
+
+    float r = cascade.Load(uint3(coords, 0)).r;
+    float g = cascade.Load(uint3(coords, 1)).g;
+    float b = cascade.Load(uint3(coords, 2)).b;
+    float32_t4 color = float32_t4(r, g, b, 1.0f);
+    float luma = calculateLumaRec709(color);
+    float32_t4 output = float32_t4(luma, luma, luma, 1.0f);
+
+    outImage[coords] = output;
+}