Increase the RT quality because it's ugly

AnKi/Renderer/IndirectDiffuseClipmaps.cpp

@@ -58,7 +58,7 @@ Error IndirectDiffuseClipmaps::init()
 	}
 
 	// Create the RT result texture
-	const U32 raysPerProbePerFrame = square(g_indirectDiffuseClipmapRadianceOctMapSize / 2);
+	const U32 raysPerProbePerFrame = square<U32>(g_indirectDiffuseClipmapRadianceOctMapSize);
 	m_rtResultRtDesc = getRenderer().create2DRenderTargetDescription(m_consts.m_totalProbeCount, raysPerProbePerFrame * kIndirectDiffuseClipmapCount,
 																	 Format::kR16G16B16A16_Sfloat, "IndirectDiffuseClipmap: RT result");
 	m_rtResultRtDesc.bake();
@@ -301,8 +301,7 @@ void IndirectDiffuseClipmaps::populateRenderGraph(RenderingContext& ctx)
 			rgraphCtx.bindUav(0, 2, rtResultHandle);
 			cmdb.bindUav(1, 2, TextureView(getDummyGpuResources().m_texture2DUav.get(), TextureSubresourceDesc::firstSurface()));
 
-			ANKI_ASSERT(g_indirectDiffuseClipmapRadianceOctMapSize % 2 == 0);
-			const U32 raysPerProbePerFrame = square(g_indirectDiffuseClipmapRadianceOctMapSize / 2);
+			const U32 raysPerProbePerFrame = square<U32>(g_indirectDiffuseClipmapRadianceOctMapSize);
 
 			for(U32 clipmap = 0; clipmap < kIndirectDiffuseClipmapCount; ++clipmap)
 			{
@@ -345,7 +344,7 @@ void IndirectDiffuseClipmaps::populateRenderGraph(RenderingContext& ctx)
 				const UVec4 consts(clipmap);
 				cmdb.setFastConstants(&consts, sizeof(consts));
 
-				const U32 raysPerProbePerFrame = square(g_indirectDiffuseClipmapRadianceOctMapSize / 2);
+				const U32 raysPerProbePerFrame = square<U32>(g_indirectDiffuseClipmapRadianceOctMapSize);
 				const U32 threadCount = 64;
 				cmdb.dispatchCompute((raysPerProbePerFrame * m_consts.m_totalProbeCount + threadCount - 1) / threadCount, 1, 1);
 			}
@@ -389,7 +388,7 @@ void IndirectDiffuseClipmaps::populateRenderGraph(RenderingContext& ctx)
 	}
 
 	// Apply GI
-	if(0)
+	if(1)
 	{
 		patchShaderBindingTablePass("IndirectDiffuseClipmaps: Patch SBT", m_rtLibraryGrProg.get(), m_rayGenShaderGroupIndices[0],
 									m_missShaderGroupIdx, m_sbtRecordSize, rgraph, sbtHandle, sbtBuffer);

AnKi/Shaders/IndirectDiffuseClipmaps.ankiprog

@@ -65,15 +65,10 @@ ANKI_FAST_CONSTANTS(Consts, g_consts)
 	const Vec3 probeWorldPos = probe3dIdx * probeSize + probeSize * 0.5 + clipmapAabbMin;
 
 	// Generate direction
-	const U32 checkerboardIdx = g_globalRendererConstants.m_frame % 4;
-	const U32 sampleIdx = (g_globalRendererConstants.m_frame / 4) % 8;
-	const U32 halfRadianceOctMapSize = g_consts.m_radianceOctMapSize / 2;
-	UVec2 radianceOctCoord = UVec2(outPixelIdx % halfRadianceOctMapSize, outPixelIdx / halfRadianceOctMapSize);
-	radianceOctCoord *= 2u; // Because there is one output pixel every 4 radiance oct map pixels
-	radianceOctCoord.x += checkerboardIdx & 1u;
-	radianceOctCoord.y += checkerboardIdx >> 1u;
+	const UVec2 radianceOctCoord = UVec2(outPixelIdx % g_consts.m_radianceOctMapSize, outPixelIdx / g_consts.m_radianceOctMapSize);
 	ANKI_ASSERT(all(radianceOctCoord < g_consts.m_radianceOctMapSize));
-	const Vec2 sampleCoord = radianceOctCoord + 0.5 + generateMsaa8x(sampleIdx) / (8.0 * 2.0);
+	const U32 sampleIdx = (g_globalRendererConstants.m_frame + probeIdx) % 16;
+	const Vec2 sampleCoord = radianceOctCoord + 0.5 + generateMsaa16x(sampleIdx) / (16.0 * 2.0);
 	const HVec3 dir = octahedronDecode(sampleCoord / g_consts.m_radianceOctMapSize);
 
 	// Trace
@@ -104,7 +99,7 @@ ANKI_FAST_CONSTANTS(Consts, g_consts)
 	}
 
 	// Store result
