Try to fix CI. Add VS natvis for some AnKi structures. More work on the new barrier interface

.github/workflows/Linux.yml

@@ -39,7 +39,7 @@ jobs:
       run: cmake -B ${{github.workspace}}/build -DANKI_BUILD_TESTS=ON -DCMAKE_CXX_COMPILER=g++ -DCMAKE_C_COMPILER=gcc -DCMAKE_BUILD_TYPE=Release -DANKI_EXTRA_CHECKS=OFF
 
     - name: Build
-      run: cmake --build ${{github.workspace}}/build --config Release --parallel
+      run: cmake --build ${{github.workspace}}/build --config Release
 
 
   Debug_Clang:
@@ -57,7 +57,7 @@ jobs:
       run: cmake -B ${{github.workspace}}/build -DANKI_BUILD_TESTS=ON -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_C_COMPILER=clang -DCMAKE_BUILD_TYPE=Debug -DANKI_EXTRA_CHECKS=ON
 
     - name: Build
-      run: cmake --build ${{github.workspace}}/build --config Debug --parallel
+      run: cmake --build ${{github.workspace}}/build --config Debug
 
   Release_Clang:
     name: "Clang Release"
@@ -74,7 +74,7 @@ jobs:
       run: cmake -B ${{github.workspace}}/build -DANKI_BUILD_TESTS=ON -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_C_COMPILER=clang -DCMAKE_BUILD_TYPE=Release -DANKI_EXTRA_CHECKS=OFF
 
     - name: Build
-      run: cmake --build ${{github.workspace}}/build --config Release --parallel
+      run: cmake --build ${{github.workspace}}/build --config Release
 
   Headless:
     name: "Headless"
@@ -91,7 +91,7 @@ jobs:
       run: cmake -B ${{github.workspace}}/build -DANKI_BUILD_TESTS=OFF -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_C_COMPILER=clang -DCMAKE_BUILD_TYPE=Release -DANKI_EXTRA_CHECKS=ON -DANKI_HEADLESS=ON
 
     - name: Build
-      run: cmake --build ${{github.workspace}}/build --config Release --parallel
+      run: cmake --build ${{github.workspace}}/build --config Release
 
   DLSS:
     name: "DLSS"
@@ -108,4 +108,4 @@ jobs:
       run: cmake -B ${{github.workspace}}/build -DANKI_BUILD_TESTS=OFF -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_C_COMPILER=clang -DCMAKE_BUILD_TYPE=Release -DANKI_EXTRA_CHECKS=ON -DANKI_DLSS=ON
 
     - name: Build
-      run: cmake --build ${{github.workspace}}/build --config Release --target Sponza --parallel
+      run: cmake --build ${{github.workspace}}/build --config Release --target Sponza

.github/workflows/Windows.yml

@@ -19,7 +19,7 @@ jobs:
       run: cmake -B ${{github.workspace}}/build -DANKI_BUILD_TESTS=ON -DCMAKE_BUILD_TYPE=Debug -DANKI_EXTRA_CHECKS=ON
 
     - name: Build
-      run: cmake --build ${{github.workspace}}/build --config Debug --parallel
+      run: cmake --build ${{github.workspace}}/build --config Debug
 
   Release:
     name: "Release"
@@ -33,7 +33,7 @@ jobs:
       run: cmake -B ${{github.workspace}}/build -DANKI_BUILD_TESTS=ON -DCMAKE_BUILD_TYPE=Release -DANKI_EXTRA_CHECKS=OFF
 
     - name: Build
-      run: cmake --build ${{github.workspace}}/build --config Release --parallel
+      run: cmake --build ${{github.workspace}}/build --config Release
 
   DLSS:
     name: "DLSS"
@@ -47,4 +47,4 @@ jobs:
       run: cmake -B ${{github.workspace}}/build -DANKI_BUILD_TESTS=OFF -DCMAKE_BUILD_TYPE=Release -DANKI_EXTRA_CHECKS=OFF -DANKI_DLSS=ON
 
     - name: Build
-      run: cmake --build ${{github.workspace}}/build --config Release --target Sponza --parallel
+      run: cmake --build ${{github.workspace}}/build --config Release --target Sponza

AnKi.natvis

@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="utf-8"?>
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+
+	<Type Name="anki::ConstWeakArray&lt;*&gt;">
+		<Intrinsic Name="size" Expression="m_size" />
+		<DisplayString>{{ size={m_size} }}</DisplayString>
+		<Expand>
+			<ArrayItems>
+				<Size>m_size</Size>
+				<ValuePointer>m_data</ValuePointer>
+			</ArrayItems>
+		</Expand>
+	</Type>
+
+	<Type Name="anki::WeakArray&lt;*&gt;">
+		<Intrinsic Name="size" Expression="m_size" />
+		<DisplayString>{{ size={m_size} }}</DisplayString>
+		<Expand>
+			<ArrayItems>
+				<Size>m_size</Size>
+				<ValuePointer>m_data</ValuePointer>
+			</ArrayItems>
+		</Expand>
+	</Type>
+
+	<Type Name="anki::DynamicArray&lt;*&gt;">
+		<Intrinsic Name="size" Expression="m_size" />
+		<DisplayString>{{ size={m_size} capacity={m_capacity} }}</DisplayString>
+		<Expand>
+			<ArrayItems>
+				<Size>m_size</Size>
+				<ValuePointer>m_data</ValuePointer>
+			</ArrayItems>
+		</Expand>
+	</Type>
+
+	<Type Name="anki::DynamicArrayRaii&lt;*&gt;">
+		<Intrinsic Name="size" Expression="m_size" />
+		<DisplayString>{{ size={m_size} capacity={m_capacity} }}</DisplayString>
+		<Expand>
+			<ArrayItems>
+				<Size>m_size</Size>
+				<ValuePointer>m_data</ValuePointer>
+			</ArrayItems>
+		</Expand>
+	</Type>
+
+</AutoVisualizer>

AnKi/Gr/RenderGraph.cpp

@@ -59,12 +59,15 @@ public:
 	TextureUsageBit m_usageBefore;
 	TextureUsageBit m_usageAfter;
 	TextureSurfaceInfo m_surface;
+	DepthStencilAspectBit m_dsAspect;
 
-	TextureBarrier(U32 rtIdx, TextureUsageBit usageBefore, TextureUsageBit usageAfter, const TextureSurfaceInfo& surf)
+	TextureBarrier(U32 rtIdx, TextureUsageBit usageBefore, TextureUsageBit usageAfter, const TextureSurfaceInfo& surf,
+				   DepthStencilAspectBit dsAspect)
 		: m_idx(rtIdx)
 		, m_usageBefore(usageBefore)
 		, m_usageAfter(usageAfter)
 		, m_surface(surf)
+		, m_dsAspect(dsAspect)
 	{
 	}
 };
@@ -1036,7 +1039,8 @@ void RenderGraph::setTextureBarrier(Batch& batch, const RenderPassDependency& de
 				{
 					// Create a new barrier for this surface
 
-					batch.m_textureBarriersBefore.emplaceBack(*ctx.m_pool, rtIdx, crntUsage, depUsage, surf);
+					batch.m_textureBarriersBefore.emplaceBack(*ctx.m_pool, rtIdx, crntUsage, depUsage, surf,
+															  dep.m_texture.m_subresource.m_depthStencilAspect);
 
 					crntUsage = depUsage;
 					rt.m_lastBatchThatTransitionedIt[surfOrVolIdx] = U16(batchIdx);
@@ -1297,6 +1301,39 @@ void RenderGraph::run() const
 		CommandBufferPtr& cmdb = ctx.m_commandBuffer;
 
 		// Set the barriers
+#if 1
+		DynamicArrayRaii<TextureBarrierInfo> texBarriers(m_ctx->m_pool);
+		texBarriers.resizeStorage(batch.m_textureBarriersBefore.getSize());
+		for(const TextureBarrier& barrier : batch.m_textureBarriersBefore)
+		{
+			TextureBarrierInfo& inf = *texBarriers.emplaceBack();
+			inf.m_previousUsage = barrier.m_usageBefore;
+			inf.m_nextUsage = barrier.m_usageAfter;
+			inf.m_subresource = barrier.m_surface;
+			inf.m_subresource.m_depthStencilAspect = barrier.m_dsAspect;
+			inf.m_texture = m_ctx->m_rts[barrier.m_idx].m_texture.get();
+		}
+		DynamicArrayRaii<BufferBarrierInfo> buffBarriers(m_ctx->m_pool);
+		buffBarriers.resizeStorage(batch.m_bufferBarriersBefore.getSize());
+		for(const BufferBarrier& barrier : batch.m_bufferBarriersBefore)
+		{
+			BufferBarrierInfo& inf = *buffBarriers.emplaceBack();
+			inf.m_previousUsage = barrier.m_usageBefore;
+			inf.m_nextUsage = barrier.m_usageAfter;
+			inf.m_offset = m_ctx->m_buffers[barrier.m_idx].m_offset;
+			inf.m_size = m_ctx->m_buffers[barrier.m_idx].m_range;
+			inf.m_buffer = m_ctx->m_buffers[barrier.m_idx].m_buffer.get();
+		}
+		DynamicArrayRaii<AccelerationStructureBarrierInfo> asBarriers(m_ctx->m_pool);
+		for(const ASBarrier& barrier : batch.m_asBarriersBefore)
+		{
+			AccelerationStructureBarrierInfo& inf = *asBarriers.emplaceBack();
+			inf.m_previousUsage = barrier.m_usageBefore;
+			inf.m_nextUsage = barrier.m_usageAfter;
+			inf.m_as = m_ctx->m_as[barrier.m_idx].m_as.get();
+		}
+		cmdb->setPipelineBarrier(texBarriers, buffBarriers, asBarriers);
+#else
 		for(const TextureBarrier& barrier : batch.m_textureBarriersBefore)
 		{
 			cmdb->setTextureSurfaceBarrier(m_ctx->m_rts[barrier.m_idx].m_texture, barrier.m_usageBefore,
@@ -1312,6 +1349,7 @@ void RenderGraph::run() const
 			cmdb->setAccelerationStructureBarrier(m_ctx->m_as[barrier.m_idx].m_as, barrier.m_usageBefore,
 												  barrier.m_usageAfter);
 		}
+#endif
 
 		// Call the passes
 		for(U32 passIdx : batch.m_passIndices)

AnKi/Gr/RenderGraph.h

@@ -342,8 +342,27 @@ public:
 		setWork(0, func);
 	}
 
-	/// Add a new consumer or producer dependency.
-	void newDependency(const RenderPassDependency& dep);
+	void newTextureDependency(RenderTargetHandle handle, TextureUsageBit usage,
+							  const TextureSubresourceInfo& subresource)
+	{
+		newDependency<RenderPassDependency::Type::kTexture>(RenderPassDependency(handle, usage, subresource));
+	}
+
+	void newTextureDependency(RenderTargetHandle handle, TextureUsageBit usage,
+							  DepthStencilAspectBit aspect = DepthStencilAspectBit::kNone)
+	{
+		newDependency<RenderPassDependency::Type::kTexture>(RenderPassDependency(handle, usage, aspect));
+	}
+
+	void newBufferDependency(BufferHandle handle, BufferUsageBit usage)
+	{
+		newDependency<RenderPassDependency::Type::kBuffer>(RenderPassDependency(handle, usage));
+	}
+
+	void newAccelerationStructureDependency(AccelerationStructureHandle handle, AccelerationStructureUsageBit usage)
+	{
+		newDependency<RenderPassDependency::Type::kAccelerationStructure>(RenderPassDependency(handle, usage));
+	}
 
 protected:
 	enum class Type : U8
@@ -388,6 +407,10 @@ protected:
 	void fixSubresource(RenderPassDependency& dep) const;
 
 	void validateDep(const RenderPassDependency& dep);
+
+	/// Add a new consumer or producer dependency.
+	template<RenderPassDependency::Type kType>
+	void newDependency(const RenderPassDependency& dep);
 };
 
 /// Framebuffer attachment info.

AnKi/Gr/RenderGraph.inl.h

@@ -58,6 +58,19 @@ inline void RenderPassDescriptionBase::fixSubresource(RenderPassDependency& dep)
 		}
 	}
 
