Fix bug in dependencies

AnKi/Gr/RenderGraph.cpp

@@ -41,6 +41,8 @@ class RenderGraph::Buffer
 public:
 	BufferUsageBit m_usage;
 	BufferPtr m_buffer; ///< Hold a reference.
+	PtrSize m_offset;
+	PtrSize m_range;
 };
 
 class RenderGraph::AS
@@ -724,6 +726,8 @@ RenderGraph::BakeContext* RenderGraph::newContext(const RenderGraphDescription&
 		ctx->m_buffers[buffIdx].m_usage = descr.m_buffers[buffIdx].m_usage;
 		ANKI_ASSERT(descr.m_buffers[buffIdx].m_importedBuff.isCreated());
 		ctx->m_buffers[buffIdx].m_buffer = descr.m_buffers[buffIdx].m_importedBuff;
+		ctx->m_buffers[buffIdx].m_offset = descr.m_buffers[buffIdx].m_offset;
+		ctx->m_buffers[buffIdx].m_range = descr.m_buffers[buffIdx].m_range;
 	}
 
 	// AS
@@ -1266,8 +1270,8 @@ void RenderGraph::run() const
 		}
 		for(const BufferBarrier& barrier : batch.m_bufferBarriersBefore)
 		{
-			cmdb->setBufferBarrier(m_ctx->m_buffers[barrier.m_idx].m_buffer, barrier.m_usageBefore,
-								   barrier.m_usageAfter, 0, MAX_PTR_SIZE);
+			const Buffer& b = m_ctx->m_buffers[barrier.m_idx];
+			cmdb->setBufferBarrier(b.m_buffer, barrier.m_usageBefore, barrier.m_usageAfter, b.m_offset, b.m_range);
 		}
 		for(const ASBarrier& barrier : batch.m_asBarriersBefore)
 		{
@@ -1682,8 +1686,8 @@ Error RenderGraph::dumpDependencyDotFile(const RenderGraphDescription& descr, co
 	slist.pushBackSprintf("}");
 
 	File file;
-	ANKI_CHECK(
-		file.open(StringAuto(alloc).sprintf("%s/rgraph_%u.dot", &path[0], m_version).toCString(), FileOpenFlag::WRITE));
+	ANKI_CHECK(file.open(StringAuto(alloc).sprintf("%s/rgraph_%05u.dot", &path[0], m_version).toCString(),
+						 FileOpenFlag::WRITE));
 	for(const String& s : slist)
 	{
 		ANKI_CHECK(file.writeText("%s", &s[0]));

AnKi/Gr/RenderGraph.h

@@ -511,7 +511,7 @@ public:
 	RenderTargetHandle newRenderTarget(const RenderTargetDescription& initInf);
 
 	/// Import a buffer.
-	BufferHandle importBuffer(BufferPtr buff, BufferUsageBit usage);
+	BufferHandle importBuffer(BufferPtr buff, BufferUsageBit usage, PtrSize offset = 0, PtrSize range = MAX_PTR_SIZE);
 
 	/// Import an AS.
 	AccelerationStructureHandle importAccelerationStructure(AccelerationStructurePtr as,
@@ -554,6 +554,8 @@ private:
 	public:
 		BufferUsageBit m_usage;
 		BufferPtr m_importedBuff;
+		PtrSize m_offset;
+		PtrSize m_range;
 	};
 
 	class AS : public Resource
@@ -569,6 +571,24 @@ private:
 	DynamicArray<Buffer> m_buffers;
 	DynamicArray<AS> m_as;
 	Bool m_gatherStatistics = false;
+
+	/// Return true if 2 buffer ranges overlap.
+	static Bool bufferRangeOverlaps(PtrSize offsetA, PtrSize rangeA, PtrSize offsetB, PtrSize rangeB)
+	{
+		ANKI_ASSERT(rangeA > 0 && rangeB > 0);
+		if(rangeA == MAX_PTR_SIZE || rangeB == MAX_PTR_SIZE)
+		{
+			return true;
+		}
+		else if(offsetA <= offsetB)
+		{
+			return offsetA + rangeA >= offsetB;
+		}
+		else
+		{
+			return offsetB + rangeB >= offsetA;
+		}
+	}
 };
 
 /// Statistics.

AnKi/Gr/RenderGraph.inl.h

@@ -279,18 +279,32 @@ inline RenderTargetHandle RenderGraphDescription::newRenderTarget(const RenderTa
 	return out;
 }
 
-inline BufferHandle RenderGraphDescription::importBuffer(BufferPtr buff, BufferUsageBit usage)
+inline BufferHandle RenderGraphDescription::importBuffer(BufferPtr buff, BufferUsageBit usage, PtrSize offset,
+														 PtrSize range)
 {
+	// Checks
+	if(range == MAX_PTR_SIZE)
+	{
+		ANKI_ASSERT(offset < buff->getSize());
+	}
+	else
+	{
+		ANKI_ASSERT((offset + range) <= buff->getSize());
+	}
+
 	for(const Buffer& bb : m_buffers)
 	{
 		(void)bb;
-		ANKI_ASSERT(bb.m_importedBuff != buff && "Already imported");
+		ANKI_ASSERT((bb.m_importedBuff != buff || !bufferRangeOverlaps(bb.m_offset, bb.m_range, offset, range))
+					&& "Range already imported");
 	}
 
 	Buffer& b = *m_buffers.emplaceBack(m_alloc);
 	b.setName(buff->getName());
 	b.m_usage = usage;
 	b.m_importedBuff = buff;
+	b.m_offset = offset;
+	b.m_range = range;
 
 	BufferHandle out;
 	out.m_idx = m_buffers.getSize() - 1;

AnKi/Renderer/ClusterBinning.cpp

@@ -53,6 +53,12 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 {
 	m_runCtx.m_ctx = &ctx;
 
+	writeClustererBuffers(ctx);
+
+	ctx.m_clusteredShading.m_clustersBufferHandle = ctx.m_renderGraphDescr.importBuffer(
+		ctx.m_clusteredShading.m_clustersToken.m_buffer, BufferUsageBit::NONE,
+		ctx.m_clusteredShading.m_clustersToken.m_offset, ctx.m_clusteredShading.m_clustersToken.m_range);
+
 	const RenderQueue& rqueue = *m_runCtx.m_ctx->m_renderQueue;
 	if(ANKI_LIKELY(rqueue.m_pointLights.getSize() || rqueue.m_spotLights.getSize() || rqueue.m_decals.getSize()
 				   || rqueue.m_reflectionProbes.getSize() || rqueue.m_fogDensityVolumes.getSize()
@@ -66,9 +72,10 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 				static_cast<ClusterBinning*>(rgraphCtx.m_userData)->run(rgraphCtx);
 			},
 			this, 0);
-	}
 
-	writeClustererBuffers(ctx);
+		pass.newDependency(
+			RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::STORAGE_COMPUTE_WRITE));
+	}
 }
 
 void ClusterBinning::run(RenderPassWorkContext& rgraphCtx)