-	const U32 raysPerProbePerFrame = square(g_consts.m_radianceOctMapSize / 2);
+	const U32 raysPerProbePerFrame = square(g_consts.m_radianceOctMapSize);
 	const F32 kMaxDist = 1000.0; // Chose something small and make sure its square doesn't overflow F16
 	TEX(g_lightResultTex, UVec2(probeIdx, outPixelIdx + raysPerProbePerFrame * g_consts.m_clipmapIdx)) = HVec4(radiance, min(rayT, kMaxDist));
 }
@@ -222,8 +217,7 @@ ANKI_FAST_CONSTANTS(Consts, g_consts)
 	const Vec3 clipmapAabbMin = idConsts.m_aabbMins[clipmapIdx].xyz;
 	const Vec3 prevClipmapAabbMin = idConsts.m_previousFrameAabbMins[clipmapIdx].xyz;
 
-	const U32 halfRadianceOctMapSize = RADIANCE_OCTAHEDRON_MAP_SIZE / 2;
-	const U32 raysPerProbePerFrame = square(halfRadianceOctMapSize);
+	const U32 raysPerProbePerFrame = square(RADIANCE_OCTAHEDRON_MAP_SIZE);
 
 	const U32 rtPixelIdx = svDispatchThreadId.x % raysPerProbePerFrame;
 	const U32 probeIdx = svDispatchThreadId.x / raysPerProbePerFrame;