+	if(subresource.m_depthStencilAspect == DepthStencilAspectBit::kNone)
+	{
+		const Bool imported = rt.m_importedTex.isCreated();
+		if(imported)
+		{
+			subresource.m_depthStencilAspect = rt.m_importedTex->getDepthStencilAspect();
+		}
+		else if(!imported && getFormatInfo(rt.m_initInfo.m_format).isDepthStencil())
+		{
+			subresource.m_depthStencilAspect = getFormatInfo(rt.m_initInfo.m_format).m_depthStencil;
+		}
+	}
+
 	ANKI_ASSERT(dep.m_texture.m_subresource.m_firstMipmap + dep.m_texture.m_subresource.m_mipmapCount
 				<= ((rt.m_importedTex) ? rt.m_importedTex->getMipmapCount() : rt.m_initInfo.m_mipmapCount));
 }
@@ -107,11 +120,13 @@ inline void RenderPassDescriptionBase::validateDep(const RenderPassDependency& d
 	}
 }
 
+template<RenderPassDependency::Type kType>
 inline void RenderPassDescriptionBase::newDependency(const RenderPassDependency& dep)
 {
+	ANKI_ASSERT(kType == dep.m_type);
 	validateDep(dep);
 
-	if(dep.m_type == RenderPassDependency::Type::kTexture)
+	if(kType == RenderPassDependency::Type::kTexture)
 	{
 		m_rtDeps.emplaceBack(*m_pool, dep);
 		fixSubresource(m_rtDeps.getBack());
@@ -128,8 +143,19 @@ inline void RenderPassDescriptionBase::newDependency(const RenderPassDependency&
 
 		// Try to derive the usage by that dep
 		m_descr->m_renderTargets[dep.m_texture.m_handle.m_idx].m_usageDerivedByDeps |= dep.m_texture.m_usage;
+
+		// Checks
+#if ANKI_ENABLE_ASSERTIONS
+		const RenderGraphDescription::RT& rt = m_descr->m_renderTargets[dep.m_texture.m_handle.m_idx];
+		if((!rt.m_importedTex.isCreated() && !!getFormatInfo(rt.m_initInfo.m_format).m_depthStencil)
+		   || (rt.m_importedTex.isCreated() && !!rt.m_importedTex->getDepthStencilAspect()))
+		{
+			ANKI_ASSERT(!!m_rtDeps.getBack().m_texture.m_subresource.m_depthStencilAspect
+						&& "Dependencies of depth/stencil resources should have a valid DS aspect");
+		}
+#endif
 	}
-	else if(dep.m_type == RenderPassDependency::Type::kBuffer)
+	else if(kType == RenderPassDependency::Type::kBuffer)
 	{
 		m_buffDeps.emplaceBack(*m_pool, dep);
 
@@ -145,7 +171,7 @@ inline void RenderPassDescriptionBase::newDependency(const RenderPassDependency&
 	}
 	else
 	{
-		ANKI_ASSERT(dep.m_type == RenderPassDependency::Type::kAccelerationStructure);
+		ANKI_ASSERT(kType == RenderPassDependency::Type::kAccelerationStructure);
 		m_asDeps.emplaceBack(*m_pool, dep);
 
 		if(!!(dep.m_as.m_usage & AccelerationStructureUsageBit::kAllRead))

AnKi/Gr/Vulkan/CommandBufferImpl.cpp

@@ -926,9 +926,7 @@ void CommandBufferImpl::setPipelineBarrierInternal(
 			// The transition of the non zero mip levels happens inside CommandBufferImpl::generateMipmapsX so limit the
 			// subresource
 
-			ANKI_ASSERT(impl.isSubresourceGoodForMipmapGeneration(subresource));
-			subresource.m_firstMipmap = 0;
-			subresource.m_mipmapCount = 1;
+			ANKI_ASSERT(subresource.m_firstMipmap == 0 && subresource.m_mipmapCount == 1);
 		}
 
 		VkImageMemoryBarrier& inf = *imageBarriers.emplaceBack();

AnKi/Renderer/AccelerationStructureBuilder.cpp

@@ -61,7 +61,7 @@ void AccelerationStructureBuilder::populateRenderGraph(RenderingContext& ctx)
 		rgraphCtx.m_commandBuffer->buildAccelerationStructure(m_runCtx.m_tlas);
 	});
 
-	rpass.newDependency(RenderPassDependency(m_runCtx.m_tlasHandle, AccelerationStructureUsageBit::kBuild));
+	rpass.newAccelerationStructureDependency(m_runCtx.m_tlasHandle, AccelerationStructureUsageBit::kBuild);
 }
 
 } // end namespace anki

AnKi/Renderer/Bloom.cpp

@@ -114,9 +114,9 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 		{
 			ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("Bloom Main");
 
-			rpass.newDependency(RenderPassDependency(m_r->getDownscaleBlur().getRt(), TextureUsageBit::kSampledCompute,
-													 inputTexSubresource));
-			rpass.newDependency(RenderPassDependency(m_runCtx.m_exposureRt, TextureUsageBit::kImageComputeWrite));
+			rpass.newTextureDependency(m_r->getDownscaleBlur().getRt(), TextureUsageBit::kSampledCompute,
+									   inputTexSubresource);
+			rpass.newTextureDependency(m_runCtx.m_exposureRt, TextureUsageBit::kImageComputeWrite);
 
 			prpass = &rpass;
 		}
@@ -125,9 +125,9 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 			GraphicsRenderPassDescription& rpass = rgraph.newGraphicsRenderPass("Bloom Main");
 			rpass.setFramebufferInfo(m_fbDescr, {m_runCtx.m_exposureRt});
 
-			rpass.newDependency(RenderPassDependency(m_r->getDownscaleBlur().getRt(), TextureUsageBit::kSampledFragment,
-													 inputTexSubresource));
-			rpass.newDependency(RenderPassDependency(m_runCtx.m_exposureRt, TextureUsageBit::kFramebufferWrite));
+			rpass.newTextureDependency(m_r->getDownscaleBlur().getRt(), TextureUsageBit::kSampledFragment,
+									   inputTexSubresource);
+			rpass.newTextureDependency(m_runCtx.m_exposureRt, TextureUsageBit::kFramebufferWrite);
 
 			prpass = &rpass;
 		}
@@ -175,8 +175,8 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 		{
 			ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("Bloom Upscale");
 
-			rpass.newDependency({m_runCtx.m_exposureRt, TextureUsageBit::kSampledCompute});
-			rpass.newDependency({m_runCtx.m_upscaleRt, TextureUsageBit::kImageComputeWrite});
+			rpass.newTextureDependency(m_runCtx.m_exposureRt, TextureUsageBit::kSampledCompute);
+			rpass.newTextureDependency(m_runCtx.m_upscaleRt, TextureUsageBit::kImageComputeWrite);
 
 			prpass = &rpass;
 		}
@@ -185,8 +185,8 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 			GraphicsRenderPassDescription& rpass = rgraph.newGraphicsRenderPass("Bloom Upscale");
 			rpass.setFramebufferInfo(m_fbDescr, {m_runCtx.m_upscaleRt});
 
-			rpass.newDependency({m_runCtx.m_exposureRt, TextureUsageBit::kSampledFragment});
-			rpass.newDependency({m_runCtx.m_upscaleRt, TextureUsageBit::kFramebufferWrite});
+			rpass.newTextureDependency(m_runCtx.m_exposureRt, TextureUsageBit::kSampledFragment);
+			rpass.newTextureDependency(m_runCtx.m_upscaleRt, TextureUsageBit::kFramebufferWrite);
 
 			prpass = &rpass;
 		}

AnKi/Renderer/ClusterBinning.cpp

@@ -67,8 +67,7 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 		RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("Cluster Binning");
 
-		pass.newDependency(
-			RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::kStorageComputeWrite));
+		pass.newBufferDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::kStorageComputeWrite);
 
 		pass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
 			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;

AnKi/Renderer/Dbg.cpp

@@ -181,9 +181,9 @@ void Dbg::populateRenderGraph(RenderingContext& ctx)
 
 	pass.setFramebufferInfo(m_fbDescr, {m_runCtx.m_rt}, m_r->getGBuffer().getDepthRt());
 
-	pass.newDependency({m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite});
-	pass.newDependency(
-		{m_r->getGBuffer().getDepthRt(), TextureUsageBit::kSampledFragment | TextureUsageBit::kFramebufferRead});
+	pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite);
+	pass.newTextureDependency(m_r->getGBuffer().getDepthRt(),
+							  TextureUsageBit::kSampledFragment | TextureUsageBit::kFramebufferRead);
 }
 
 } // end namespace anki

AnKi/Renderer/DepthDownscale.cpp

@@ -188,15 +188,14 @@ void DepthDownscale::populateRenderGraph(RenderingContext& ctx)
 
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("HiZ");
 
-		pass.newDependency(RenderPassDependency(m_r->getGBuffer().getDepthRt(), TextureUsageBit::kSampledCompute,
-												TextureSubresourceInfo(DepthStencilAspectBit::kDepth)));
+		pass.newTextureDependency(m_r->getGBuffer().getDepthRt(), TextureUsageBit::kSampledCompute,
+								  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
 		for(U32 mip = 0; mip < m_mipCount; ++mip)
 		{
 			TextureSubresourceInfo subresource;
 			subresource.m_firstMipmap = mip;
-			pass.newDependency(
-				RenderPassDependency(m_runCtx.m_hizRt, TextureUsageBit::kImageComputeWrite, subresource));
+			pass.newTextureDependency(m_runCtx.m_hizRt, TextureUsageBit::kImageComputeWrite, subresource);
 		}
 
 		pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
@@ -216,21 +215,19 @@ void DepthDownscale::populateRenderGraph(RenderingContext& ctx)
 
 			if(mip == 0)
 			{
-				pass.newDependency(RenderPassDependency(m_r->getGBuffer().getDepthRt(),
-														TextureUsageBit::kSampledFragment,
-														TextureSubresourceInfo(DepthStencilAspectBit::kDepth)));
+				pass.newTextureDependency(m_r->getGBuffer().getDepthRt(), TextureUsageBit::kSampledFragment,
+										  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 			}
 			else
 			{
 				TextureSurfaceInfo subresource;
 				subresource.m_level = mip - 1;
-				pass.newDependency(
-					RenderPassDependency(m_runCtx.m_hizRt, TextureUsageBit::kSampledFragment, subresource));
+				pass.newTextureDependency(m_runCtx.m_hizRt, TextureUsageBit::kSampledFragment, subresource);
 			}
 
 			TextureSurfaceInfo subresource;
 			subresource.m_level = mip;
-			pass.newDependency(RenderPassDependency(m_runCtx.m_hizRt, TextureUsageBit::kFramebufferWrite, subresource));
+			pass.newTextureDependency(m_runCtx.m_hizRt, TextureUsageBit::kFramebufferWrite, subresource);
 
 			pass.setWork([this, mip](RenderPassWorkContext& rgraphCtx) {
 				runGraphics(mip, rgraphCtx);

AnKi/Renderer/DownscaleBlur.cpp

@@ -108,18 +108,15 @@ void DownscaleBlur::populateRenderGraph(RenderingContext& ctx)
 				sampleSubresource.m_firstMipmap = i - 1;
 				renderSubresource.m_firstMipmap = i;
 
-				pass.newDependency(
-					RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::kImageComputeWrite, renderSubresource));
-				pass.newDependency(
-					RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::kSampledCompute, sampleSubresource));
+				pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kImageComputeWrite, renderSubresource);
+				pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kSampledCompute, sampleSubresource);
 			}
 			else
 			{
 				TextureSubresourceInfo renderSubresource;
 
-				pass.newDependency(
-					RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::kImageComputeWrite, renderSubresource));
-				pass.newDependency(RenderPassDependency(inRt, TextureUsageBit::kSampledCompute));
+				pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kImageComputeWrite, renderSubresource);
+				pass.newTextureDependency(inRt, TextureUsageBit::kSampledCompute);
 			}
 		}
 	}
@@ -141,18 +138,15 @@ void DownscaleBlur::populateRenderGraph(RenderingContext& ctx)
 				sampleSubresource.m_firstMipmap = i - 1;
 				renderSubresource.m_firstMipmap = i;
 
-				pass.newDependency(
-					RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite, renderSubresource));
-				pass.newDependency(
-					RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::kSampledFragment, sampleSubresource));
+				pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite, renderSubresource);
+				pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kSampledFragment, sampleSubresource);
 			}
 			else
 			{
 				TextureSubresourceInfo renderSubresource;
 
-				pass.newDependency(
-					RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite, renderSubresource));
-				pass.newDependency(RenderPassDependency(inRt, TextureUsageBit::kSampledFragment));
+				pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite, renderSubresource);
+				pass.newTextureDependency(inRt, TextureUsageBit::kSampledFragment);
 			}
 		}
 	}