AnKi/Renderer/Common.h

@@ -136,6 +136,8 @@ public:
 	StagingGpuMemoryToken m_clustersToken;
 	void* m_clustersAddress = nullptr;
 
+	BufferHandle m_clustersBufferHandle; ///< To track dependencies. Don't track all tokens, not worth it.
+
 	TextureViewPtr m_diffuseDecalTextureView;
 	TextureViewPtr m_specularRoughnessDecalTextureView;
 };

AnKi/Renderer/GBufferPost.cpp

@@ -65,10 +65,14 @@ void GBufferPost::populateRenderGraph(RenderingContext& ctx)
 
 	rpass.setFramebufferInfo(m_fbDescr, {m_r->getGBuffer().getColorRt(0), m_r->getGBuffer().getColorRt(1)}, {});
 
-	rpass.newDependency({m_r->getGBuffer().getColorRt(0), TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT});
-	rpass.newDependency({m_r->getGBuffer().getColorRt(1), TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT});
-	rpass.newDependency({m_r->getGBuffer().getDepthRt(), TextureUsageBit::SAMPLED_FRAGMENT,
-						 TextureSubresourceInfo(DepthStencilAspectBit::DEPTH)});
+	rpass.newDependency(
+		RenderPassDependency(m_r->getGBuffer().getColorRt(0), TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT));
+	rpass.newDependency(
+		RenderPassDependency(m_r->getGBuffer().getColorRt(1), TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT));
+	rpass.newDependency(RenderPassDependency(m_r->getGBuffer().getDepthRt(), TextureUsageBit::SAMPLED_FRAGMENT,
+											 TextureSubresourceInfo(DepthStencilAspectBit::DEPTH)));
+	rpass.newDependency(
+		RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::STORAGE_FRAGMENT_READ));
 }
 
 void GBufferPost::run(RenderPassWorkContext& rgraphCtx)

