Add a raster path to indirect diffuse

AnKi/Renderer/IndirectDiffuse.cpp

@@ -33,19 +33,27 @@ Error IndirectDiffuse::initInternal()
 {
 	const UVec2 size = m_r->getInternalResolution() / 2;
 	ANKI_ASSERT((m_r->getInternalResolution() % 2) == UVec2(0u) && "Needs to be dividable for proper upscaling");
+	const Bool preferCompute = getConfig().getRPreferCompute();
 
 	// Init textures
-	TextureInitInfo texInit = m_r->create2DRenderTargetInitInfo(
-		size.x(), size.y(), Format::B10G11R11_UFLOAT_PACK32,
-		TextureUsageBit::IMAGE_COMPUTE_WRITE | TextureUsageBit::ALL_SAMPLED, "IndirectDiffuse #1");
+	TextureUsageBit usage = TextureUsageBit::ALL_SAMPLED;
+
+	usage |= (preferCompute) ? TextureUsageBit::IMAGE_COMPUTE_WRITE : TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE;
+	TextureInitInfo texInit = m_r->create2DRenderTargetInitInfo(size.x(), size.y(), Format::B10G11R11_UFLOAT_PACK32,
+																usage, "IndirectDiffuse #1");
 	texInit.m_initialUsage = TextureUsageBit::ALL_SAMPLED;
 	m_rts[0] = m_r->createAndClearRenderTarget(texInit);
 	texInit.setName("IndirectDiffuse #2");
 	m_rts[1] = m_r->createAndClearRenderTarget(texInit);
 
+	m_fbDescr.m_colorAttachmentCount = 1;
+	m_fbDescr.bake();
+
 	// Init SSGI+probes pass
 	{
-		ANKI_CHECK(getResourceManager().loadResource("Shaders/IndirectDiffuse.ankiprog", m_main.m_prog));
+		ANKI_CHECK(getResourceManager().loadResource((preferCompute) ? "Shaders/IndirectDiffuseCompute.ankiprog"
+																	 : "Shaders/IndirectDiffuseRaster.ankiprog",
+													 m_main.m_prog));
 
 		const ShaderProgramResourceVariant* variant;
 		m_main.m_prog->getOrCreateVariant(variant);
@@ -54,7 +62,9 @@ Error IndirectDiffuse::initInternal()
 
 	// Init denoise
 	{
-		ANKI_CHECK(getResourceManager().loadResource("Shaders/IndirectDiffuseDenoise.ankiprog", m_denoise.m_prog));
+		ANKI_CHECK(getResourceManager().loadResource((preferCompute) ? "Shaders/IndirectDiffuseDenoiseCompute.ankiprog"
+																	 : "Shaders/IndirectDiffuseDenoiseRaster.ankiprog",
+													 m_denoise.m_prog));
 
 		ShaderProgramResourceVariantInitInfo variantInit(m_denoise.m_prog);
 		variantInit.addMutation("BLUR_ORIENTATION", 0);
@@ -73,6 +83,7 @@ Error IndirectDiffuse::initInternal()
 void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 {
 	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	const Bool preferCompute = getConfig().getRPreferCompute();
 
 	// SSGI+probes
 	{
@@ -92,23 +103,38 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 		}
 
 		// Create main pass
-		ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("IndirectDiffuse");
+		TextureUsageBit readUsage;
+		TextureUsageBit writeUsage;
+		RenderPassDescriptionBase* prpass;
+		if(preferCompute)
+		{
+			ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("IndirectDiffuse");
+			readUsage = TextureUsageBit::SAMPLED_COMPUTE;
+			writeUsage = TextureUsageBit::IMAGE_COMPUTE_WRITE;
+			prpass = &rpass;
+		}
+		else
+		{
+			GraphicsRenderPassDescription& rpass = rgraph.newGraphicsRenderPass("IndirectDiffuse");
+			rpass.setFramebufferInfo(m_fbDescr, {m_runCtx.m_mainRtHandles[WRITE]}, {});
+			readUsage = TextureUsageBit::SAMPLED_FRAGMENT;
+			writeUsage = TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE;
+			prpass = &rpass;
+		}
 
-		rpass.newDependency(
-			RenderPassDependency(m_runCtx.m_mainRtHandles[WRITE], TextureUsageBit::IMAGE_COMPUTE_WRITE));
+		prpass->newDependency(RenderPassDependency(m_runCtx.m_mainRtHandles[WRITE], writeUsage));
 
-		const TextureUsageBit readUsage = TextureUsageBit::SAMPLED_COMPUTE;
-		m_r->getIndirectDiffuseProbes().setRenderGraphDependencies(ctx, rpass, readUsage);
-		rpass.newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(2), readUsage));
+		m_r->getIndirectDiffuseProbes().setRenderGraphDependencies(ctx, *prpass, readUsage);
+		prpass->newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(2), readUsage));
 		TextureSubresourceInfo hizSubresource;
 		hizSubresource.m_mipmapCount = 1;