AnKi/Renderer/FinalComposite.cpp

@@ -98,18 +98,17 @@ void FinalComposite::populateRenderGraph(RenderingContext& ctx)
 	});
 	pass.setFramebufferInfo(m_fbDescr, {ctx.m_outRenderTarget});
 
-	pass.newDependency(RenderPassDependency(ctx.m_outRenderTarget, TextureUsageBit::kFramebufferWrite));
+	pass.newTextureDependency(ctx.m_outRenderTarget, TextureUsageBit::kFramebufferWrite);
 
 	if(getConfig().getRDbgEnabled())
 	{
-		pass.newDependency(RenderPassDependency(m_r->getDbg().getRt(), TextureUsageBit::kSampledFragment));
+		pass.newTextureDependency(m_r->getDbg().getRt(), TextureUsageBit::kSampledFragment);
 	}
 
-	pass.newDependency(RenderPassDependency(m_r->getScale().getTonemappedRt(), TextureUsageBit::kSampledFragment));
-	pass.newDependency(RenderPassDependency(m_r->getBloom().getRt(), TextureUsageBit::kSampledFragment));
-	pass.newDependency(
-		RenderPassDependency(m_r->getMotionVectors().getMotionVectorsRt(), TextureUsageBit::kSampledFragment));
-	pass.newDependency(RenderPassDependency(m_r->getGBuffer().getDepthRt(), TextureUsageBit::kSampledFragment));
+	pass.newTextureDependency(m_r->getScale().getTonemappedRt(), TextureUsageBit::kSampledFragment);
+	pass.newTextureDependency(m_r->getBloom().getRt(), TextureUsageBit::kSampledFragment);
+	pass.newTextureDependency(m_r->getMotionVectors().getMotionVectorsRt(), TextureUsageBit::kSampledFragment);
+	pass.newTextureDependency(m_r->getGBuffer().getDepthRt(), TextureUsageBit::kSampledFragment);
 
 	Array<RenderTargetHandle, kMaxDebugRenderTargets> dbgRts;
 	ShaderProgramPtr debugProgram;
@@ -120,7 +119,7 @@ void FinalComposite::populateRenderGraph(RenderingContext& ctx)
 		{
 			if(handle.isValid())
 			{
-				pass.newDependency(RenderPassDependency(handle, TextureUsageBit::kSampledFragment));
+				pass.newTextureDependency(handle, TextureUsageBit::kSampledFragment);
 			}
 		}
 	}

AnKi/Renderer/ForwardShading.cpp

@@ -73,12 +73,12 @@ void ForwardShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgr
 
 void ForwardShading::setDependencies(const RenderingContext& ctx, GraphicsRenderPassDescription& pass)
 {
-	pass.newDependency({m_r->getDepthDownscale().getHiZRt(), TextureUsageBit::kSampledFragment, kHiZHalfSurface});
-	pass.newDependency({m_r->getVolumetricLightingAccumulation().getRt(), TextureUsageBit::kSampledFragment});
+	pass.newTextureDependency(m_r->getDepthDownscale().getHiZRt(), TextureUsageBit::kSampledFragment, kHiZHalfSurface);
+	pass.newTextureDependency(m_r->getVolumetricLightingAccumulation().getRt(), TextureUsageBit::kSampledFragment);
 
 	if(ctx.m_renderQueue->m_lensFlares.getSize())
 	{
-		pass.newDependency({m_r->getLensFlare().getIndirectDrawBuffer(), BufferUsageBit::kIndirectDraw});
+		pass.newBufferDependency(m_r->getLensFlare().getIndirectDrawBuffer(), BufferUsageBit::kIndirectDraw);
 	}
 }
 

AnKi/Renderer/GBuffer.cpp

@@ -232,16 +232,15 @@ void GBuffer::populateRenderGraph(RenderingContext& ctx)
 
 	for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 	{
-		pass.newDependency(RenderPassDependency(m_runCtx.m_colorRts[i], TextureUsageBit::kFramebufferWrite));
+		pass.newTextureDependency(m_runCtx.m_colorRts[i], TextureUsageBit::kFramebufferWrite);
 	}
 
 	TextureSubresourceInfo subresource(DepthStencilAspectBit::kDepth);
-	pass.newDependency(
-		RenderPassDependency(m_runCtx.m_crntFrameDepthRt, TextureUsageBit::kAllFramebuffer, subresource));
+	pass.newTextureDependency(m_runCtx.m_crntFrameDepthRt, TextureUsageBit::kAllFramebuffer, subresource);
 
 	if(enableVrs)
 	{
-		pass.newDependency(RenderPassDependency(sriRt, TextureUsageBit::kFramebufferShadingRate));
+		pass.newTextureDependency(sriRt, TextureUsageBit::kFramebufferShadingRate);
 	}
 }
 

AnKi/Renderer/GBufferPost.cpp

@@ -68,12 +68,11 @@ void GBufferPost::populateRenderGraph(RenderingContext& ctx)
 
 	rpass.setFramebufferInfo(m_fbDescr, {m_r->getGBuffer().getColorRt(0), m_r->getGBuffer().getColorRt(1)});
 
-	rpass.newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(0), TextureUsageBit::kAllFramebuffer));
-	rpass.newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(1), TextureUsageBit::kAllFramebuffer));
-	rpass.newDependency(RenderPassDependency(m_r->getGBuffer().getDepthRt(), TextureUsageBit::kSampledFragment,
-											 TextureSubresourceInfo(DepthStencilAspectBit::kDepth)));
-	rpass.newDependency(
-		RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::kStorageFragmentRead));
+	rpass.newTextureDependency(m_r->getGBuffer().getColorRt(0), TextureUsageBit::kAllFramebuffer);
+	rpass.newTextureDependency(m_r->getGBuffer().getColorRt(1), TextureUsageBit::kAllFramebuffer);
+	rpass.newTextureDependency(m_r->getGBuffer().getDepthRt(), TextureUsageBit::kSampledFragment,
+							   TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
+	rpass.newBufferDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::kStorageFragmentRead);
 }
 
 void GBufferPost::run(const RenderingContext& ctx, RenderPassWorkContext& rgraphCtx)

AnKi/Renderer/GenericCompute.cpp

@@ -27,7 +27,7 @@ void GenericCompute::populateRenderGraph(RenderingContext& ctx)
 		run(ctx, rgraphCtx);
 	});
 
-	pass.newDependency({m_r->getDepthDownscale().getHiZRt(), TextureUsageBit::kSampledCompute});
+	pass.newTextureDependency(m_r->getDepthDownscale().getHiZRt(), TextureUsageBit::kSampledCompute);
 }
 
 void GenericCompute::run(const RenderingContext& ctx, RenderPassWorkContext& rgraphCtx)

AnKi/Renderer/IndirectDiffuse.cpp

@@ -168,9 +168,9 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("IndirectDiffuse VRS SRI gen");
 
-		pass.newDependency(RenderPassDependency(m_runCtx.m_sriRt, TextureUsageBit::kImageComputeWrite));
-		pass.newDependency(RenderPassDependency(m_r->getDepthDownscale().getHiZRt(), TextureUsageBit::kSampledCompute,
-												kHiZHalfSurface));
+		pass.newTextureDependency(m_runCtx.m_sriRt, TextureUsageBit::kImageComputeWrite);
+		pass.newTextureDependency(m_r->getDepthDownscale().getHiZRt(), TextureUsageBit::kSampledCompute,
+								  kHiZHalfSurface);
 
 		pass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
 			const UVec2 viewport = m_r->getInternalResolution() / 2u;
@@ -230,7 +230,7 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 		else
 		{
 			GraphicsRenderPassDescription& rpass = rgraph.newGraphicsRenderPass("IndirectDiffuse");
-			rpass.setFramebufferInfo(m_main.m_fbDescr, {m_runCtx.m_mainRtHandles[WRITE]}, {},
+			rpass.setFramebufferInfo(m_main.m_fbDescr, {m_runCtx.m_mainRtHandles[kWrite]}, {},
 									 (enableVrs) ? m_runCtx.m_sriRt : RenderTargetHandle());
 			readUsage = TextureUsageBit::kSampledFragment;
 			writeUsage = TextureUsageBit::kFramebufferWrite;
@@ -238,21 +238,21 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 
 			if(enableVrs)
 			{
-				prpass->newDependency(RenderPassDependency(m_runCtx.m_sriRt, TextureUsageBit::kFramebufferShadingRate));
+				prpass->newTextureDependency(m_runCtx.m_sriRt, TextureUsageBit::kFramebufferShadingRate);
 			}
 		}
 
-		prpass->newDependency(RenderPassDependency(m_runCtx.m_mainRtHandles[WRITE], writeUsage));
+		prpass->newTextureDependency(m_runCtx.m_mainRtHandles[kWrite], writeUsage);
 
 		m_r->getIndirectDiffuseProbes().setRenderGraphDependencies(ctx, *prpass, readUsage);
-		prpass->newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(2), readUsage));
+		prpass->newTextureDependency(m_r->getGBuffer().getColorRt(2), readUsage);
 		TextureSubresourceInfo hizSubresource;
 		hizSubresource.m_mipmapCount = 1;