@@ -254,12 +248,7 @@ ANKI_FAST_CONSTANTS(Consts, g_consts)
 	// Update the radiance and distance moments volumes
 	{
 		// Compute oct coord
-		const U32 checkerboardIdx = g_globalRendererConstants.m_frame % 4;
-
-		UVec2 radianceOctCoord = UVec2(rtPixelIdx % halfRadianceOctMapSize, rtPixelIdx / halfRadianceOctMapSize);
-		radianceOctCoord *= 2u; // Because there is one output pixel every 4 radiance oct map pixels
-		radianceOctCoord.x += checkerboardIdx & 1u;
-		radianceOctCoord.y += checkerboardIdx >> 1u;
+		const UVec2 radianceOctCoord = UVec2(rtPixelIdx % RADIANCE_OCTAHEDRON_MAP_SIZE, rtPixelIdx / RADIANCE_OCTAHEDRON_MAP_SIZE);
 		ANKI_ASSERT(all(radianceOctCoord < RADIANCE_OCTAHEDRON_MAP_SIZE));
 
 		UVec3 actualVolumeTexCoord;
@@ -270,7 +259,7 @@ ANKI_FAST_CONSTANTS(Consts, g_consts)
 		Vec2 avgMoments = 0.0;
 		if(blendWithHistory)
 		{
-			const F16 blendFactor = 0.1;
+			const F16 blendFactor = 0.1 / 4.0;
 
 			const HVec3 prevValue = TEX(g_radianceVolume, actualVolumeTexCoord).xyz;
 			avgRadiance = lerp(prevValue, radiance, blendFactor);
@@ -300,44 +289,6 @@ ANKI_FAST_CONSTANTS(Consts, g_consts)
 			TEX(g_radianceVolume, actualVolumeTexCoord).xyz = avgRadiance;
 			TEX(g_distanceMomentsVolume, actualVolumeTexCoord).xy = avgMoments;
 		}
-
-		// Set the texels of the oct that don't have a valid value
-		if(!blendWithHistory)
-		{
-			for(U32 otherCheckerboardIdx = 0; otherCheckerboardIdx < 4; ++otherCheckerboardIdx)
-			{
-				if(otherCheckerboardIdx == checkerboardIdx)
-				{
-					continue;
-				}
-
-				UVec2 otherOctCoord = UVec2(rtPixelIdx % halfRadianceOctMapSize, rtPixelIdx / halfRadianceOctMapSize);
-				otherOctCoord *= 2u;
-				otherOctCoord.x += otherCheckerboardIdx & 1u;
-				otherOctCoord.y += otherCheckerboardIdx >> 1u;
-
-				UVec3 actualVolumeTexCoord;
-				actualVolumeTexCoord.xy = otherOctCoord + noOctTexCoord * (RADIANCE_OCTAHEDRON_MAP_SIZE + 2) + 1;
-				actualVolumeTexCoord.z = noOctTexCoord.z;
-
-				TEX(g_radianceVolume, actualVolumeTexCoord).xyz = avgRadiance;
-				TEX(g_distanceMomentsVolume, actualVolumeTexCoord).xy = avgMoments;
-
-				// Set oct borders
-				IVec2 borders[3];
-				const U32 borderCount = octahedronBorder(RADIANCE_OCTAHEDRON_MAP_SIZE, otherOctCoord, borders);
-				for(U32 i = 0; i < borderCount; ++i)
-				{
-					IVec3 actualVolumeTexCoord;
-					actualVolumeTexCoord.xy = otherOctCoord + noOctTexCoord * (RADIANCE_OCTAHEDRON_MAP_SIZE + 2) + 1;
-					actualVolumeTexCoord.xy += borders[i];
-					actualVolumeTexCoord.z = noOctTexCoord.z;
-
-					TEX(g_radianceVolume, actualVolumeTexCoord).xyz = avgRadiance;
-					TEX(g_distanceMomentsVolume, actualVolumeTexCoord).xy = avgMoments;
-				}
-			}
-		}
 	}
 
 	// Update probe validity

AnKi/Shaders/Reflections.ankiprog

@@ -208,6 +208,9 @@ ANKI_FAST_CONSTANTS(ReflectionConstants, g_consts)
 groupshared Vec4 g_viewHitPointAndSsrSuccess[NUM_THREADS_SQRT][NUM_THREADS_SQRT];
 groupshared Vec4 g_colorAndDepth[NUM_THREADS_SQRT][NUM_THREADS_SQRT];
 