-		rpass.newDependency(RenderPassDependency(m_r->getDepthDownscale().getHiZRt(), readUsage, hizSubresource));
-		rpass.newDependency(RenderPassDependency(m_r->getDownscaleBlur().getRt(), readUsage));
-		rpass.newDependency(RenderPassDependency(m_r->getMotionVectors().getMotionVectorsRt(), readUsage));
-		rpass.newDependency(RenderPassDependency(m_r->getMotionVectors().getRejectionFactorRt(), readUsage));
-		rpass.newDependency(RenderPassDependency(m_runCtx.m_mainRtHandles[READ], readUsage));
+		prpass->newDependency(RenderPassDependency(m_r->getDepthDownscale().getHiZRt(), readUsage, hizSubresource));
+		prpass->newDependency(RenderPassDependency(m_r->getDownscaleBlur().getRt(), readUsage));
+		prpass->newDependency(RenderPassDependency(m_r->getMotionVectors().getMotionVectorsRt(), readUsage));
+		prpass->newDependency(RenderPassDependency(m_r->getMotionVectors().getRejectionFactorRt(), readUsage));
+		prpass->newDependency(RenderPassDependency(m_runCtx.m_mainRtHandles[READ], readUsage));
 
-		rpass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
+		prpass->setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
 			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 			cmdb->bindShaderProgram(m_main.m_grProg);
 
@@ -118,18 +144,21 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 			bindUniforms(cmdb, 0, 2, binning.m_globalIlluminationProbesToken);
 			bindStorage(cmdb, 0, 3, binning.m_clustersToken);
 
-			rgraphCtx.bindImage(0, 4, m_runCtx.m_mainRtHandles[WRITE]);
-
-			cmdb->bindSampler(0, 5, m_r->getSamplers().m_trilinearClamp);
-			rgraphCtx.bindColorTexture(0, 6, m_r->getGBuffer().getColorRt(2));
+			cmdb->bindSampler(0, 4, m_r->getSamplers().m_trilinearClamp);
+			rgraphCtx.bindColorTexture(0, 5, m_r->getGBuffer().getColorRt(2));
 
 			TextureSubresourceInfo hizSubresource;
 			hizSubresource.m_mipmapCount = 1;
-			rgraphCtx.bindTexture(0, 7, m_r->getDepthDownscale().getHiZRt(), hizSubresource);
-			rgraphCtx.bindColorTexture(0, 8, m_r->getDownscaleBlur().getRt());
-			rgraphCtx.bindColorTexture(0, 9, m_runCtx.m_mainRtHandles[READ]);
-			rgraphCtx.bindColorTexture(0, 10, m_r->getMotionVectors().getMotionVectorsRt());
-			rgraphCtx.bindColorTexture(0, 11, m_r->getMotionVectors().getRejectionFactorRt());
+			rgraphCtx.bindTexture(0, 6, m_r->getDepthDownscale().getHiZRt(), hizSubresource);
+			rgraphCtx.bindColorTexture(0, 7, m_r->getDownscaleBlur().getRt());
+			rgraphCtx.bindColorTexture(0, 8, m_runCtx.m_mainRtHandles[READ]);
+			rgraphCtx.bindColorTexture(0, 9, m_r->getMotionVectors().getMotionVectorsRt());
+			rgraphCtx.bindColorTexture(0, 10, m_r->getMotionVectors().getRejectionFactorRt());
+
+			if(getConfig().getRPreferCompute())
+			{
+				rgraphCtx.bindImage(0, 11, m_runCtx.m_mainRtHandles[WRITE]);
+			}
 
 			// Bind uniforms
 			IndirectDiffuseUniforms unis;