AnKi/Renderer/LightShading.cpp

@@ -212,33 +212,39 @@ void LightShading::populateRenderGraph(RenderingContext& ctx)
 	pass.setFramebufferInfo(m_lightShading.m_fbDescr, {{m_runCtx.m_rt}}, {m_r->getGBuffer().getDepthRt()});
 
 	// Light shading
-	pass.newDependency({m_runCtx.m_rt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
-	pass.newDependency({m_r->getGBuffer().getColorRt(0), TextureUsageBit::SAMPLED_FRAGMENT});
-	pass.newDependency({m_r->getGBuffer().getColorRt(1), TextureUsageBit::SAMPLED_FRAGMENT});
-	pass.newDependency({m_r->getGBuffer().getColorRt(2), TextureUsageBit::SAMPLED_FRAGMENT});
-	pass.newDependency({m_r->getGBuffer().getDepthRt(),
-						TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ,
-						TextureSubresourceInfo(DepthStencilAspectBit::DEPTH)});
-	pass.newDependency({m_r->getShadowMapping().getShadowmapRt(), TextureUsageBit::SAMPLED_FRAGMENT});
-	pass.newDependency({m_r->getSsao().getRt(), TextureUsageBit::SAMPLED_FRAGMENT});
-	pass.newDependency({m_r->getSsgi().getRt(), TextureUsageBit::SAMPLED_FRAGMENT});
+	pass.newDependency(RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE));
+	pass.newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(0), TextureUsageBit::SAMPLED_FRAGMENT));
+	pass.newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(1), TextureUsageBit::SAMPLED_FRAGMENT));
+	pass.newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(2), TextureUsageBit::SAMPLED_FRAGMENT));
+	pass.newDependency(
+		RenderPassDependency(m_r->getGBuffer().getDepthRt(),
+							 TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ,
+							 TextureSubresourceInfo(DepthStencilAspectBit::DEPTH)));
+	pass.newDependency(
+		RenderPassDependency(m_r->getShadowMapping().getShadowmapRt(), TextureUsageBit::SAMPLED_FRAGMENT));
+	pass.newDependency(RenderPassDependency(m_r->getSsao().getRt(), TextureUsageBit::SAMPLED_FRAGMENT));
+	pass.newDependency(RenderPassDependency(m_r->getSsgi().getRt(), TextureUsageBit::SAMPLED_FRAGMENT));
 	if(m_r->getRtShadowsEnabled())
 	{
-		pass.newDependency({m_r->getRtShadows().getRt(), TextureUsageBit::SAMPLED_FRAGMENT});
+		pass.newDependency(RenderPassDependency(m_r->getRtShadows().getRt(), TextureUsageBit::SAMPLED_FRAGMENT));
 	}
 	else
 	{
-		pass.newDependency({m_r->getShadowmapsResolve().getRt(), TextureUsageBit::SAMPLED_FRAGMENT});
+		pass.newDependency(
+			RenderPassDependency(m_r->getShadowmapsResolve().getRt(), TextureUsageBit::SAMPLED_FRAGMENT));
 	}
+	pass.newDependency(
+		RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::STORAGE_FRAGMENT_READ));
 
 	// Refl & indirect