+constexpr SampleClipmapFlag kSampleClipmapFlags =
+	kSampleClipmapFlagBiasSamplePointTowardsCamera | kSampleClipmapFlagInvalidProbeRejection | kSampleClipmapFlagBackfacingProbeRejection;
+
 Vec3 doLightShading(Vec3 worldPos, Vec3 viewPos, UVec2 coord, F32 depth)
 {
 	// Read
@@ -217,10 +220,9 @@ Vec3 doLightShading(Vec3 worldPos, Vec3 viewPos, UVec2 coord, F32 depth)
 	Vec3 outColor = gbuffer.m_emission;
 
 #	if INDIRECT_DIFFUSE_CLIPMAPS
-	const SampleClipmapFlag flags =
-		kSampleClipmapFlagFullQuality & ~(kSampleClipmapFlagChebyshevOcclusion | kSampleClipmapFlagAccurateClipmapSelection);
-	const Vec3 irradiance = sampleClipmapIrradiance(worldPos, gbuffer.m_normal, g_globalRendererConstants.m_cameraPosition,
-													g_globalRendererConstants.m_indirectDiffuseClipmaps, g_linearAnyRepeatSampler, flags);
+	const Vec3 irradiance =
+		sampleClipmapIrradiance(worldPos, gbuffer.m_normal, g_globalRendererConstants.m_cameraPosition,
+								g_globalRendererConstants.m_indirectDiffuseClipmaps, g_linearAnyRepeatSampler, kSampleClipmapFlags);
 	outColor += irradiance * gbuffer.m_diffuse;
 #	else
 	// GI
@@ -382,10 +384,8 @@ void bestCandidateToHallucinate(IVec2 svGroupThreadId, IVec2 offset, F32 depth,
 		const Vec3 reflDir = reflect(normalize(worldPos.xyz - g_globalRendererConstants.m_cameraPosition), worldNormal);
 
 #	if INDIRECT_DIFFUSE_CLIPMAPS
-		const SampleClipmapFlag flags =
-			kSampleClipmapFlagFullQuality & ~(kSampleClipmapFlagChebyshevOcclusion | kSampleClipmapFlagAccurateClipmapSelection);
 		const Vec3 col = sampleClipmapRadiance(worldPos, reflDir, g_globalRendererConstants.m_cameraPosition,
-											   g_globalRendererConstants.m_indirectDiffuseClipmaps, g_linearAnyRepeatSampler, flags);
+											   g_globalRendererConstants.m_indirectDiffuseClipmaps, g_linearAnyRepeatSampler, kSampleClipmapFlags);
 #	else
 		Cluster cluster = getClusterFragCoord(g_clusters, g_globalRendererConstants, Vec3(logicalCoord.xy + 0.5, depth));
 		const Vec3 col = sampleGiProbes<F32>(cluster, g_giProbes, reflDir, worldPos.xyz, g_trilinearClampSampler);
@@ -436,10 +436,8 @@ void bestCandidateToHallucinate(IVec2 svGroupThreadId, IVec2 offset, F32 depth,
 		worldPos.xyz /= worldPos.w;
 
 #	if INDIRECT_DIFFUSE_CLIPMAPS
-		const SampleClipmapFlag flags =
-			kSampleClipmapFlagFullQuality & ~(kSampleClipmapFlagChebyshevOcclusion | kSampleClipmapFlagAccurateClipmapSelection);
 		outColor = sampleClipmapRadiance(worldPos, woldReflDir, g_globalRendererConstants.m_cameraPosition,
-										 g_globalRendererConstants.m_indirectDiffuseClipmaps, g_linearAnyRepeatSampler, flags);
+										 g_globalRendererConstants.m_indirectDiffuseClipmaps, g_linearAnyRepeatSampler, kSampleClipmapFlags);
 #	else
 		outColor = sampleGiProbes<F32>(cluster, g_giProbes, woldReflDir, worldPos.xyz, g_trilinearClampSampler);
 #	endif

Samples/PhysicsPlayground/Main.cpp

@@ -189,16 +189,33 @@ Error MyApp::userMainLoop(Bool& quit, [[maybe_unused]] Second elapsedTime)
 {
 	// ANKI_CHECK(SampleApp::userMainLoop(quit));
 	Renderer& renderer = Renderer::getSingleton();
+	Input& in = Input::getSingleton();
 
 	if(Input::getSingleton().getKey(KeyCode::kEscape))
 	{
 		quit = true;
 	}
 
-	if(Input::getSingleton().getKey(KeyCode::kH) == 1)
+	if(in.getKey(KeyCode::kY) == 1)
 	{
 		renderer.setCurrentDebugRenderTarget(
 			(renderer.getCurrentDebugRenderTarget() == "IndirectDiffuseClipmapsTest") ? "" : "IndirectDiffuseClipmapsTest");
+		// g_shadowMappingPcssCVar = !g_shadowMappingPcssCVar;
+	}
+
+	if(in.getKey(KeyCode::kU) == 1)
+	{
+		renderer.setCurrentDebugRenderTarget((renderer.getCurrentDebugRenderTarget() == "Reflections") ? "" : "Reflections");
+	}
+
+	if(in.getKey(KeyCode::kI) == 1)
+	{
+		renderer.setCurrentDebugRenderTarget((renderer.getCurrentDebugRenderTarget() == "IndirectDiffuse") ? "" : "IndirectDiffuse");
+	}
+
+	if(in.getKey(KeyCode::kO) == 1)
+	{
+		renderer.setCurrentDebugRenderTarget((renderer.getCurrentDebugRenderTarget() == "RtMaterialFetchDbg") ? "" : "RtMaterialFetchDbg");
 	}
 
 	if(Input::getSingleton().getKey(KeyCode::kP) == 1)