-		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().getHistoryLengthRt(), readUsage));
-		prpass->newDependency(RenderPassDependency(m_runCtx.m_mainRtHandles[READ], readUsage));
+		prpass->newTextureDependency(m_r->getDepthDownscale().getHiZRt(), readUsage, hizSubresource);
+		prpass->newTextureDependency(m_r->getDownscaleBlur().getRt(), readUsage);
+		prpass->newTextureDependency(m_r->getMotionVectors().getMotionVectorsRt(), readUsage);
+		prpass->newTextureDependency(m_r->getMotionVectors().getHistoryLengthRt(), readUsage);
+		prpass->newTextureDependency(m_runCtx.m_mainRtHandles[kRead], readUsage);
 
 		prpass->setWork([this, &ctx, enableVrs](RenderPassWorkContext& rgraphCtx) {
 			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
@@ -271,13 +271,13 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 			hizSubresource.m_mipmapCount = 1;
 			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, 8, m_runCtx.m_mainRtHandles[kRead]);
 			rgraphCtx.bindColorTexture(0, 9, m_r->getMotionVectors().getMotionVectorsRt());
 			rgraphCtx.bindColorTexture(0, 10, m_r->getMotionVectors().getHistoryLengthRt());
 
 			if(getConfig().getRPreferCompute())
 			{
-				rgraphCtx.bindImage(0, 11, m_runCtx.m_mainRtHandles[WRITE]);
+				rgraphCtx.bindImage(0, 11, m_runCtx.m_mainRtHandles[kWrite]);
 			}
 
 			// Bind uniforms
@@ -314,7 +314,7 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 	// Denoise
 	for(U32 dir = 0; dir < 2; ++dir)
 	{
-		const U32 readIdx = (dir == 0) ? WRITE : READ;
+		const U32 readIdx = (dir == 0) ? kWrite : kRead;
 
 		TextureUsageBit readUsage;
 		TextureUsageBit writeUsage;
@@ -337,12 +337,12 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 			prpass = &rpass;
 		}
 
-		prpass->newDependency(RenderPassDependency(m_runCtx.m_mainRtHandles[readIdx], readUsage));
+		prpass->newTextureDependency(m_runCtx.m_mainRtHandles[readIdx], readUsage);
 
 		TextureSubresourceInfo hizSubresource;
 		hizSubresource.m_mipmapCount = 1;
-		prpass->newDependency(RenderPassDependency(m_r->getDepthDownscale().getHiZRt(), readUsage, hizSubresource));
-		prpass->newDependency(RenderPassDependency(m_runCtx.m_mainRtHandles[!readIdx], writeUsage));
+		prpass->newTextureDependency(m_r->getDepthDownscale().getHiZRt(), readUsage, hizSubresource);
+		prpass->newTextureDependency(m_runCtx.m_mainRtHandles[!readIdx], writeUsage);
 
 		prpass->setWork([this, &ctx, dir, readIdx](RenderPassWorkContext& rgraphCtx) {
 			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
@@ -387,7 +387,7 @@ void IndirectDiffuse::getDebugRenderTarget(CString rtName, Array<RenderTargetHan
 {
 	if(rtName == "IndirectDiffuse")
 	{
-		handles[0] = m_runCtx.m_mainRtHandles[WRITE];
+		handles[0] = m_runCtx.m_mainRtHandles[kWrite];
 	}
 	else
 	{

AnKi/Renderer/IndirectDiffuse.h

@@ -36,15 +36,15 @@ public:
 
 	RenderTargetHandle getRt() const
 	{
-		return m_runCtx.m_mainRtHandles[WRITE];
+		return m_runCtx.m_mainRtHandles[kWrite];
 	}
 
 private:
 	Array<TexturePtr, 2> m_rts;
 	Bool m_rtsImportedOnce = false;
 
-	static constexpr U32 READ = 0;
-	static constexpr U32 WRITE = 1;
+	static constexpr U32 kRead = 0;
+	static constexpr U32 kWrite = 1;
 
 	class
 	{

AnKi/Renderer/IndirectDiffuseProbes.cpp

@@ -75,7 +75,7 @@ void IndirectDiffuseProbes::setRenderGraphDependencies(const RenderingContext& c
 {
 	for(U32 idx = 0; idx < ctx.m_renderQueue->m_giProbes.getSize(); ++idx)
 	{
-		pass.newDependency({getVolumeRenderTarget(ctx.m_renderQueue->m_giProbes[idx]), usage});
+		pass.newTextureDependency(getVolumeRenderTarget(ctx.m_renderQueue->m_giProbes[idx]), usage);
 	}
 }
 
@@ -282,11 +282,11 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 
 		for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 		{
-			pass.newDependency({giCtx->m_gbufferColorRts[i], TextureUsageBit::kFramebufferWrite});
+			pass.newTextureDependency(giCtx->m_gbufferColorRts[i], TextureUsageBit::kFramebufferWrite);
 		}
 
 		TextureSubresourceInfo subresource(DepthStencilAspectBit::kDepth);
-		pass.newDependency({giCtx->m_gbufferDepthRt, TextureUsageBit::kAllFramebuffer, subresource});
+		pass.newTextureDependency(giCtx->m_gbufferDepthRt, TextureUsageBit::kAllFramebuffer, subresource);
 	}
 
 	// Shadow pass. Optional
@@ -323,7 +323,7 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 		});
 
 		TextureSubresourceInfo subresource(DepthStencilAspectBit::kDepth);
-		pass.newDependency({giCtx->m_shadowsRt, TextureUsageBit::kAllFramebuffer, subresource});
+		pass.newTextureDependency(giCtx->m_shadowsRt, TextureUsageBit::kAllFramebuffer, subresource);
 	}
 	else
 	{
@@ -342,18 +342,18 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 			runLightShading(rgraphCtx, *giCtx);
 		});
 
-		pass.newDependency({giCtx->m_lightShadingRt, TextureUsageBit::kFramebufferWrite});
+		pass.newTextureDependency(giCtx->m_lightShadingRt, TextureUsageBit::kFramebufferWrite);
 
 		for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 		{
-			pass.newDependency({giCtx->m_gbufferColorRts[i], TextureUsageBit::kSampledFragment});
+			pass.newTextureDependency(giCtx->m_gbufferColorRts[i], TextureUsageBit::kSampledFragment);
 		}
-		pass.newDependency({giCtx->m_gbufferDepthRt, TextureUsageBit::kSampledFragment,
-							TextureSubresourceInfo(DepthStencilAspectBit::kDepth)});
+		pass.newTextureDependency(giCtx->m_gbufferDepthRt, TextureUsageBit::kSampledFragment,
+								  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
 		if(giCtx->m_shadowsRt.isValid())
 		{
-			pass.newDependency({giCtx->m_shadowsRt, TextureUsageBit::kSampledFragment});
+			pass.newTextureDependency(giCtx->m_shadowsRt, TextureUsageBit::kSampledFragment);
 		}
 	}
 
@@ -365,15 +365,15 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 			runIrradiance(rgraphCtx, *giCtx);
 		});
 
-		pass.newDependency({giCtx->m_lightShadingRt, TextureUsageBit::kSampledCompute});
+		pass.newTextureDependency(giCtx->m_lightShadingRt, TextureUsageBit::kSampledCompute);
 
 		for(U32 i = 0; i < kGBufferColorRenderTargetCount - 1; ++i)
 		{
-			pass.newDependency({giCtx->m_gbufferColorRts[i], TextureUsageBit::kSampledCompute});
+			pass.newTextureDependency(giCtx->m_gbufferColorRts[i], TextureUsageBit::kSampledCompute);
 		}
 
 		const U32 probeIdx = U32(giCtx->m_probeToUpdateThisFrame - &giCtx->m_ctx->m_renderQueue->m_giProbes.getFront());
-		pass.newDependency({giCtx->m_irradianceProbeRts[probeIdx], TextureUsageBit::kImageComputeWrite});
+		pass.newTextureDependency(giCtx->m_irradianceProbeRts[probeIdx], TextureUsageBit::kImageComputeWrite);
 	}
 }
 

AnKi/Renderer/IndirectSpecular.cpp

@@ -126,7 +126,7 @@ void IndirectSpecular::populateRenderGraph(RenderingContext& ctx)
 		else
 		{
 			GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass("SSR");
-			pass.setFramebufferInfo(m_fbDescr, {m_runCtx.m_rts[WRITE]}, {},
+			pass.setFramebufferInfo(m_fbDescr, {m_runCtx.m_rts[kWrite]}, {},
 									(enableVrs) ? m_r->getVrsSriGeneration().getDownscaledSriRt()
 												: RenderTargetHandle());
 
@@ -136,25 +136,25 @@ void IndirectSpecular::populateRenderGraph(RenderingContext& ctx)
 
 			if(enableVrs)
 			{
-				ppass->newDependency(RenderPassDependency(m_r->getVrsSriGeneration().getDownscaledSriRt(),
-														  TextureUsageBit::kFramebufferShadingRate));
+				ppass->newTextureDependency(m_r->getVrsSriGeneration().getDownscaledSriRt(),
+											TextureUsageBit::kFramebufferShadingRate);
 			}
 		}
 
-		ppass->newDependency(RenderPassDependency(m_runCtx.m_rts[WRITE], writeUsage));
-		ppass->newDependency(RenderPassDependency(m_runCtx.m_rts[READ], readUsage));
-		ppass->newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(1), readUsage));
-		ppass->newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(2), readUsage));
+		ppass->newTextureDependency(m_runCtx.m_rts[kWrite], writeUsage);
+		ppass->newTextureDependency(m_runCtx.m_rts[kRead], readUsage);
+		ppass->newTextureDependency(m_r->getGBuffer().getColorRt(1), readUsage);
+		ppass->newTextureDependency(m_r->getGBuffer().getColorRt(2), readUsage);
 
 		TextureSubresourceInfo hizSubresource;
 		hizSubresource.m_mipmapCount =
 			min(getConfig().getRSsrDepthLod() + 1, m_r->getDepthDownscale().getMipmapCount());
-		ppass->newDependency(RenderPassDependency(m_r->getDepthDownscale().getHiZRt(), readUsage, hizSubresource));
+		ppass->newTextureDependency(m_r->getDepthDownscale().getHiZRt(), readUsage, hizSubresource);
 
-		ppass->newDependency(RenderPassDependency(m_r->getProbeReflections().getReflectionRt(), readUsage));
+		ppass->newTextureDependency(m_r->getProbeReflections().getReflectionRt(), readUsage);
 
-		ppass->newDependency(RenderPassDependency(m_r->getMotionVectors().getMotionVectorsRt(), readUsage));
-		ppass->newDependency(RenderPassDependency(m_r->getMotionVectors().getHistoryLengthRt(), readUsage));
+		ppass->newTextureDependency(m_r->getMotionVectors().getMotionVectorsRt(), readUsage);
+		ppass->newTextureDependency(m_r->getMotionVectors().getHistoryLengthRt(), readUsage);
 
 		ppass->setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
 			run(ctx, rgraphCtx);
@@ -197,7 +197,7 @@ void IndirectSpecular::run(const RenderingContext& ctx, RenderPassWorkContext& r
 
 	rgraphCtx.bindColorTexture(0, 5, m_r->getDownscaleBlur().getRt());
 
-	rgraphCtx.bindColorTexture(0, 6, m_runCtx.m_rts[READ]);
+	rgraphCtx.bindColorTexture(0, 6, m_runCtx.m_rts[kRead]);
 	rgraphCtx.bindColorTexture(0, 7, m_r->getMotionVectors().getMotionVectorsRt());
 	rgraphCtx.bindColorTexture(0, 8, m_r->getMotionVectors().getHistoryLengthRt());
 
@@ -212,7 +212,7 @@ void IndirectSpecular::run(const RenderingContext& ctx, RenderPassWorkContext& r
 
 	if(getConfig().getRPreferCompute())
 	{
-		rgraphCtx.bindImage(0, 15, m_runCtx.m_rts[WRITE], TextureSubresourceInfo());
+		rgraphCtx.bindImage(0, 15, m_runCtx.m_rts[kWrite], TextureSubresourceInfo());
 
 		dispatchPPCompute(cmdb, 8, 8, m_r->getInternalResolution().x() / 2, m_r->getInternalResolution().y() / 2);
 	}
@@ -229,7 +229,7 @@ void IndirectSpecular::getDebugRenderTarget(CString rtName, Array<RenderTargetHa
 {
 	if(rtName == "SSR")
 	{
-		handles[0] = m_runCtx.m_rts[WRITE];
+		handles[0] = m_runCtx.m_rts[kWrite];
 	}
 }
 

AnKi/Renderer/IndirectSpecular.h

@@ -31,12 +31,12 @@ public:
 
 	RenderTargetHandle getRt() const
 	{
-		return m_runCtx.m_rts[WRITE];
+		return m_runCtx.m_rts[kWrite];
 	}
 
 private:
-	static constexpr U32 READ = 0;
-	static constexpr U32 WRITE = 1;
+	static constexpr U32 kRead = 0;
+	static constexpr U32 kWrite = 1;
 
 	ShaderProgramResourcePtr m_prog;
 	ShaderProgramPtr m_grProg;

AnKi/Renderer/LensFlare.cpp

@@ -126,9 +126,9 @@ void LensFlare::populateRenderGraph(RenderingContext& ctx)
 			updateIndirectInfo(ctx, rgraphCtx);
 		});
 
-		rpass.newDependency({m_runCtx.m_indirectBuffHandle, BufferUsageBit::kStorageComputeWrite});
-		rpass.newDependency(
-			{m_r->getDepthDownscale().getHiZRt(), TextureUsageBit::kSampledCompute, kHiZQuarterSurface});
+		rpass.newBufferDependency(m_runCtx.m_indirectBuffHandle, BufferUsageBit::kStorageComputeWrite);
+		rpass.newTextureDependency(m_r->getDepthDownscale().getHiZRt(), TextureUsageBit::kSampledCompute,
+								   kHiZQuarterSurface);
 	}
 }
 

AnKi/Renderer/LightShading.cpp

@@ -373,36 +373,35 @@ void LightShading::populateRenderGraph(RenderingContext& ctx)
 	// All
 	if(enableVrs)
 	{
-		pass.newDependency(RenderPassDependency(sriRt, TextureUsageBit::kFramebufferShadingRate));
+		pass.newTextureDependency(sriRt, TextureUsageBit::kFramebufferShadingRate);
 	}
 
 	// Light shading
-	pass.newDependency(RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite));
-	pass.newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(0), readUsage));
-	pass.newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(1), readUsage));
-	pass.newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(2), readUsage));
-	pass.newDependency(RenderPassDependency(m_r->getGBuffer().getDepthRt(),
-											TextureUsageBit::kSampledFragment | TextureUsageBit::kFramebufferRead,
-											TextureSubresourceInfo(DepthStencilAspectBit::kDepth)));
-	pass.newDependency(RenderPassDependency(m_r->getShadowMapping().getShadowmapRt(), readUsage));
+	pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite);
+	pass.newTextureDependency(m_r->getGBuffer().getColorRt(0), readUsage);
+	pass.newTextureDependency(m_r->getGBuffer().getColorRt(1), readUsage);
+	pass.newTextureDependency(m_r->getGBuffer().getColorRt(2), readUsage);
+	pass.newTextureDependency(m_r->getGBuffer().getDepthRt(),
+							  TextureUsageBit::kSampledFragment | TextureUsageBit::kFramebufferRead,
+							  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
+	pass.newTextureDependency(m_r->getShadowMapping().getShadowmapRt(), readUsage);
 	if(m_r->getRtShadowsEnabled())
 	{
-		pass.newDependency(RenderPassDependency(m_r->getRtShadows().getRt(), readUsage));
+		pass.newTextureDependency(m_r->getRtShadows().getRt(), readUsage);
 	}
 	else
 	{
-		pass.newDependency(RenderPassDependency(m_r->getShadowmapsResolve().getRt(), readUsage));
+		pass.newTextureDependency(m_r->getShadowmapsResolve().getRt(), readUsage);
 	}
-	pass.newDependency(
-		RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::kStorageFragmentRead));
+	pass.newBufferDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::kStorageFragmentRead);
 
 	// Apply indirect
