Refactor

Author: Przemog1

31_HLSLPathTracer/app_resources/hlsl/RWMCCascadeAccumulator.hlsl

@@ -6,6 +6,7 @@
 #include <nbl/builtin/hlsl/math/functions.hlsl>
 #include <nbl/builtin/hlsl/bxdf/bxdf_traits.hlsl>
 #include <nbl/builtin/hlsl/vector_utils/vector_traits.hlsl>
+#include <nbl/builtin/hlsl/concepts.hlsl>
 
 #include "rand_gen.hlsl"
 #include "ray_gen.hlsl"
@@ -41,8 +42,7 @@ struct PathTracerCreationParams
     BxDFCreation dielectricParams;
 };
 
-// TODO: maybe implement a concept to ensure that OutputTypeVec is a vector?
-template<typename OutputTypeVec>
+template<typename OutputTypeVec NBL_PRIMARY_REQUIRES(concepts::FloatingPointVector<OutputTypeVec>)
 struct DefaultAccumulator
 {
     struct DefaultAccumulatorInitializationSettings {};

31_HLSLPathTracer/app_resources/hlsl/pathtracer.hlsl

@@ -39,7 +39,7 @@
 #include "rwmc_global_settings_common.hlsl"
 
 #ifdef RWMC_ENABLED
-#include "RWMCCascadeAccumulator.hlsl"
+#include <nbl/builtin/hlsl/rwmc/CascadeAccumulator.hlsl>
 #include "render_rwmc_common.hlsl"
 #endif
 
@@ -124,7 +124,7 @@ using material_system_type = ext::MaterialSystem::System<diffuse_bxdf_type, cond
 using nee_type = ext::NextEventEstimator::Estimator<scene_type, ray_type, sample_t, aniso_interaction, ext::IntersectMode::IM_PROCEDURAL, LIGHT_TYPE, POLYGON_METHOD>;
 
 #ifdef RWMC_ENABLED
-using accumulator_type = rwmc::RWMCCascadeAccumulator<float32_t3, CascadeSize>;
+using accumulator_type = rwmc::CascadeAccumulator<float32_t3, CascadeSize>;
 #else
 using accumulator_type = ext::PathTracer::DefaultAccumulator<float32_t3>;
 #endif

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

@@ -1,7 +1,9 @@
-#include "nbl/builtin/hlsl/cpp_compat.hlsl"
-#include <nbl/builtin/hlsl/colorspace/encodeCIEXYZ.hlsl>
+#include <nbl/builtin/hlsl/rwmc/rwmc.hlsl>
 #include "resolve_common.hlsl"
 #include "rwmc_global_settings_common.hlsl"
+#ifdef PERSISTENT_WORKGROUPS
+#include "nbl/builtin/hlsl/math/morton.hlsl"
+#endif
 
 [[vk::push_constant]] ResolvePushConstants pc;
 [[vk::image_format("rgba16f")]] [[vk::binding(0, 0)]] RWTexture2D<float32_t4> outImage;
@@ -14,174 +16,33 @@ NBL_CONSTEXPR uint32_t WorkgroupSize = 512;
 NBL_CONSTEXPR uint32_t MAX_DEPTH_LOG2 = 4;
 NBL_CONSTEXPR uint32_t MAX_SAMPLES_LOG2 = 10;
 
-struct RWMCReweightingParameters
-{
-    uint32_t lastCascadeIndex;
-    float initialEmin; // a minimum image brightness that we always consider reliable
-    float reciprocalBase;
-    float reciprocalN;
-    float reciprocalKappa;
-    float colorReliabilityFactor;
-    float NOverKappa;
-};
-
-RWMCReweightingParameters computeReweightingParameters(float base, uint32_t sampleCount, float minReliableLuma, float kappa)
-{
-    RWMCReweightingParameters retval;
-    retval.lastCascadeIndex = CascadeSize - 1u;
-    retval.initialEmin = minReliableLuma;
-    retval.reciprocalBase = 1.f / base;
-    const float N = float(sampleCount);
-    retval.reciprocalN = 1.f / N;
-    retval.reciprocalKappa = 1.f / kappa;
-    // if not interested in exact expected value estimation (kappa!=1.f), can usually accept a bit more variance relative to the image brightness we already have
-    // allow up to ~<cascadeBase> more energy in one sample to lessen bias in some cases
-    retval.colorReliabilityFactor = base + (1.f - base) * retval.reciprocalKappa;
-    retval.NOverKappa = N * retval.reciprocalKappa;
-
-    return retval;
-}
-
-struct RWMCCascadeSample
-{
-	float32_t3 centerValue;
-	float normalizedCenterLuma;
-	float normalizedNeighbourhoodAverageLuma;
-};
-
-// TODO: figure out what values should pixels outside have, 0.0f is incorrect
-float32_t3 RWMCsampleCascadeTexel(int32_t2 currentCoord, int32_t2 offset, uint32_t cascadeIndex)
-{
-	const int32_t2 texelCoord = currentCoord + offset;
-	if (any(texelCoord < int32_t2(0, 0)))
-		return float32_t3(0.0f, 0.0f, 0.0f);
-
-    float32_t4 output = cascade.Load(int32_t3(texelCoord, int32_t(cascadeIndex)));
-    return float32_t3(output.r, output.g, output.b);
-}
-
-float32_t calcLuma(in float32_t3 col)
-{
-    return hlsl::dot<float32_t3>(hlsl::transpose(colorspace::scRGBtoXYZ)[1], col);
-}
-
-RWMCCascadeSample RWMCSampleCascade(in int32_t2 coord, in uint cascadeIndex, in float reciprocalBaseI)
-{
-	float32_t3 neighbourhood[9];
-	neighbourhood[0] = RWMCsampleCascadeTexel(coord, int32_t2(-1, -1), cascadeIndex);
-    neighbourhood[1] = RWMCsampleCascadeTexel(coord, int32_t2(0, -1), cascadeIndex);
-    neighbourhood[2] = RWMCsampleCascadeTexel(coord, int32_t2(1, -1), cascadeIndex);
-    neighbourhood[3] = RWMCsampleCascadeTexel(coord, int32_t2(-1, 0), cascadeIndex);
-    neighbourhood[4] = RWMCsampleCascadeTexel(coord, int32_t2(0, 0), cascadeIndex);
-    neighbourhood[5] = RWMCsampleCascadeTexel(coord, int32_t2(1, 0), cascadeIndex);
-    neighbourhood[6] = RWMCsampleCascadeTexel(coord, int32_t2(-1, 1), cascadeIndex);
-    neighbourhood[7] = RWMCsampleCascadeTexel(coord, int32_t2(0, 1), cascadeIndex);
-    neighbourhood[8] = RWMCsampleCascadeTexel(coord, int32_t2(1, 1), cascadeIndex);
-
-	// numerical robustness
-	float32_t3 excl_hood_sum = ((neighbourhood[0] + neighbourhood[1]) + (neighbourhood[2] + neighbourhood[3])) +
-		((neighbourhood[5] + neighbourhood[6]) + (neighbourhood[7] + neighbourhood[8]));
-
-	RWMCCascadeSample retval;
-	retval.centerValue = neighbourhood[4];
-	retval.normalizedNeighbourhoodAverageLuma = retval.normalizedCenterLuma = calcLuma(neighbourhood[4]) * reciprocalBaseI;
-	retval.normalizedNeighbourhoodAverageLuma = (calcLuma(excl_hood_sum) * reciprocalBaseI + retval.normalizedNeighbourhoodAverageLuma) / 9.f;
-	return retval;
-}
-
-float32_t3 RWMCReweight(in RWMCReweightingParameters params, in int32_t2 coord)
-{
-	float reciprocalBaseI = 1.f;
-	RWMCCascadeSample curr = RWMCSampleCascade(coord, 0u, reciprocalBaseI);
-
-	float32_t3 accumulation = float32_t3(0.0f, 0.0f, 0.0f);
-	float Emin = params.initialEmin;
-
-	float prevNormalizedCenterLuma, prevNormalizedNeighbourhoodAverageLuma;
-	for (uint i = 0u; i <= params.lastCascadeIndex; i++)
-	{
-		const bool notFirstCascade = i != 0u;
-		const bool notLastCascade = i != params.lastCascadeIndex;
-
-		RWMCCascadeSample next;
-		if (notLastCascade)
-		{
-			reciprocalBaseI *= params.reciprocalBase;
-			next = RWMCSampleCascade(coord, i + 1u, reciprocalBaseI);
-		}
-
-		float reliability = 1.f;
-		// sample counting-based reliability estimation
-		if (params.reciprocalKappa <= 1.f)
-		{
-			float localReliability = curr.normalizedCenterLuma;
-			// reliability in 3x3 pixel block (see robustness)
-			float globalReliability = curr.normalizedNeighbourhoodAverageLuma;
-			if (notFirstCascade)
-			{
-				localReliability += prevNormalizedCenterLuma;
-				globalReliability += prevNormalizedNeighbourhoodAverageLuma;
-			}
-			if (notLastCascade)
-			{
-				localReliability += next.normalizedCenterLuma;
-				globalReliability += next.normalizedNeighbourhoodAverageLuma;
-			}
-			// check if above minimum sampling threshold (avg 9 sample occurences in 3x3 neighbourhood), then use per-pixel reliability (NOTE: tertiary op is in reverse)
-			reliability = globalReliability < params.reciprocalN ? globalReliability : localReliability;
-			{
-				const float accumLuma = calcLuma(accumulation);
-				if (accumLuma > Emin)
-					Emin = accumLuma;
-
-				const float colorReliability = Emin * reciprocalBaseI * params.colorReliabilityFactor;
-
-				reliability += colorReliability;
-				reliability *= params.NOverKappa;
-				reliability -= params.reciprocalKappa;
-				reliability = clamp(reliability * 0.5f, 0.f, 1.f);
-			}
-		}
-		accumulation += curr.centerValue * reliability;
-
-		prevNormalizedCenterLuma = curr.normalizedCenterLuma;
-		prevNormalizedNeighbourhoodAverageLuma = curr.normalizedNeighbourhoodAverageLuma;
-		curr = next;
-	}
-
-	return accumulation;
-}
-
 int32_t2 getCoordinates()
 {
     uint32_t width, height;
     outImage.GetDimensions(width, height);
     return int32_t2(glsl::gl_GlobalInvocationID().x % width, glsl::gl_GlobalInvocationID().x / width);
 }
 
-// this function is for testing purpose
-// simply adds every cascade buffer, output shoud be nearly the same as output of default accumulator (RWMC off)
-float32_t3 sumCascade(in const int32_t2 coords)
-{
-    float32_t3 accumulation = float32_t3(0.0f, 0.0f, 0.0f);
-
-    for (int i = 0; i < 6; ++i)
-    {
-        float32_t4 cascadeLevel = cascade.Load(uint3(coords, i));
-        accumulation += float32_t3(cascadeLevel.r, cascadeLevel.g, cascadeLevel.b);
-    }
-
-	return accumulation;
-}
-
 [numthreads(WorkgroupSize, 1, 1)]
 void main(uint32_t3 threadID : SV_DispatchThreadID)
 {
+#ifdef PERSISTENT_WORKGROUPS
+    uint32_t virtualThreadIndex;
+    [loop]
+    for (uint32_t virtualThreadBase = glsl::gl_WorkGroupID().x * WorkgroupSize; virtualThreadBase < 1920 * 1080; virtualThreadBase += glsl::gl_NumWorkGroups().x * WorkgroupSize) // not sure why 1280*720 doesn't cover draw surface
+    {
+        virtualThreadIndex = virtualThreadBase + glsl::gl_LocalInvocationIndex().x;
+        const int32_t2 coords = (int32_t2)math::Morton<uint32_t>::decode2d(virtualThreadIndex);
+#else
     const int32_t2 coords = getCoordinates();
-    //float32_t3 color = sumCascade(coords);
+#endif
 
-    RWMCReweightingParameters reweightingParameters = computeReweightingParameters(pc.base, pc.sampleCount, pc.minReliableLuma, pc.kappa);
-	float32_t3 color = RWMCReweight(reweightingParameters, coords);
+    rwmc::ReweightingParameters reweightingParameters = rwmc::computeReweightingParameters(pc.base, pc.sampleCount, pc.minReliableLuma, pc.kappa, CascadeSize);
+    float32_t3 color = rwmc::reweight(reweightingParameters, cascade, coords);
 
-	outImage[coords] = float32_t4(color, 1.0f);
+    outImage[coords] = float32_t4(color, 1.0f);
+
+#ifdef PERSISTENT_WORKGROUPS
+    }
+#endif
 }