@@ -144,32 +173,54 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 			unis.m_ssaoStrength = getConfig().getRIndirectDiffuseSsaoStrength();
 			cmdb->setPushConstants(&unis, sizeof(unis));
 
-			// Dispatch
-			dispatchPPCompute(cmdb, 8, 8, unis.m_viewportSize.x(), unis.m_viewportSize.y());
+			if(getConfig().getRPreferCompute())
+			{
+				dispatchPPCompute(cmdb, 8, 8, unis.m_viewportSize.x(), unis.m_viewportSize.y());
+			}
+			else
+			{
+				cmdb->setViewport(0, 0, unis.m_viewportSize.x(), unis.m_viewportSize.y());
+
+				cmdb->drawArrays(PrimitiveTopology::TRIANGLES, 3);
+			}
 		});
 	}
 
 	// Denoise
 	for(U32 dir = 0; dir < 2; ++dir)
 	{
-		ComputeRenderPassDescription& rpass =
-			rgraph.newComputeRenderPass((dir == 0) ? "IndirectDiffuseDenoiseH" : "IndirectDiffuseDenoiseV");
-
-		const TextureUsageBit readUsage = TextureUsageBit::SAMPLED_COMPUTE;
 		const U32 readIdx = (dir == 0) ? WRITE : READ;
 
-		rpass.newDependency(RenderPassDependency(m_runCtx.m_mainRtHandles[readIdx], readUsage));
+		TextureUsageBit readUsage;
+		TextureUsageBit writeUsage;
+		RenderPassDescriptionBase* prpass;
+		if(preferCompute)
+		{
+			ComputeRenderPassDescription& rpass =
+				rgraph.newComputeRenderPass((dir == 0) ? "IndirectDiffuseDenoiseH" : "IndirectDiffuseDenoiseV");
+			readUsage = TextureUsageBit::SAMPLED_COMPUTE;
+			writeUsage = TextureUsageBit::IMAGE_COMPUTE_WRITE;
+			prpass = &rpass;
+		}
+		else
+		{
+			GraphicsRenderPassDescription& rpass =
+				rgraph.newGraphicsRenderPass((dir == 0) ? "IndirectDiffuseDenoiseH" : "IndirectDiffuseDenoiseV");
+			rpass.setFramebufferInfo(m_fbDescr, {m_runCtx.m_mainRtHandles[!readIdx]}, {});
+			readUsage = TextureUsageBit::SAMPLED_FRAGMENT;
+			writeUsage = TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE;
+			prpass = &rpass;
+		}
+
+		prpass->newDependency(RenderPassDependency(m_runCtx.m_mainRtHandles[readIdx], readUsage));
 
 		TextureSubresourceInfo hizSubresource;
 		hizSubresource.m_mipmapCount = 1;
-		rpass.newDependency(RenderPassDependency(m_r->getDepthDownscale().getHiZRt(), readUsage, hizSubresource));
-
-		rpass.newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(2), readUsage));
-
-		rpass.newDependency(
-			RenderPassDependency(m_runCtx.m_mainRtHandles[!readIdx], TextureUsageBit::IMAGE_COMPUTE_WRITE));
+		prpass->newDependency(RenderPassDependency(m_r->getDepthDownscale().getHiZRt(), readUsage, hizSubresource));
+		prpass->newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(2), readUsage));
+		prpass->newDependency(RenderPassDependency(m_runCtx.m_mainRtHandles[!readIdx], writeUsage));
 