-	pass.newDependency(RenderPassDependency(m_r->getIndirectDiffuse().getRt(), readUsage));
-	pass.newDependency(RenderPassDependency(m_r->getDepthDownscale().getHiZRt(), readUsage));
-	pass.newDependency(RenderPassDependency(m_r->getIndirectSpecular().getRt(), readUsage));
+	pass.newTextureDependency(m_r->getIndirectDiffuse().getRt(), readUsage);
+	pass.newTextureDependency(m_r->getDepthDownscale().getHiZRt(), readUsage);
+	pass.newTextureDependency(m_r->getIndirectSpecular().getRt(), readUsage);
 
 	// Fog
-	pass.newDependency(RenderPassDependency(m_r->getVolumetricFog().getRt(), readUsage));
+	pass.newTextureDependency(m_r->getVolumetricFog().getRt(), readUsage);
 
 	// For forward shading
 	m_r->getForwardShading().setDependencies(ctx, pass);

AnKi/Renderer/MainRenderer.cpp

@@ -123,8 +123,8 @@ Error MainRenderer::render(RenderQueue& rqueue, TexturePtr presentTex)
 			cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
 		});
 
-		pass.newDependency(RenderPassDependency(presentRt, TextureUsageBit::kFramebufferWrite));
-		pass.newDependency(RenderPassDependency(ctx.m_outRenderTarget, TextureUsageBit::kSampledFragment));
+		pass.newTextureDependency(presentRt, TextureUsageBit::kFramebufferWrite);
+		pass.newTextureDependency(ctx.m_outRenderTarget, TextureUsageBit::kSampledFragment);
 	}
 
 	// Create a dummy pass to transition the presentable image to present
@@ -134,7 +134,7 @@ Error MainRenderer::render(RenderQueue& rqueue, TexturePtr presentTex)
 		pass.setWork([]([[maybe_unused]] RenderPassWorkContext& rgraphCtx) {
 			// Do nothing. This pass is dummy
 		});
-		pass.newDependency({presentRt, TextureUsageBit::kPresent});
+		pass.newTextureDependency(presentRt, TextureUsageBit::kPresent);
 	}
 
 	// Bake the render graph

AnKi/Renderer/MotionVectors.cpp

@@ -119,12 +119,12 @@ void MotionVectors::populateRenderGraph(RenderingContext& ctx)
 		run(ctx, rgraphCtx);
 	});
 
-	ppass->newDependency(RenderPassDependency(m_runCtx.m_motionVectorsRtHandle, writeUsage));
-	ppass->newDependency(RenderPassDependency(m_runCtx.m_historyLengthWriteRtHandle, writeUsage));
-	ppass->newDependency(RenderPassDependency(m_runCtx.m_historyLengthReadRtHandle, readUsage));
-	ppass->newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(3), readUsage));
-	ppass->newDependency(RenderPassDependency(m_r->getGBuffer().getDepthRt(), readUsage));
-	ppass->newDependency(RenderPassDependency(m_r->getGBuffer().getPreviousFrameDepthRt(), readUsage));
+	ppass->newTextureDependency(m_runCtx.m_motionVectorsRtHandle, writeUsage);
+	ppass->newTextureDependency(m_runCtx.m_historyLengthWriteRtHandle, writeUsage);
+	ppass->newTextureDependency(m_runCtx.m_historyLengthReadRtHandle, readUsage);
+	ppass->newTextureDependency(m_r->getGBuffer().getColorRt(3), readUsage);
+	ppass->newTextureDependency(m_r->getGBuffer().getDepthRt(), readUsage);
+	ppass->newTextureDependency(m_r->getGBuffer().getPreviousFrameDepthRt(), readUsage);
 }
 
 void MotionVectors::run(const RenderingContext& ctx, RenderPassWorkContext& rgraphCtx)

AnKi/Renderer/ProbeReflections.cpp

@@ -539,11 +539,11 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 
 		for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 		{
-			pass.newDependency({m_ctx.m_gbufferColorRts[i], TextureUsageBit::kFramebufferWrite});
+			pass.newTextureDependency(m_ctx.m_gbufferColorRts[i], TextureUsageBit::kFramebufferWrite);
 		}
 
 		TextureSubresourceInfo subresource(DepthStencilAspectBit::kDepth);
-		pass.newDependency({m_ctx.m_gbufferDepthRt, TextureUsageBit::kAllFramebuffer, subresource});
+		pass.newTextureDependency(m_ctx.m_gbufferDepthRt, TextureUsageBit::kAllFramebuffer, subresource);
 	}
 
 	// Shadow pass. Optional
@@ -587,7 +587,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 		});
 
 		TextureSubresourceInfo subresource(DepthStencilAspectBit::kDepth);
-		pass.newDependency({m_ctx.m_shadowMapRt, TextureUsageBit::kAllFramebuffer, subresource});
+		pass.newTextureDependency(m_ctx.m_shadowMapRt, TextureUsageBit::kAllFramebuffer, subresource);
 	}
 	else
 	{
@@ -613,18 +613,18 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 			});
 
 			TextureSubresourceInfo subresource(TextureSurfaceInfo(0, 0, faceIdx, probeToUpdateCacheEntryIdx));
-			pass.newDependency({m_ctx.m_lightShadingRt, TextureUsageBit::kFramebufferWrite, subresource});
+			pass.newTextureDependency(m_ctx.m_lightShadingRt, TextureUsageBit::kFramebufferWrite, subresource);
 
 			for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 			{
-				pass.newDependency({m_ctx.m_gbufferColorRts[i], TextureUsageBit::kSampledFragment});
+				pass.newTextureDependency(m_ctx.m_gbufferColorRts[i], TextureUsageBit::kSampledFragment);
 			}
-			pass.newDependency({m_ctx.m_gbufferDepthRt, TextureUsageBit::kSampledFragment,
-								TextureSubresourceInfo(DepthStencilAspectBit::kDepth)});
+			pass.newTextureDependency(m_ctx.m_gbufferDepthRt, TextureUsageBit::kSampledFragment,
+									  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
 			if(m_ctx.m_shadowMapRt.isValid())
 			{
-				pass.newDependency({m_ctx.m_shadowMapRt, TextureUsageBit::kSampledFragment});
+				pass.newTextureDependency(m_ctx.m_shadowMapRt, TextureUsageBit::kSampledFragment);
 			}
 		}
 	}
@@ -644,9 +644,9 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 		TextureSubresourceInfo readSubresource;
 		readSubresource.m_faceCount = 6;
 		readSubresource.m_firstLayer = probeToUpdateCacheEntryIdx;
-		pass.newDependency({m_ctx.m_lightShadingRt, TextureUsageBit::kSampledCompute, readSubresource});
+		pass.newTextureDependency(m_ctx.m_lightShadingRt, TextureUsageBit::kSampledCompute, readSubresource);
 
-		pass.newDependency({m_ctx.m_irradianceDiceValuesBuffHandle, BufferUsageBit::kStorageComputeWrite});
+		pass.newBufferDependency(m_ctx.m_irradianceDiceValuesBuffHandle, BufferUsageBit::kStorageComputeWrite);
 	}
 
 	// Write irradiance back to refl
@@ -659,16 +659,17 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 
 		for(U i = 0; i < kGBufferColorRenderTargetCount - 1; ++i)
 		{
-			pass.newDependency({m_ctx.m_gbufferColorRts[i], TextureUsageBit::kSampledCompute});
+			pass.newTextureDependency(m_ctx.m_gbufferColorRts[i], TextureUsageBit::kSampledCompute);
 		}
 
 		TextureSubresourceInfo subresource;
 		subresource.m_faceCount = 6;
 		subresource.m_firstLayer = probeToUpdateCacheEntryIdx;
-		pass.newDependency({m_ctx.m_lightShadingRt,
-							TextureUsageBit::kImageComputeRead | TextureUsageBit::kImageComputeWrite, subresource});
+		pass.newTextureDependency(m_ctx.m_lightShadingRt,
+								  TextureUsageBit::kImageComputeRead | TextureUsageBit::kImageComputeWrite,
+								  subresource);
 
-		pass.newDependency({m_ctx.m_irradianceDiceValuesBuffHandle, BufferUsageBit::kStorageComputeRead});
+		pass.newBufferDependency(m_ctx.m_irradianceDiceValuesBuffHandle, BufferUsageBit::kStorageComputeRead);
 	}
 
 	// Mipmapping "passes"
@@ -685,7 +686,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 			TextureSubresourceInfo subresource(TextureSurfaceInfo(0, 0, faceIdx, probeToUpdateCacheEntryIdx));
 			subresource.m_mipmapCount = m_lightShading.m_mipCount;
 
-			pass.newDependency({m_ctx.m_lightShadingRt, TextureUsageBit::kGenerateMipmaps, subresource});
+			pass.newTextureDependency(m_ctx.m_lightShadingRt, TextureUsageBit::kGenerateMipmaps, subresource);
 		}
 	}
 }

AnKi/Renderer/RtShadows.cpp

@@ -234,9 +234,9 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 		m_runCtx.m_upscaledRt = rgraph.newRenderTarget(m_upscaledRtDescr);
 	}
 
-	const RenderPassDependency depthDependency(m_r->getDepthDownscale().getHiZRt(),
-											   TextureUsageBit::kSampledTraceRays | TextureUsageBit::kSampledCompute,
-											   kHiZHalfSurface);
+#define ANKI_DEPTH_DEP \
+	m_r->getDepthDownscale().getHiZRt(), TextureUsageBit::kSampledTraceRays | TextureUsageBit::kSampledCompute, \
+		kHiZHalfSurface
 
 	// RT shadows pass
 	{
@@ -245,24 +245,20 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 			run(ctx, rgraphCtx);
 		});
 
-		rpass.newDependency(RenderPassDependency(m_runCtx.m_historyRt, TextureUsageBit::kSampledTraceRays));
-		rpass.newDependency(
-			RenderPassDependency(m_runCtx.m_intermediateShadowsRts[0], TextureUsageBit::kImageTraceRaysWrite));
-		rpass.newDependency(
-			RenderPassDependency(m_r->getAccelerationStructureBuilder().getAccelerationStructureHandle(),
-								 AccelerationStructureUsageBit::kTraceRaysRead));
-		rpass.newDependency(depthDependency);
-		rpass.newDependency(
-			RenderPassDependency(m_r->getMotionVectors().getMotionVectorsRt(), TextureUsageBit::kSampledTraceRays));
-		rpass.newDependency(
-			RenderPassDependency(m_r->getMotionVectors().getHistoryLengthRt(), TextureUsageBit::kSampledTraceRays));
-		rpass.newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(2), TextureUsageBit::kSampledTraceRays));
-
-		rpass.newDependency(RenderPassDependency(m_runCtx.m_prevMomentsRt, TextureUsageBit::kSampledTraceRays));
-		rpass.newDependency(RenderPassDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kImageTraceRaysWrite));
-
-		rpass.newDependency(
-			RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::kStorageTraceRaysRead));
+		rpass.newTextureDependency(m_runCtx.m_historyRt, TextureUsageBit::kSampledTraceRays);
+		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[0], TextureUsageBit::kImageTraceRaysWrite);
+		rpass.newAccelerationStructureDependency(
+			m_r->getAccelerationStructureBuilder().getAccelerationStructureHandle(),
+			AccelerationStructureUsageBit::kTraceRaysRead);
+		rpass.newTextureDependency(ANKI_DEPTH_DEP);
+		rpass.newTextureDependency(m_r->getMotionVectors().getMotionVectorsRt(), TextureUsageBit::kSampledTraceRays);
+		rpass.newTextureDependency(m_r->getMotionVectors().getHistoryLengthRt(), TextureUsageBit::kSampledTraceRays);
+		rpass.newTextureDependency(m_r->getGBuffer().getColorRt(2), TextureUsageBit::kSampledTraceRays);
+
+		rpass.newTextureDependency(m_runCtx.m_prevMomentsRt, TextureUsageBit::kSampledTraceRays);
+		rpass.newTextureDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kImageTraceRaysWrite);
+
+		rpass.newBufferDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::kStorageTraceRaysRead);
 	}
 
 	// Denoise pass horizontal