-	pass.newDependency({m_r->getSsr().getRt(), TextureUsageBit::SAMPLED_FRAGMENT});
-	pass.newDependency({m_r->getProbeReflections().getReflectionRt(), TextureUsageBit::SAMPLED_FRAGMENT});
+	pass.newDependency(RenderPassDependency(m_r->getSsr().getRt(), TextureUsageBit::SAMPLED_FRAGMENT));
+	pass.newDependency(
+		RenderPassDependency(m_r->getProbeReflections().getReflectionRt(), TextureUsageBit::SAMPLED_FRAGMENT));
 
 	m_r->getGlobalIllumination().setRenderGraphDependencies(ctx, pass, TextureUsageBit::SAMPLED_FRAGMENT);
 
 	// Fog
-	pass.newDependency({m_r->getVolumetricFog().getRt(), TextureUsageBit::SAMPLED_FRAGMENT});
+	pass.newDependency(RenderPassDependency(m_r->getVolumetricFog().getRt(), TextureUsageBit::SAMPLED_FRAGMENT));
 
 	// For forward shading
 	m_r->getForwardShading().setDependencies(ctx, pass);

AnKi/Renderer/RtShadows.cpp

@@ -280,6 +280,9 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 		rpass.newDependency(RenderPassDependency(m_runCtx.m_prevHistoryLengthRt, TextureUsageBit::SAMPLED_TRACE_RAYS));
 		rpass.newDependency(
 			RenderPassDependency(m_runCtx.m_currentHistoryLengthRt, TextureUsageBit::IMAGE_TRACE_RAYS_WRITE));
+
+		rpass.newDependency(RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle,
+												 BufferUsageBit::STORAGE_TRACE_RAYS_READ));
 	}
 
 	// Denoise pass horizontal

AnKi/Renderer/ShadowmapsResolve.cpp

@@ -62,9 +62,13 @@ void ShadowmapsResolve::populateRenderGraph(RenderingContext& ctx)
 		[](RenderPassWorkContext& rgraphCtx) { static_cast<ShadowmapsResolve*>(rgraphCtx.m_userData)->run(rgraphCtx); },
 		this, 0);
 
-	rpass.newDependency({m_runCtx.m_rt, TextureUsageBit::IMAGE_COMPUTE_WRITE});
-	rpass.newDependency({m_r->getGBuffer().getDepthRt(), TextureUsageBit::SAMPLED_COMPUTE});
-	rpass.newDependency({m_r->getShadowMapping().getShadowmapRt(), TextureUsageBit::SAMPLED_COMPUTE});
+	rpass.newDependency(RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::IMAGE_COMPUTE_WRITE));
+	rpass.newDependency(RenderPassDependency(m_r->getGBuffer().getDepthRt(), TextureUsageBit::SAMPLED_COMPUTE));
+	rpass.newDependency(
+		RenderPassDependency(m_r->getShadowMapping().getShadowmapRt(), TextureUsageBit::SAMPLED_COMPUTE));
+
+	rpass.newDependency(
+		RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::STORAGE_COMPUTE_READ));
 }
 
 void ShadowmapsResolve::run(RenderPassWorkContext& rgraphCtx)

AnKi/Renderer/VolumetricLightingAccumulation.cpp

@@ -91,9 +91,13 @@ void VolumetricLightingAccumulation::populateRenderGraph(RenderingContext& ctx)
 	};
 	pass.setWork(callback, this, 0);
 
-	pass.newDependency({m_runCtx.m_rts[0], TextureUsageBit::SAMPLED_COMPUTE});
-	pass.newDependency({m_runCtx.m_rts[1], TextureUsageBit::IMAGE_COMPUTE_WRITE});
-	pass.newDependency({m_r->getShadowMapping().getShadowmapRt(), TextureUsageBit::SAMPLED_COMPUTE});
+	pass.newDependency(RenderPassDependency(m_runCtx.m_rts[0], TextureUsageBit::SAMPLED_COMPUTE));
+	pass.newDependency(RenderPassDependency(m_runCtx.m_rts[1], TextureUsageBit::IMAGE_COMPUTE_WRITE));
+	pass.newDependency(
+		RenderPassDependency(m_r->getShadowMapping().getShadowmapRt(), TextureUsageBit::SAMPLED_COMPUTE));
+
+	pass.newDependency(
+		RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::STORAGE_COMPUTE_READ));
 
 	m_r->getGlobalIllumination().setRenderGraphDependencies(ctx, pass, TextureUsageBit::SAMPLED_COMPUTE);
 }