-		rpass.setWork([this, &ctx, dir, readIdx](RenderPassWorkContext& rgraphCtx) {
+		prpass->setWork([this, &ctx, dir, readIdx](RenderPassWorkContext& rgraphCtx) {
 			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 			cmdb->bindShaderProgram(m_denoise.m_grProgs[dir]);
 
@@ -179,7 +230,11 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 			hizSubresource.m_mipmapCount = 1;
 			rgraphCtx.bindTexture(0, 2, m_r->getDepthDownscale().getHiZRt(), hizSubresource);
 			rgraphCtx.bindColorTexture(0, 3, m_r->getGBuffer().getColorRt(2));
-			rgraphCtx.bindImage(0, 4, m_runCtx.m_mainRtHandles[!readIdx]);
+
+			if(getConfig().getRPreferCompute())
+			{
+				rgraphCtx.bindImage(0, 4, m_runCtx.m_mainRtHandles[!readIdx]);
+			}
 
 			IndirectDiffuseDenoiseUniforms unis;
 			unis.m_invertedViewProjectionJitterMat = ctx.m_matrices.m_invertedViewProjectionJitter;
@@ -190,8 +245,16 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 
 			cmdb->setPushConstants(&unis, sizeof(unis));
 
-			// Dispatch
-			dispatchPPCompute(cmdb, 8, 8, unis.m_viewportSize.x(), unis.m_viewportSize.y());
+			if(getConfig().getRPreferCompute())
+			{
+				dispatchPPCompute(cmdb, 8, 8, unis.m_viewportSize.x(), unis.m_viewportSize.y());
+			}
+			else
+			{
+				cmdb->setViewport(0, 0, unis.m_viewportSize.x(), unis.m_viewportSize.y());
+
+				cmdb->drawArrays(PrimitiveTopology::TRIANGLES, 3);
+			}
 		});
 	}
 }

AnKi/Renderer/IndirectDiffuse.h

@@ -44,6 +44,7 @@ public:
 
 private:
 	Array<TexturePtr, 2> m_rts;
+	FramebufferDescription m_fbDescr;
 	Bool m_rtsImportedOnce = false;
 
 	static constexpr U32 READ = 0;

AnKi/ShaderCompiler/ShaderProgramParser.cpp

@@ -255,6 +255,9 @@ layout(std140, row_major) buffer;
 
 #define ANKI_RP mediump
 #define ANKI_FP highp
+
+precision highp int;
+precision highp float;
 )";
 
 static const U64 SHADER_HEADER_HASH = computeHash(SHADER_HEADER, sizeof(SHADER_HEADER));

AnKi/Shaders/IndirectDiffuse.ankiprog → AnKi/Shaders/IndirectDiffuse.glsl

@@ -13,31 +13,35 @@ ANKI_SPECIALIZATION_CONSTANT_U32(SAMPLE_COUNT, 6u);
 #define REPROJECT_LIGHTBUFFER false
 #define SSGI_PROBE_COMBINE(ssgiColor, probeColor) ((ssgiColor) + (probeColor))
 
-#pragma anki start comp
 #include <AnKi/Shaders/Functions.glsl>
 #include <AnKi/Shaders/PackFunctions.glsl>
 #include <AnKi/Shaders/ImportanceSampling.glsl>
 #include <AnKi/Shaders/TonemappingFunctions.glsl>
 #include <AnKi/Shaders/Include/IndirectDiffuseTypes.h>
 
-const UVec2 WORKGROUP_SIZE = UVec2(8, 8);
-layout(local_size_x = WORKGROUP_SIZE.x, local_size_y = WORKGROUP_SIZE.y) in;
-
 #define CLUSTERED_SHADING_SET 0
 #define CLUSTERED_SHADING_UNIFORMS_BINDING 0
 #define CLUSTERED_SHADING_GI_BINDING 1
 #define CLUSTERED_SHADING_CLUSTERS_BINDING 3
 #include <AnKi/Shaders/ClusteredShadingCommon.glsl>
 
-layout(set = 0, binding = 4) writeonly uniform image2D u_outImage;
+layout(set = 0, binding = 4) uniform sampler u_linearAnyClampSampler;
+layout(set = 0, binding = 5) ANKI_RP uniform texture2D u_gbufferRt2;
+layout(set = 0, binding = 6) uniform texture2D u_depthRt;
+layout(set = 0, binding = 7) ANKI_RP uniform texture2D u_lightBufferRt;
+layout(set = 0, binding = 8) ANKI_RP uniform texture2D u_historyTex;
+layout(set = 0, binding = 9) uniform texture2D u_motionVectorsTex;
+layout(set = 0, binding = 10) uniform texture2D u_motionVectorsRejectionTex;
+
+#if defined(ANKI_COMPUTE_SHADER)
+const UVec2 WORKGROUP_SIZE = UVec2(8, 8);
+layout(local_size_x = WORKGROUP_SIZE.x, local_size_y = WORKGROUP_SIZE.y) in;
 