@@ -273,16 +269,13 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 			runDenoise(ctx, rgraphCtx);
 		});
 
-		rpass.newDependency(
-			RenderPassDependency(m_runCtx.m_intermediateShadowsRts[0], TextureUsageBit::kSampledCompute));
-		rpass.newDependency(depthDependency);
-		rpass.newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(2), TextureUsageBit::kSampledCompute));
-		rpass.newDependency(RenderPassDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kSampledCompute));
-		rpass.newDependency(
-			RenderPassDependency(m_r->getMotionVectors().getHistoryLengthRt(), TextureUsageBit::kSampledCompute));
+		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[0], TextureUsageBit::kSampledCompute);
+		rpass.newTextureDependency(ANKI_DEPTH_DEP);
+		rpass.newTextureDependency(m_r->getGBuffer().getColorRt(2), TextureUsageBit::kSampledCompute);
+		rpass.newTextureDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kSampledCompute);
+		rpass.newTextureDependency(m_r->getMotionVectors().getHistoryLengthRt(), TextureUsageBit::kSampledCompute);
 
-		rpass.newDependency(
-			RenderPassDependency(m_runCtx.m_intermediateShadowsRts[1], TextureUsageBit::kImageComputeWrite));
+		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[1], TextureUsageBit::kImageComputeWrite);
 	}
 
 	// Denoise pass vertical
@@ -293,15 +286,13 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 			runDenoise(ctx, rgraphCtx);
 		});
 
-		rpass.newDependency(
-			RenderPassDependency(m_runCtx.m_intermediateShadowsRts[1], TextureUsageBit::kSampledCompute));
-		rpass.newDependency(depthDependency);
-		rpass.newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(2), TextureUsageBit::kSampledCompute));
-		rpass.newDependency(RenderPassDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kSampledCompute));
-		rpass.newDependency(
-			RenderPassDependency(m_r->getMotionVectors().getHistoryLengthRt(), TextureUsageBit::kSampledCompute));
+		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[1], TextureUsageBit::kSampledCompute);
+		rpass.newTextureDependency(ANKI_DEPTH_DEP);
+		rpass.newTextureDependency(m_r->getGBuffer().getColorRt(2), TextureUsageBit::kSampledCompute);
+		rpass.newTextureDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kSampledCompute);
+		rpass.newTextureDependency(m_r->getMotionVectors().getHistoryLengthRt(), TextureUsageBit::kSampledCompute);
 
-		rpass.newDependency(RenderPassDependency(m_runCtx.m_historyRt, TextureUsageBit::kImageComputeWrite));
+		rpass.newTextureDependency(m_runCtx.m_historyRt, TextureUsageBit::kImageComputeWrite);
 	}
 
 	// Variance calculation pass
@@ -312,17 +303,14 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 			runSvgfVariance(ctx, rgraphCtx);
 		});
 
-		rpass.newDependency(
-			RenderPassDependency(m_runCtx.m_intermediateShadowsRts[0], TextureUsageBit::kSampledCompute));
-		rpass.newDependency(RenderPassDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kSampledCompute));
-		rpass.newDependency(
-			RenderPassDependency(m_r->getMotionVectors().getHistoryLengthRt(), TextureUsageBit::kSampledCompute));
-		rpass.newDependency(depthDependency);
-		rpass.newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(2), TextureUsageBit::kSampledCompute));
-
-		rpass.newDependency(
-			RenderPassDependency(m_runCtx.m_intermediateShadowsRts[1], TextureUsageBit::kImageComputeWrite));
-		rpass.newDependency(RenderPassDependency(m_runCtx.m_varianceRts[1], TextureUsageBit::kImageComputeWrite));
+		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[0], TextureUsageBit::kSampledCompute);
+		rpass.newTextureDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kSampledCompute);
+		rpass.newTextureDependency(m_r->getMotionVectors().getHistoryLengthRt(), TextureUsageBit::kSampledCompute);
+		rpass.newTextureDependency(ANKI_DEPTH_DEP);
+		rpass.newTextureDependency(m_r->getGBuffer().getColorRt(2), TextureUsageBit::kSampledCompute);
+
+		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[1], TextureUsageBit::kImageComputeWrite);
+		rpass.newTextureDependency(m_runCtx.m_varianceRts[1], TextureUsageBit::kImageComputeWrite);
 	}
 
 	// SVGF Atrous
@@ -340,25 +328,21 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 				runSvgfAtrous(ctx, rgraphCtx);
 			});
 
-			rpass.newDependency(depthDependency);
-			rpass.newDependency(
-				RenderPassDependency(m_r->getGBuffer().getColorRt(2), TextureUsageBit::kSampledCompute));
-			rpass.newDependency(
-				RenderPassDependency(m_runCtx.m_intermediateShadowsRts[readRtIdx], TextureUsageBit::kSampledCompute));
-			rpass.newDependency(
-				RenderPassDependency(m_runCtx.m_varianceRts[readRtIdx], TextureUsageBit::kSampledCompute));
+			rpass.newTextureDependency(ANKI_DEPTH_DEP);
+			rpass.newTextureDependency(m_r->getGBuffer().getColorRt(2), TextureUsageBit::kSampledCompute);
+			rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[readRtIdx], TextureUsageBit::kSampledCompute);
+			rpass.newTextureDependency(m_runCtx.m_varianceRts[readRtIdx], TextureUsageBit::kSampledCompute);
 
 			if(!lastPass)
 			{
-				rpass.newDependency(RenderPassDependency(m_runCtx.m_intermediateShadowsRts[!readRtIdx],
-														 TextureUsageBit::kImageComputeWrite));
+				rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[!readRtIdx],
+										   TextureUsageBit::kImageComputeWrite);
 
-				rpass.newDependency(
-					RenderPassDependency(m_runCtx.m_varianceRts[!readRtIdx], TextureUsageBit::kImageComputeWrite));
+				rpass.newTextureDependency(m_runCtx.m_varianceRts[!readRtIdx], TextureUsageBit::kImageComputeWrite);
 			}
 			else
 			{
-				rpass.newDependency(RenderPassDependency(m_runCtx.m_historyRt, TextureUsageBit::kImageComputeWrite));
+				rpass.newTextureDependency(m_runCtx.m_historyRt, TextureUsageBit::kImageComputeWrite);
 			}
 		}
 	}
@@ -370,11 +354,11 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 			runUpscale(rgraphCtx);
 		});
 
-		rpass.newDependency(RenderPassDependency(m_runCtx.m_historyRt, TextureUsageBit::kSampledCompute));
-		rpass.newDependency(RenderPassDependency(m_r->getGBuffer().getDepthRt(), TextureUsageBit::kSampledCompute));
-		rpass.newDependency(depthDependency);
+		rpass.newTextureDependency(m_runCtx.m_historyRt, TextureUsageBit::kSampledCompute);
+		rpass.newTextureDependency(m_r->getGBuffer().getDepthRt(), TextureUsageBit::kSampledCompute);
+		rpass.newTextureDependency(ANKI_DEPTH_DEP);
 
-		rpass.newDependency(RenderPassDependency(m_runCtx.m_upscaledRt, TextureUsageBit::kImageComputeWrite));
+		rpass.newTextureDependency(m_runCtx.m_upscaledRt, TextureUsageBit::kImageComputeWrite);
 	}
 
 	// Find out the lights that will take part in RT pass

AnKi/Renderer/Scale.cpp

@@ -202,11 +202,11 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		const TextureUsageBit readUsage = TextureUsageBit::kAllSampled & TextureUsageBit::kAllCompute;
 		const TextureUsageBit writeUsage = TextureUsageBit::kAllImage & TextureUsageBit::kAllCompute;
 
-		pass.newDependency(RenderPassDependency(m_r->getLightShading().getRt(), readUsage));
-		pass.newDependency(RenderPassDependency(m_r->getMotionVectors().getMotionVectorsRt(), readUsage));
-		pass.newDependency(RenderPassDependency(m_r->getGBuffer().getDepthRt(), readUsage,
-												TextureSubresourceInfo(DepthStencilAspectBit::kDepth)));
-		pass.newDependency(RenderPassDependency(m_runCtx.m_upscaledHdrRt, writeUsage));
+		pass.newTextureDependency(m_r->getLightShading().getRt(), readUsage);
+		pass.newTextureDependency(m_r->getMotionVectors().getMotionVectorsRt(), readUsage);
+		pass.newTextureDependency(m_r->getGBuffer().getDepthRt(), readUsage,
+								  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
+		pass.newTextureDependency(m_runCtx.m_upscaledHdrRt, writeUsage);
 
 		pass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
 			runGrUpscaling(ctx, rgraphCtx);
@@ -222,8 +222,8 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		if(preferCompute)
 		{
 			ComputeRenderPassDescription& pass = ctx.m_renderGraphDescr.newComputeRenderPass("Scale");
-			pass.newDependency(RenderPassDependency(inRt, TextureUsageBit::kSampledCompute));
-			pass.newDependency(RenderPassDependency(outRt, TextureUsageBit::kImageComputeWrite));
+			pass.newTextureDependency(inRt, TextureUsageBit::kSampledCompute);
+			pass.newTextureDependency(outRt, TextureUsageBit::kImageComputeWrite);
 
 			pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 				runFsrOrBilinearScaling(rgraphCtx);
@@ -233,8 +233,8 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		{
 			GraphicsRenderPassDescription& pass = ctx.m_renderGraphDescr.newGraphicsRenderPass("Scale");
 			pass.setFramebufferInfo(m_fbDescr, {outRt});
-			pass.newDependency(RenderPassDependency(inRt, TextureUsageBit::kSampledFragment));
-			pass.newDependency(RenderPassDependency(outRt, TextureUsageBit::kFramebufferWrite));
+			pass.newTextureDependency(inRt, TextureUsageBit::kSampledFragment);
+			pass.newTextureDependency(outRt, TextureUsageBit::kFramebufferWrite);
 
 			pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 				runFsrOrBilinearScaling(rgraphCtx);
@@ -259,8 +259,8 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		if(preferCompute)
 		{
 			ComputeRenderPassDescription& pass = ctx.m_renderGraphDescr.newComputeRenderPass("Tonemap");
-			pass.newDependency(RenderPassDependency(inRt, TextureUsageBit::kSampledCompute));
-			pass.newDependency(RenderPassDependency(outRt, TextureUsageBit::kImageComputeWrite));
+			pass.newTextureDependency(inRt, TextureUsageBit::kSampledCompute);
+			pass.newTextureDependency(outRt, TextureUsageBit::kImageComputeWrite);
 
 			pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 				runTonemapping(rgraphCtx);
@@ -270,8 +270,8 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		{
 			GraphicsRenderPassDescription& pass = ctx.m_renderGraphDescr.newGraphicsRenderPass("Sharpen");
 			pass.setFramebufferInfo(m_fbDescr, {outRt});
-			pass.newDependency(RenderPassDependency(inRt, TextureUsageBit::kSampledFragment));
-			pass.newDependency(RenderPassDependency(outRt, TextureUsageBit::kFramebufferWrite));
+			pass.newTextureDependency(inRt, TextureUsageBit::kSampledFragment);
+			pass.newTextureDependency(outRt, TextureUsageBit::kFramebufferWrite);
 
 			pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 				runTonemapping(rgraphCtx);
@@ -293,8 +293,8 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		if(preferCompute)
 		{
 			ComputeRenderPassDescription& pass = ctx.m_renderGraphDescr.newComputeRenderPass("Sharpen");
-			pass.newDependency(RenderPassDependency(inRt, TextureUsageBit::kSampledCompute));
-			pass.newDependency(RenderPassDependency(outRt, TextureUsageBit::kImageComputeWrite));
+			pass.newTextureDependency(inRt, TextureUsageBit::kSampledCompute);
+			pass.newTextureDependency(outRt, TextureUsageBit::kImageComputeWrite);
 
 			pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 				runRcasSharpening(rgraphCtx);
@@ -304,8 +304,8 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		{
 			GraphicsRenderPassDescription& pass = ctx.m_renderGraphDescr.newGraphicsRenderPass("Sharpen");
 			pass.setFramebufferInfo(m_fbDescr, {outRt});
-			pass.newDependency(RenderPassDependency(inRt, TextureUsageBit::kSampledFragment));
-			pass.newDependency(RenderPassDependency(outRt, TextureUsageBit::kFramebufferWrite));
+			pass.newTextureDependency(inRt, TextureUsageBit::kSampledFragment);
+			pass.newTextureDependency(outRt, TextureUsageBit::kFramebufferWrite);
 
 			pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 				runRcasSharpening(rgraphCtx);

AnKi/Renderer/ShadowMapping.cpp

@@ -270,7 +270,7 @@ void ShadowMapping::populateRenderGraph(RenderingContext& ctx)
 			});
 
 			TextureSubresourceInfo subresource = TextureSubresourceInfo(DepthStencilAspectBit::kDepth);
-			pass.newDependency({m_scratch.m_rt, TextureUsageBit::kAllFramebuffer, subresource});
+			pass.newTextureDependency(m_scratch.m_rt, TextureUsageBit::kAllFramebuffer, subresource);
 		}
 
 		// Atlas pass
@@ -293,9 +293,9 @@ void ShadowMapping::populateRenderGraph(RenderingContext& ctx)
 					runAtlas(rgraphCtx);
 				});
 
-				pass.newDependency(RenderPassDependency(m_scratch.m_rt, TextureUsageBit::kSampledCompute,
-														TextureSubresourceInfo(DepthStencilAspectBit::kDepth)));
-				pass.newDependency(RenderPassDependency(m_atlas.m_rt, TextureUsageBit::kImageComputeWrite));
+				pass.newTextureDependency(m_scratch.m_rt, TextureUsageBit::kSampledCompute,
+										  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
+				pass.newTextureDependency(m_atlas.m_rt, TextureUsageBit::kImageComputeWrite);
 			}
 			else
 			{
@@ -306,10 +306,10 @@ void ShadowMapping::populateRenderGraph(RenderingContext& ctx)
 					runAtlas(rgraphCtx);
 				});
 
-				pass.newDependency(RenderPassDependency(m_scratch.m_rt, TextureUsageBit::kSampledFragment,
-														TextureSubresourceInfo(DepthStencilAspectBit::kDepth)));
-				pass.newDependency(RenderPassDependency(m_atlas.m_rt, TextureUsageBit::kFramebufferRead
-																		  | TextureUsageBit::kFramebufferWrite));
+				pass.newTextureDependency(m_scratch.m_rt, TextureUsageBit::kSampledFragment,
+										  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
+				pass.newTextureDependency(m_atlas.m_rt,
+										  TextureUsageBit::kFramebufferRead | TextureUsageBit::kFramebufferWrite);
 			}
 		}
 	}