-layout(set = 0, binding = 5) uniform sampler u_linearAnyClampSampler;
-layout(set = 0, binding = 6) ANKI_RP uniform texture2D u_gbufferRt2;
-layout(set = 0, binding = 7) uniform texture2D u_depthRt;
-layout(set = 0, binding = 8) ANKI_RP uniform texture2D u_lightBufferRt;
-layout(set = 0, binding = 9) ANKI_RP uniform texture2D u_historyTex;
-layout(set = 0, binding = 10) uniform texture2D u_motionVectorsTex;
-layout(set = 0, binding = 11) uniform texture2D u_motionVectorsRejectionTex;
+layout(set = 0, binding = 11) writeonly uniform image2D u_outImage;
+#else
+layout(location = 0) in Vec2 in_uv;
+layout(location = 0) out Vec3 out_color;
+#endif
 
 layout(push_constant, std430) uniform b_pc
 {
@@ -52,6 +56,7 @@ Vec4 cheapProject(Vec4 point)
 
 void main()
 {
+#if defined(ANKI_COMPUTE_SHADER)
 	if(gl_GlobalInvocationID.x >= u_unis.m_viewportSize.x || gl_GlobalInvocationID.y >= u_unis.m_viewportSize.y)
 	{
 		return;
@@ -59,6 +64,11 @@ void main()
 
 	const Vec2 fragCoord = Vec2(gl_GlobalInvocationID.xy) + 0.5;
 	const Vec2 uv = fragCoord / u_unis.m_viewportSizef;
+#else
+	const Vec2 fragCoord = gl_FragCoord.xy;
+	const Vec2 uv = in_uv;
+#endif
+
 	const Vec2 ndc = UV_TO_NDC(uv);
 
 	// Get normal
@@ -84,7 +94,12 @@ void main()
 		const ANKI_RP F32 projRadius = length(projSphereLimit2 - ndc);
 
 		// Loop to compute
-		const UVec2 random = rand3DPCG16(UVec3(gl_GlobalInvocationID.xy, u_clusteredShading.m_frame)).xy;
+#if defined(ANKI_COMPUTE_SHADER)
+		const UVec2 globalInvocation = gl_GlobalInvocationID.xy;
+#else
+		const UVec2 globalInvocation = UVec2(gl_FragCoord.xy);
+#endif
+		const UVec2 random = rand3DPCG16(UVec3(globalInvocation, u_clusteredShading.m_frame)).xy;
 		for(U32 i = 0u; i < u_unis.m_sampleCount; ++i)
 		{
 			const Vec2 point = UV_TO_NDC(hammersleyRandom16(i, u_unis.m_sampleCount, random));
@@ -214,7 +229,9 @@ void main()
 	}
 
 	// Store color
+#if defined(ANKI_COMPUTE_SHADER)
 	imageStore(u_outImage, IVec2(gl_GlobalInvocationID.xy), Vec4(outColor, 1.0));
+#else
+	out_color = outColor;
+#endif
 }
-
-#pragma anki end

AnKi/Shaders/IndirectDiffuseCompute.ankiprog

@@ -0,0 +1,8 @@
+// Copyright (C) 2009-2021, Panagiotis Christopoulos Charitos and contributors.
+// All rights reserved.
+// Code licensed under the BSD License.
+// http://www.anki3d.org/LICENSE
+
+#pragma anki start comp
+#include <AnKi/Shaders/IndirectDiffuse.glsl>
+#pragma anki end

AnKi/Shaders/IndirectDiffuseDenoise.ankiprog → AnKi/Shaders/IndirectDiffuseDenoise.glsl

@@ -5,21 +5,25 @@
 
 #pragma anki mutator BLUR_ORIENTATION 0 1 // 0: in X axis, 1: in Y axis
 
-#pragma anki start comp
-
 #include <AnKi/Shaders/Include/IndirectDiffuseTypes.h>
 #include <AnKi/Shaders/PackFunctions.glsl>
 #include <AnKi/Shaders/Functions.glsl>
 #include <AnKi/Shaders/BilateralFilter.glsl>
 
-const UVec2 WORKGROUP_SIZE = UVec2(8u, 8u);
-layout(local_size_x = WORKGROUP_SIZE.x, local_size_y = WORKGROUP_SIZE.y) in;
-
 layout(set = 0, binding = 0) uniform sampler u_linearAnyClampSampler;
 layout(set = 0, binding = 1) uniform ANKI_RP texture2D u_toDenoiseTex;
 layout(set = 0, binding = 2) uniform texture2D u_depthTex;
 layout(set = 0, binding = 3) uniform ANKI_RP texture2D u_gbuffer2Tex;
+
+#if defined(ANKI_COMPUTE_SHADER)
+const UVec2 WORKGROUP_SIZE = UVec2(8u, 8u);
+layout(local_size_x = WORKGROUP_SIZE.x, local_size_y = WORKGROUP_SIZE.y) in;
+
 layout(set = 0, binding = 4) writeonly uniform ANKI_RP image2D u_outImg;
+#else
+layout(location = 0) in Vec2 in_uv;
+layout(location = 0) out Vec3 out_color;
+#endif
 
 layout(push_constant, std430, row_major) uniform b_pc
 {
@@ -35,18 +39,26 @@ Vec3 unproject(Vec2 ndc, F32 depth)
 
 void main()
 {
+#if defined(ANKI_COMPUTE_SHADER)
 	if(skipOutOfBoundsInvocations(WORKGROUP_SIZE, u_unis.m_viewportSize))
 	{
 		return;
 	}
 
 	const Vec2 uv = (Vec2(gl_GlobalInvocationID.xy) + 0.5) / u_unis.m_viewportSizef;
+#else
+	const Vec2 uv = in_uv;
+#endif
 
 	// Reference
 	const F32 depthCenter = textureLod(u_depthTex, u_linearAnyClampSampler, uv, 0.0).r;
 	if(depthCenter == 1.0)
 	{
+#if defined(ANKI_COMPUTE_SHADER)
 		imageStore(u_outImg, IVec2(gl_GlobalInvocationID.xy), Vec4(0.0));
+#else
+		out_color = Vec3(0.0);
+#endif
 		return;
 	}
 
@@ -81,9 +93,12 @@ void main()
 
 	// Normalize and store
 	color /= weight;
+
+#if defined(ANKI_COMPUTE_SHADER)
 	imageStore(u_outImg, IVec2(gl_GlobalInvocationID.xy), Vec4(color, 0.0));
 	// imageStore(u_outImg, IVec2(gl_GlobalInvocationID.xy), textureLod(u_toDenoiseTex, u_linearAnyClampSampler, uv,
 	// 0.0));
+#else
+	out_color = color;
+#endif
 }
-
-#pragma anki end

AnKi/Shaders/IndirectDiffuseDenoiseCompute.ankiprog

@@ -0,0 +1,8 @@
+// Copyright (C) 2009-2021, Panagiotis Christopoulos Charitos and contributors.
+// All rights reserved.
+// Code licensed under the BSD License.
+// http://www.anki3d.org/LICENSE
+
+#pragma anki start comp
+#include <AnKi/Shaders/IndirectDiffuseDenoise.glsl>
+#pragma anki end

AnKi/Shaders/IndirectDiffuseDenoiseRaster.ankiprog

@@ -0,0 +1,12 @@
+// Copyright (C) 2009-2021, Panagiotis Christopoulos Charitos and contributors.
+// All rights reserved.
+// Code licensed under the BSD License.
+// http://www.anki3d.org/LICENSE
+
+#pragma anki start vert
+#include <AnKi/Shaders/QuadVert.glsl>
+#pragma anki end
+
+#pragma anki start frag
+#include <AnKi/Shaders/IndirectDiffuseDenoise.glsl>
+#pragma anki end

AnKi/Shaders/IndirectDiffuseRaster.ankiprog

@@ -0,0 +1,12 @@
+// Copyright (C) 2009-2021, Panagiotis Christopoulos Charitos and contributors.
+// All rights reserved.
+// Code licensed under the BSD License.
+// http://www.anki3d.org/LICENSE
+
+#pragma anki start vert
+#include <AnKi/Shaders/QuadVert.glsl>
+#pragma anki end
+
+#pragma anki start frag
+#include <AnKi/Shaders/IndirectDiffuse.glsl>
+#pragma anki end