AnKi/Renderer/ShadowmapsResolve.cpp

@@ -75,15 +75,13 @@ void ShadowmapsResolve::populateRenderGraph(RenderingContext& ctx)
 			run(ctx, rgraphCtx);
 		});
 
-		rpass.newDependency(RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::kImageComputeWrite));
-		rpass.newDependency(
-			RenderPassDependency((m_quarterRez) ? m_r->getDepthDownscale().getHiZRt() : m_r->getGBuffer().getDepthRt(),
-								 TextureUsageBit::kSampledCompute, TextureSurfaceInfo(0, 0, 0, 0)));
-		rpass.newDependency(
-			RenderPassDependency(m_r->getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledCompute));
-
-		rpass.newDependency(
-			RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::kStorageComputeRead));
+		rpass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kImageComputeWrite);
+		rpass.newTextureDependency((m_quarterRez) ? m_r->getDepthDownscale().getHiZRt()
+												  : m_r->getGBuffer().getDepthRt(),
+								   TextureUsageBit::kSampledCompute, TextureSurfaceInfo(0, 0, 0, 0));
+		rpass.newTextureDependency(m_r->getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledCompute);
+
+		rpass.newBufferDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::kStorageComputeRead);
 	}
 	else
 	{
@@ -94,15 +92,13 @@ void ShadowmapsResolve::populateRenderGraph(RenderingContext& ctx)
 			run(ctx, rgraphCtx);
 		});
 
-		rpass.newDependency(RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite));
-		rpass.newDependency(
-			RenderPassDependency((m_quarterRez) ? m_r->getDepthDownscale().getHiZRt() : m_r->getGBuffer().getDepthRt(),
-								 TextureUsageBit::kSampledFragment, TextureSurfaceInfo(0, 0, 0, 0)));
-		rpass.newDependency(
-			RenderPassDependency(m_r->getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledFragment));
+		rpass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite);
+		rpass.newTextureDependency((m_quarterRez) ? m_r->getDepthDownscale().getHiZRt()
+												  : m_r->getGBuffer().getDepthRt(),
+								   TextureUsageBit::kSampledFragment, TextureSurfaceInfo(0, 0, 0, 0));
+		rpass.newTextureDependency(m_r->getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledFragment);
 
-		rpass.newDependency(
-			RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::kStorageFragmentRead));
+		rpass.newBufferDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::kStorageFragmentRead);
 	}
 }
 

AnKi/Renderer/TemporalAA.cpp

@@ -115,8 +115,8 @@ void TemporalAA::populateRenderGraph(RenderingContext& ctx)
 	{
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("TemporalAA");
 
-		pass.newDependency(RenderPassDependency(m_runCtx.m_renderRt, TextureUsageBit::kImageComputeWrite));
-		pass.newDependency(RenderPassDependency(m_runCtx.m_tonemappedRt, TextureUsageBit::kImageComputeWrite));
+		pass.newTextureDependency(m_runCtx.m_renderRt, TextureUsageBit::kImageComputeWrite);
+		pass.newTextureDependency(m_runCtx.m_tonemappedRt, TextureUsageBit::kImageComputeWrite);
 
 		readUsage = TextureUsageBit::kSampledCompute;
 
@@ -127,19 +127,19 @@ void TemporalAA::populateRenderGraph(RenderingContext& ctx)
 		GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass("TemporalAA");
 		pass.setFramebufferInfo(m_fbDescr, {m_runCtx.m_renderRt, m_runCtx.m_tonemappedRt});
 
-		pass.newDependency(RenderPassDependency(m_runCtx.m_renderRt, TextureUsageBit::kFramebufferWrite));
-		pass.newDependency(RenderPassDependency(m_runCtx.m_tonemappedRt, TextureUsageBit::kFramebufferWrite));
+		pass.newTextureDependency(m_runCtx.m_renderRt, TextureUsageBit::kFramebufferWrite);
+		pass.newTextureDependency(m_runCtx.m_tonemappedRt, TextureUsageBit::kFramebufferWrite);
 
 		readUsage = TextureUsageBit::kSampledFragment;
 
 		prpass = &pass;
 	}
 
-	prpass->newDependency(RenderPassDependency(m_r->getGBuffer().getDepthRt(), readUsage,
-											   TextureSubresourceInfo(DepthStencilAspectBit::kDepth)));
-	prpass->newDependency(RenderPassDependency(m_r->getLightShading().getRt(), readUsage));
-	prpass->newDependency(RenderPassDependency(m_runCtx.m_historyRt, readUsage));
-	prpass->newDependency(RenderPassDependency(m_r->getMotionVectors().getMotionVectorsRt(), readUsage));
+	prpass->newTextureDependency(m_r->getGBuffer().getDepthRt(), readUsage,
+								 TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
+	prpass->newTextureDependency(m_r->getLightShading().getRt(), readUsage);
+	prpass->newTextureDependency(m_runCtx.m_historyRt, readUsage);
+	prpass->newTextureDependency(m_r->getMotionVectors().getMotionVectorsRt(), readUsage);
 
 	prpass->setWork([this](RenderPassWorkContext& rgraphCtx) {
 		CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;

AnKi/Renderer/Tonemapping.cpp

@@ -80,7 +80,7 @@ void Tonemapping::populateRenderGraph(RenderingContext& ctx)
 
 	TextureSubresourceInfo inputTexSubresource;
 	inputTexSubresource.m_firstMipmap = m_inputTexMip;
-	pass.newDependency({m_r->getDownscaleBlur().getRt(), TextureUsageBit::kSampledCompute, inputTexSubresource});
+	pass.newTextureDependency(m_r->getDownscaleBlur().getRt(), TextureUsageBit::kSampledCompute, inputTexSubresource);
 }
 
 } // end namespace anki

AnKi/Renderer/VolumetricFog.cpp

@@ -59,8 +59,8 @@ void VolumetricFog::populateRenderGraph(RenderingContext& ctx)
 
 	ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("Vol fog");
 
-	pass.newDependency({m_runCtx.m_rt, TextureUsageBit::kImageComputeWrite});
-	pass.newDependency({m_r->getVolumetricLightingAccumulation().getRt(), TextureUsageBit::kSampledCompute});
+	pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kImageComputeWrite);
+	pass.newTextureDependency(m_r->getVolumetricLightingAccumulation().getRt(), TextureUsageBit::kSampledCompute);
 
 	pass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) -> void {
 		CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;

AnKi/Renderer/VolumetricLightingAccumulation.cpp

@@ -87,13 +87,11 @@ void VolumetricLightingAccumulation::populateRenderGraph(RenderingContext& ctx)
 		run(ctx, rgraphCtx);
 	});
 
-	pass.newDependency(RenderPassDependency(m_runCtx.m_rts[0], TextureUsageBit::kSampledCompute));
-	pass.newDependency(RenderPassDependency(m_runCtx.m_rts[1], TextureUsageBit::kImageComputeWrite));
-	pass.newDependency(
-		RenderPassDependency(m_r->getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledCompute));
+	pass.newTextureDependency(m_runCtx.m_rts[0], TextureUsageBit::kSampledCompute);
+	pass.newTextureDependency(m_runCtx.m_rts[1], TextureUsageBit::kImageComputeWrite);
+	pass.newTextureDependency(m_r->getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledCompute);
 
-	pass.newDependency(
-		RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::kStorageComputeRead));
+	pass.newBufferDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::kStorageComputeRead);
 
 	m_r->getIndirectDiffuseProbes().setRenderGraphDependencies(ctx, pass, TextureUsageBit::kSampledCompute);
 }

AnKi/Renderer/VrsSriGeneration.cpp

@@ -148,8 +148,8 @@ void VrsSriGeneration::populateRenderGraph(RenderingContext& ctx)
 	{
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("VRS SRI generation");
 
-		pass.newDependency(RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::kImageComputeWrite));
-		pass.newDependency(RenderPassDependency(m_r->getLightShading().getRt(), TextureUsageBit::kSampledCompute));
+		pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kImageComputeWrite);
+		pass.newTextureDependency(m_r->getLightShading().getRt(), TextureUsageBit::kSampledCompute);
 
 		pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
@@ -172,8 +172,8 @@ void VrsSriGeneration::populateRenderGraph(RenderingContext& ctx)
 	{
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("VRS SRI downscale");
 
-		pass.newDependency(RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::kSampledCompute));
-		pass.newDependency(RenderPassDependency(m_runCtx.m_downscaledRt, TextureUsageBit::kImageComputeWrite));
+		pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kSampledCompute);
+		pass.newTextureDependency(m_runCtx.m_downscaledRt, TextureUsageBit::kImageComputeWrite);
 
 		pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 			const UVec2 rezDownscaled =

CMakeLists.txt

@@ -473,7 +473,12 @@ endif()
 # Add AnKi sub libraries
 add_subdirectory(AnKi)
 
-add_library(AnKi INTERFACE)
+if(MSVC)
+    add_library(AnKi INTERFACE AnKi.natvis)
+else()
+    add_library(AnKi INTERFACE)
+endif()
+
 target_link_libraries(AnKi INTERFACE AnKiCore ${THIRD_PARTY_LIBS})
 add_dependencies(AnKi AnKiShaders)
 

Tests/Gr/Gr.cpp

@@ -1537,15 +1537,15 @@ ANKI_TEST(Gr, RenderGraph)
 	RenderTargetHandle smScratchRt = descr.newRenderTarget(newRTDescr("SM scratch"));
 	{
 		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("SM");
-		pass.newDependency({smScratchRt, TextureUsageBit::kAllFramebuffer});
+		pass.newTextureDependency(smScratchRt, TextureUsageBit::kAllFramebuffer);
 	}
 
 	// SM to exponential SM
 	RenderTargetHandle smExpRt = descr.importRenderTarget(dummyTex, TextureUsageBit::kSampledFragment);
 	{
 		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("ESM");
-		pass.newDependency({smScratchRt, TextureUsageBit::kSampledFragment});
-		pass.newDependency({smExpRt, TextureUsageBit::kFramebufferWrite});
+		pass.newTextureDependency(smScratchRt, TextureUsageBit::kSampledFragment);
+		pass.newTextureDependency(smExpRt, TextureUsageBit::kFramebufferWrite);
 	}
 
 	// GI gbuff
@@ -1554,9 +1554,9 @@ ANKI_TEST(Gr, RenderGraph)
 	RenderTargetHandle giGbuffDepthRt = descr.newRenderTarget(newRTDescr("GI GBuff depth"));
 	{
 		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("GI gbuff");
-		pass.newDependency({giGbuffNormRt, TextureUsageBit::kFramebufferWrite});
-		pass.newDependency({giGbuffDepthRt, TextureUsageBit::kFramebufferWrite});
-		pass.newDependency({giGbuffDiffRt, TextureUsageBit::kFramebufferWrite});
+		pass.newTextureDependency(giGbuffNormRt, TextureUsageBit::kFramebufferWrite);
+		pass.newTextureDependency(giGbuffDepthRt, TextureUsageBit::kFramebufferWrite);
+		pass.newTextureDependency(giGbuffDiffRt, TextureUsageBit::kFramebufferWrite);
 	}
 
 	// GI light
@@ -1567,10 +1567,10 @@ ANKI_TEST(Gr, RenderGraph)
 
 		GraphicsRenderPassDescription& pass =
 			descr.newGraphicsRenderPass(StringRaii(&pool).sprintf("GI lp%u", faceIdx).toCString());
-		pass.newDependency({giGiLightRt, TextureUsageBit::kFramebufferWrite, subresource});
-		pass.newDependency({giGbuffNormRt, TextureUsageBit::kSampledFragment});
-		pass.newDependency({giGbuffDepthRt, TextureUsageBit::kSampledFragment});
-		pass.newDependency({giGbuffDiffRt, TextureUsageBit::kSampledFragment});
+		pass.newTextureDependency(giGiLightRt, TextureUsageBit::kFramebufferWrite, subresource);
+		pass.newTextureDependency(giGbuffNormRt, TextureUsageBit::kSampledFragment);
+		pass.newTextureDependency(giGbuffDepthRt, TextureUsageBit::kSampledFragment);
+		pass.newTextureDependency(giGbuffDiffRt, TextureUsageBit::kSampledFragment);
 	}
 
 	// GI light mips
@@ -1583,7 +1583,7 @@ ANKI_TEST(Gr, RenderGraph)
 			for(U32 mip = 0; mip < GI_MIP_COUNT; ++mip)
 			{
 				TextureSurfaceInfo surf(mip, 0, faceIdx, 0);
-				pass.newDependency({giGiLightRt, TextureUsageBit::kGenerateMipmaps, surf});
+				pass.newTextureDependency(giGiLightRt, TextureUsageBit::kGenerateMipmaps, surf);
 			}
 		}
 	}
@@ -1595,70 +1595,70 @@ ANKI_TEST(Gr, RenderGraph)
 	RenderTargetHandle gbuffDepth = descr.newRenderTarget(newRTDescr("GBuff RT2"));
 	{
 		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("G-Buffer");
-		pass.newDependency({gbuffRt0, TextureUsageBit::kFramebufferWrite});
-		pass.newDependency({gbuffRt1, TextureUsageBit::kFramebufferWrite});
-		pass.newDependency({gbuffRt2, TextureUsageBit::kFramebufferWrite});
-		pass.newDependency({gbuffDepth, TextureUsageBit::kFramebufferWrite});
+		pass.newTextureDependency(gbuffRt0, TextureUsageBit::kFramebufferWrite);
+		pass.newTextureDependency(gbuffRt1, TextureUsageBit::kFramebufferWrite);
+		pass.newTextureDependency(gbuffRt2, TextureUsageBit::kFramebufferWrite);
+		pass.newTextureDependency(gbuffDepth, TextureUsageBit::kFramebufferWrite);
 	}
 
 	// Half depth
 	RenderTargetHandle halfDepthRt = descr.newRenderTarget(newRTDescr("Depth/2"));
 	{
 		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("HalfDepth");
-		pass.newDependency({gbuffDepth, TextureUsageBit::kSampledFragment});
-		pass.newDependency({halfDepthRt, TextureUsageBit::kFramebufferWrite});
+		pass.newTextureDependency(gbuffDepth, TextureUsageBit::kSampledFragment);
+		pass.newTextureDependency(halfDepthRt, TextureUsageBit::kFramebufferWrite);
 	}
 
 	// Quarter depth
 	RenderTargetHandle quarterDepthRt = descr.newRenderTarget(newRTDescr("Depth/4"));
 	{
 		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("QuarterDepth");
-		pass.newDependency({quarterDepthRt, TextureUsageBit::kFramebufferWrite});
-		pass.newDependency({halfDepthRt, TextureUsageBit::kSampledFragment});
+		pass.newTextureDependency(quarterDepthRt, TextureUsageBit::kFramebufferWrite);
+		pass.newTextureDependency(halfDepthRt, TextureUsageBit::kSampledFragment);
 	}
 
 	// SSAO
 	RenderTargetHandle ssaoRt = descr.newRenderTarget(newRTDescr("SSAO"));
 	{
 		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("SSAO main");
-		pass.newDependency({ssaoRt, TextureUsageBit::kFramebufferWrite});
-		pass.newDependency({quarterDepthRt, TextureUsageBit::kSampledFragment});
-		pass.newDependency({gbuffRt2, TextureUsageBit::kSampledFragment});
+		pass.newTextureDependency(ssaoRt, TextureUsageBit::kFramebufferWrite);
+		pass.newTextureDependency(quarterDepthRt, TextureUsageBit::kSampledFragment);
+		pass.newTextureDependency(gbuffRt2, TextureUsageBit::kSampledFragment);
 
 		RenderTargetHandle ssaoVBlurRt = descr.newRenderTarget(newRTDescr("SSAO tmp"));
 		GraphicsRenderPassDescription& pass2 = descr.newGraphicsRenderPass("SSAO vblur");
-		pass2.newDependency({ssaoRt, TextureUsageBit::kSampledFragment});
-		pass2.newDependency({ssaoVBlurRt, TextureUsageBit::kFramebufferWrite});
+		pass2.newTextureDependency(ssaoRt, TextureUsageBit::kSampledFragment);
+		pass2.newTextureDependency(ssaoVBlurRt, TextureUsageBit::kFramebufferWrite);
 
 		GraphicsRenderPassDescription& pass3 = descr.newGraphicsRenderPass("SSAO hblur");
-		pass3.newDependency({ssaoRt, TextureUsageBit::kFramebufferWrite});
-		pass3.newDependency({ssaoVBlurRt, TextureUsageBit::kSampledFragment});
+		pass3.newTextureDependency(ssaoRt, TextureUsageBit::kFramebufferWrite);
+		pass3.newTextureDependency(ssaoVBlurRt, TextureUsageBit::kSampledFragment);
 	}
 
 	// Volumetric
 	RenderTargetHandle volRt = descr.newRenderTarget(newRTDescr("Vol"));
 	{
 		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("Vol main");
-		pass.newDependency({volRt, TextureUsageBit::kFramebufferWrite});
-		pass.newDependency({quarterDepthRt, TextureUsageBit::kSampledFragment});
+		pass.newTextureDependency(volRt, TextureUsageBit::kFramebufferWrite);
+		pass.newTextureDependency(quarterDepthRt, TextureUsageBit::kSampledFragment);
 
 		RenderTargetHandle volVBlurRt = descr.newRenderTarget(newRTDescr("Vol tmp"));
 		GraphicsRenderPassDescription& pass2 = descr.newGraphicsRenderPass("Vol vblur");
-		pass2.newDependency({volRt, TextureUsageBit::kSampledFragment});
-		pass2.newDependency({volVBlurRt, TextureUsageBit::kFramebufferWrite});
+		pass2.newTextureDependency(volRt, TextureUsageBit::kSampledFragment);
+		pass2.newTextureDependency(volVBlurRt, TextureUsageBit::kFramebufferWrite);
 
 		GraphicsRenderPassDescription& pass3 = descr.newGraphicsRenderPass("Vol hblur");
-		pass3.newDependency({volRt, TextureUsageBit::kFramebufferWrite});
-		pass3.newDependency({volVBlurRt, TextureUsageBit::kSampledFragment});
+		pass3.newTextureDependency(volRt, TextureUsageBit::kFramebufferWrite);
+		pass3.newTextureDependency(volVBlurRt, TextureUsageBit::kSampledFragment);
 	}
 
 	// Forward shading
 	RenderTargetHandle fsRt = descr.newRenderTarget(newRTDescr("FS"));
 	{
 		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("Forward shading");
-		pass.newDependency({fsRt, TextureUsageBit::kFramebufferWrite});
-		pass.newDependency({halfDepthRt, TextureUsageBit::kSampledFragment | TextureUsageBit::kFramebufferRead});
-		pass.newDependency({volRt, TextureUsageBit::kSampledFragment});
+		pass.newTextureDependency(fsRt, TextureUsageBit::kFramebufferWrite);
+		pass.newTextureDependency(halfDepthRt, TextureUsageBit::kSampledFragment | TextureUsageBit::kFramebufferRead);
+		pass.newTextureDependency(volRt, TextureUsageBit::kSampledFragment);
 	}
 
 	// Light shading
@@ -1666,15 +1666,15 @@ ANKI_TEST(Gr, RenderGraph)
 	{
 		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("Light shading");
 
-		pass.newDependency({lightRt, TextureUsageBit::kFramebufferWrite});
-		pass.newDependency({gbuffRt0, TextureUsageBit::kSampledFragment});
-		pass.newDependency({gbuffRt1, TextureUsageBit::kSampledFragment});
-		pass.newDependency({gbuffRt2, TextureUsageBit::kSampledFragment});
-		pass.newDependency({gbuffDepth, TextureUsageBit::kSampledFragment});
-		pass.newDependency({smExpRt, TextureUsageBit::kSampledFragment});
-		pass.newDependency({giGiLightRt, TextureUsageBit::kSampledFragment});
-		pass.newDependency({ssaoRt, TextureUsageBit::kSampledFragment});
-		pass.newDependency({fsRt, TextureUsageBit::kSampledFragment});
+		pass.newTextureDependency(lightRt, TextureUsageBit::kFramebufferWrite);
+		pass.newTextureDependency(gbuffRt0, TextureUsageBit::kSampledFragment);
+		pass.newTextureDependency(gbuffRt1, TextureUsageBit::kSampledFragment);
+		pass.newTextureDependency(gbuffRt2, TextureUsageBit::kSampledFragment);
+		pass.newTextureDependency(gbuffDepth, TextureUsageBit::kSampledFragment);
+		pass.newTextureDependency(smExpRt, TextureUsageBit::kSampledFragment);
+		pass.newTextureDependency(giGiLightRt, TextureUsageBit::kSampledFragment);
+		pass.newTextureDependency(ssaoRt, TextureUsageBit::kSampledFragment);
+		pass.newTextureDependency(fsRt, TextureUsageBit::kSampledFragment);
 	}
 
 	// TAA
@@ -1683,9 +1683,9 @@ ANKI_TEST(Gr, RenderGraph)
 	{
 		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("Temporal AA");
 
-		pass.newDependency({lightRt, TextureUsageBit::kSampledFragment});
-		pass.newDependency({taaRt, TextureUsageBit::kFramebufferWrite});
-		pass.newDependency({taaHistoryRt, TextureUsageBit::kSampledFragment});
+		pass.newTextureDependency(lightRt, TextureUsageBit::kSampledFragment);
+		pass.newTextureDependency(taaRt, TextureUsageBit::kFramebufferWrite);
+		pass.newTextureDependency(taaHistoryRt, TextureUsageBit::kSampledFragment);
 	}
 
 	rgraph->compileNewGraph(descr, pool);