Move some barriers to the new interface

AnKi/Gr/CommandBuffer.h

@@ -361,20 +361,24 @@ public:
 
 	/// @name Sync
 	/// @{
-	void setTextureBarrier(const TexturePtr& tex, TextureUsageBit prevUsage, TextureUsageBit nextUsage,
-						   const TextureSubresourceInfo& subresource);
+	[[deprecated]] void setTextureBarrier(const TexturePtr& tex, TextureUsageBit prevUsage, TextureUsageBit nextUsage,
+										  const TextureSubresourceInfo& subresource);
 
-	void setTextureSurfaceBarrier(const TexturePtr& tex, TextureUsageBit prevUsage, TextureUsageBit nextUsage,
-								  const TextureSurfaceInfo& surf);
+	[[deprecated]] void setTextureSurfaceBarrier(const TexturePtr& tex, TextureUsageBit prevUsage,
+												 TextureUsageBit nextUsage, const TextureSurfaceInfo& surf);
 
-	void setTextureVolumeBarrier(const TexturePtr& tex, TextureUsageBit prevUsage, TextureUsageBit nextUsage,
-								 const TextureVolumeInfo& vol);
+	[[deprecated]] void setTextureVolumeBarrier(const TexturePtr& tex, TextureUsageBit prevUsage,
+												TextureUsageBit nextUsage, const TextureVolumeInfo& vol);
 
-	void setBufferBarrier(const BufferPtr& buff, BufferUsageBit prevUsage, BufferUsageBit nextUsage, PtrSize offset,
-						  PtrSize size);
+	[[deprecated]] void setBufferBarrier(const BufferPtr& buff, BufferUsageBit prevUsage, BufferUsageBit nextUsage,
+										 PtrSize offset, PtrSize size);
 
-	void setAccelerationStructureBarrier(const AccelerationStructurePtr& as, AccelerationStructureUsageBit prevUsage,
-										 AccelerationStructureUsageBit nextUsage);
+	[[deprecated]] void setAccelerationStructureBarrier(const AccelerationStructurePtr& as,
+														AccelerationStructureUsageBit prevUsage,
+														AccelerationStructureUsageBit nextUsage);
+
+	void setPipelineBarrier(ConstWeakArray<TextureBarrierInfo> textures, ConstWeakArray<BufferBarrierInfo> buffers,
+							ConstWeakArray<AccelerationStructureBarrierInfo> accelerationStructures);
 	/// @}
 
 	/// @name Other

AnKi/Gr/Common.h

@@ -1014,12 +1014,27 @@ public:
 		ANKI_ASSERT(_m_padding[0] == 0);
 		return anki::computeHash(this, sizeof(*this));
 	}
+
+	Bool overlapsWith(const TextureSubresourceInfo& b) const
+	{
+		auto overlaps = [](U32 beginA, U32 countA, U32 beginB, U32 countB) -> Bool {
+			return (beginA < beginB) ? (beginA + countA > beginB) : (beginB + countB > beginA);
+		};
+
+		const Bool depthStencilOverlaps = (m_depthStencilAspect == DepthStencilAspectBit::NONE
+										   && b.m_depthStencilAspect == DepthStencilAspectBit::NONE)
+										  || !!(m_depthStencilAspect & b.m_depthStencilAspect);
+
+		return overlaps(m_firstMipmap, m_mipmapCount, b.m_firstMipmap, b.m_mipmapCount)
+			   && overlaps(m_firstLayer, m_layerCount, b.m_firstLayer, b.m_layerCount)
+			   && overlaps(m_firstFace, m_faceCount, b.m_firstFace, b.m_faceCount) && depthStencilOverlaps;
+	}
 };
 
 class TextureBarrierInfo
 {
 public:
-	TexturePtr m_texture;
+	Texture* m_texture = nullptr;
 	TextureUsageBit m_previousUsage = TextureUsageBit::NONE;
 	TextureUsageBit m_nextUsage = TextureUsageBit::NONE;
 	TextureSubresourceInfo m_subresource;
@@ -1028,7 +1043,7 @@ public:
 class BufferBarrierInfo
 {
 public:
-	BufferPtr m_buffer;
+	Buffer* m_buffer = nullptr;
 	BufferUsageBit m_previousUsage = BufferUsageBit::NONE;
 	BufferUsageBit m_nextUsage = BufferUsageBit::NONE;
 	PtrSize m_offset = 0;
@@ -1038,7 +1053,7 @@ public:
 class AccelerationStructureBarrierInfo
 {
 public:
-	AccelerationStructurePtr m_as;
+	AccelerationStructure* m_as = nullptr;
 	AccelerationStructureUsageBit m_previousUsage = AccelerationStructureUsageBit::NONE;
 	AccelerationStructureUsageBit m_nextUsage = AccelerationStructureUsageBit::NONE;
 };

AnKi/Gr/Vulkan/CommandBuffer.cpp

@@ -408,6 +408,14 @@ void CommandBuffer::setAccelerationStructureBarrier(const AccelerationStructureP
 	self.setAccelerationStructureBarrierInternal(as, prevUsage, nextUsage);
 }
 
+void CommandBuffer::setPipelineBarrier(ConstWeakArray<TextureBarrierInfo> textures,
+									   ConstWeakArray<BufferBarrierInfo> buffers,
+									   ConstWeakArray<AccelerationStructureBarrierInfo> accelerationStructures)
+{
+	ANKI_VK_SELF(CommandBufferImpl);
+	self.setPipelineBarrierInternal(textures, buffers, accelerationStructures);
+}
+
 void CommandBuffer::resetOcclusionQuery(const OcclusionQueryPtr& query)
 {
 	ANKI_VK_SELF(CommandBufferImpl);

AnKi/Gr/Vulkan/CommandBufferFactory.h

@@ -85,6 +85,12 @@ public:
 		pushToArray(m_objectRefs[T::CLASS_TYPE], x.get());
 	}
 
+	template<typename T>
+	void pushObjectRef(T* x)
+	{
+		pushToArray(m_objectRefs[T::CLASS_TYPE], x);
+	}
+
 	CommandBufferFlag getFlags() const
 	{
 		return m_flags;

AnKi/Gr/Vulkan/CommandBufferImpl.cpp

@@ -888,4 +888,135 @@ void CommandBufferImpl::upscaleInternal(const GrUpscalerPtr& upscaler, const Tex
 #endif
 }
 
+void CommandBufferImpl::setPipelineBarrierInternal(
+	ConstWeakArray<TextureBarrierInfo> textures, ConstWeakArray<BufferBarrierInfo> buffers,
+	ConstWeakArray<AccelerationStructureBarrierInfo> accelerationStructures)
+{
+	commandCommon();
+
+	DynamicArrayAuto<VkImageMemoryBarrier> imageBarriers(m_alloc);
+	DynamicArrayAuto<VkBufferMemoryBarrier> bufferBarriers(m_alloc);
+	DynamicArrayAuto<VkMemoryBarrier> genericBarriers(m_alloc);
+	VkPipelineStageFlags srcStageMask = 0;
+	VkPipelineStageFlags dstStageMask = 0;
+
+	for(const TextureBarrierInfo& barrier : textures)
+	{
+		ANKI_ASSERT(barrier.m_texture);
+		const TextureImpl& impl = static_cast<const TextureImpl&>(*barrier.m_texture);
+		const TextureUsageBit nextUsage = barrier.m_nextUsage;
+		const TextureUsageBit prevUsage = barrier.m_previousUsage;
+		TextureSubresourceInfo subresource = barrier.m_subresource;
+
+		ANKI_ASSERT(impl.usageValid(prevUsage));
+		ANKI_ASSERT(impl.usageValid(nextUsage));
+		ANKI_ASSERT(((nextUsage & TextureUsageBit::GENERATE_MIPMAPS) == TextureUsageBit::GENERATE_MIPMAPS
+					 || (nextUsage & TextureUsageBit::GENERATE_MIPMAPS) == TextureUsageBit::NONE)
+					&& "GENERATE_MIPMAPS should be alone");
+		ANKI_ASSERT(impl.isSubresourceValid(subresource));
+
+		if(ANKI_UNLIKELY(subresource.m_firstMipmap > 0 && nextUsage == TextureUsageBit::GENERATE_MIPMAPS))
+		{
+			// This transition happens inside CommandBufferImpl::generateMipmapsX. No need to do something
+			continue;
+		}
+
+		if(ANKI_UNLIKELY(nextUsage == TextureUsageBit::GENERATE_MIPMAPS))
+		{
+			// 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;
+		}
+
+		VkImageMemoryBarrier& inf = *imageBarriers.emplaceBack();
+		inf = {};
+		inf.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+		inf.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+		inf.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+		inf.image = impl.m_imageHandle;
+
+		impl.computeVkImageSubresourceRange(subresource, inf.subresourceRange);
+
+		VkPipelineStageFlags srcStage;
+		VkPipelineStageFlags dstStage;
+		impl.computeBarrierInfo(prevUsage, nextUsage, inf.subresourceRange.baseMipLevel, srcStage, inf.srcAccessMask,
+								dstStage, inf.dstAccessMask);
+		inf.oldLayout = impl.computeLayout(prevUsage, inf.subresourceRange.baseMipLevel);
+		inf.newLayout = impl.computeLayout(nextUsage, inf.subresourceRange.baseMipLevel);
+
+		srcStageMask |= srcStage;
+		dstStageMask |= dstStage;
+
+		m_microCmdb->pushObjectRef(barrier.m_texture);
+	}
+
+	for(const BufferBarrierInfo& barrier : buffers)
+	{
+		ANKI_ASSERT(barrier.m_buffer);
+		const BufferImpl& impl = static_cast<const BufferImpl&>(*barrier.m_buffer);
+
+		const BufferUsageBit prevUsage = barrier.m_previousUsage;
+		const BufferUsageBit nextUsage = barrier.m_nextUsage;
+
+		VkBufferMemoryBarrier& inf = *bufferBarriers.emplaceBack();
+		inf = {};
+		inf.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
+		inf.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+		inf.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+		inf.buffer = impl.getHandle();
+
+		ANKI_ASSERT(barrier.m_offset < impl.getSize());
+		inf.offset = barrier.m_offset;
+
+		if(barrier.m_size == MAX_PTR_SIZE)
+		{
+			inf.size = VK_WHOLE_SIZE;
+		}
+		else
+		{
+			ANKI_ASSERT(barrier.m_size > 0);
+			ANKI_ASSERT(barrier.m_offset + barrier.m_size <= impl.getSize());
+			inf.size = barrier.m_size;
+		}
+
+		VkPipelineStageFlags srcStage;
+		VkPipelineStageFlags dstStage;
+		impl.computeBarrierInfo(prevUsage, nextUsage, srcStage, inf.srcAccessMask, dstStage, inf.dstAccessMask);
+
+		srcStageMask |= srcStage;
+		dstStageMask |= dstStage;
+
+		m_microCmdb->pushObjectRef(barrier.m_buffer);
+	}
+
+	for(const AccelerationStructureBarrierInfo& barrier : accelerationStructures)
+	{
+		ANKI_ASSERT(barrier.m_as);
+
+		VkMemoryBarrier& inf = *genericBarriers.emplaceBack();
+		inf = {};
+		inf.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER;
+
+		VkPipelineStageFlags srcStage;
+		VkPipelineStageFlags dstStage;
+		AccelerationStructureImpl::computeBarrierInfo(barrier.m_previousUsage, barrier.m_nextUsage, srcStage,
+													  inf.srcAccessMask, dstStage, inf.dstAccessMask);
+
+		srcStageMask |= srcStage;
+		dstStageMask |= dstStage;
+
+		m_microCmdb->pushObjectRef(barrier.m_as);
+	}
+
+	vkCmdPipelineBarrier(m_handle, srcStageMask, dstStageMask, 0, genericBarriers.getSize(),
+						 (genericBarriers.getSize()) ? &genericBarriers[0] : nullptr, bufferBarriers.getSize(),
+						 (bufferBarriers.getSize()) ? &bufferBarriers[0] : nullptr, imageBarriers.getSize(),
+						 (imageBarriers.getSize()) ? &imageBarriers[0] : nullptr);
+
+	ANKI_TRACE_INC_COUNTER(VK_PIPELINE_BARRIERS, 1);
+}
+
 } // end namespace anki

AnKi/Gr/Vulkan/CommandBufferImpl.h

@@ -360,6 +360,10 @@ public:
 												 AccelerationStructureUsageBit prevUsage,
 												 AccelerationStructureUsageBit nextUsage);
 
+	void setPipelineBarrierInternal(ConstWeakArray<TextureBarrierInfo> textures,
+									ConstWeakArray<BufferBarrierInfo> buffers,
+									ConstWeakArray<AccelerationStructureBarrierInfo> accelerationStructures);
+
 	void fillBufferInternal(const BufferPtr& buff, PtrSize offset, PtrSize size, U32 value);
 
 	void writeOcclusionQueryResultToBufferInternal(const OcclusionQueryPtr& query, PtrSize offset,

AnKi/Renderer/DepthDownscale.cpp

@@ -251,8 +251,9 @@ void DepthDownscale::runCompute(RenderPassWorkContext& rgraphCtx)
 
 		cmdb->fillBuffer(m_counterBuffer, 0, MAX_PTR_SIZE, 0);
 
-		cmdb->setBufferBarrier(m_counterBuffer, BufferUsageBit::TRANSFER_DESTINATION,
-							   BufferUsageBit::STORAGE_COMPUTE_WRITE, 0, MAX_PTR_SIZE);
+		const BufferBarrierInfo barrier = {m_counterBuffer.get(), BufferUsageBit::TRANSFER_DESTINATION,
+										   BufferUsageBit::STORAGE_COMPUTE_WRITE, 0, MAX_PTR_SIZE};
+		cmdb->setPipelineBarrier({}, {&barrier, 1}, {});
 	}
 
 	cmdb->bindShaderProgram(m_grProg);

AnKi/Renderer/Renderer.cpp

@@ -526,16 +526,19 @@ TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, Text
 					}
 					FramebufferPtr fb = m_gr->newFramebuffer(fbInit);
 
-					cmdb->setTextureSurfaceBarrier(tex, TextureUsageBit::NONE,
-												   TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE, surf);
+					TextureBarrierInfo barrier = {tex.get(), TextureUsageBit::NONE,
+												  TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE, surf};
+					barrier.m_subresource.m_depthStencilAspect = tex->getDepthStencilAspect();
+					cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
 					cmdb->beginRenderPass(fb, colUsage, dsUsage);
 					cmdb->endRenderPass();
 
 					if(!!initialUsage)
 					{
-						cmdb->setTextureSurfaceBarrier(tex, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE, initialUsage,
-													   surf);
+						barrier.m_previousUsage = TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE;
+						barrier.m_nextUsage = initialUsage;
+						cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 					}
 				}
 				else
@@ -570,8 +573,9 @@ TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, Text
 					TextureViewPtr view = getGrManager().newTextureView(TextureViewInitInfo(tex, surf));
 					cmdb->bindImage(0, 0, view);
 
-					cmdb->setTextureSurfaceBarrier(tex, TextureUsageBit::NONE, TextureUsageBit::IMAGE_COMPUTE_WRITE,
-												   surf);
+					const TextureBarrierInfo barrier = {tex.get(), TextureUsageBit::NONE,
+														TextureUsageBit::IMAGE_COMPUTE_WRITE, surf};
+					cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
 					UVec3 wgSize;
 					wgSize.x() = (8 - 1 + (tex->getWidth() >> mip)) / 8;
@@ -582,7 +586,10 @@ TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, Text
 
 					if(!!initialUsage)
 					{
-						cmdb->setTextureSurfaceBarrier(tex, TextureUsageBit::IMAGE_COMPUTE_WRITE, initialUsage, surf);
+						const TextureBarrierInfo barrier = {tex.get(), TextureUsageBit::IMAGE_COMPUTE_WRITE,
+															initialUsage, surf};
+
+						cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 					}
 				}
 			}

AnKi/Resource/ImageResource.cpp

@@ -217,7 +217,9 @@ Error ImageResource::load(const ResourceFilename& filename, Bool async)
 		subresource.m_layerCount = init.m_layerCount;
 		subresource.m_mipmapCount = init.m_mipmapCount;
 
-		cmdb->setTextureBarrier(m_tex, TextureUsageBit::NONE, TextureUsageBit::ALL_SAMPLED, subresource);
+		const TextureBarrierInfo barrier = {m_tex.get(), TextureUsageBit::NONE, TextureUsageBit::ALL_SAMPLED,
+											subresource};
+		cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
 		FencePtr outFence;
 		cmdb->flush({}, &outFence);
@@ -266,24 +268,27 @@ Error ImageResource::load(LoadingContext& ctx)
 		CommandBufferPtr cmdb = ctx.m_gr->newCommandBuffer(ci);
 
 		// Set the barriers of the batch
+		Array<TextureBarrierInfo, MAX_COPIES_BEFORE_FLUSH> barriers;
+		U32 barrierCount = 0;
 		for(U32 i = begin; i < end; ++i)
 		{
 			U32 mip, layer, face;
 			unflatten3dArrayIndex(ctx.m_layerCount, ctx.m_faces, ctx.m_loader.getMipmapCount(), i, layer, face, mip);
 
+			TextureBarrierInfo& barrier = barriers[barrierCount++];
+			barrier = {ctx.m_tex.get(), TextureUsageBit::NONE, TextureUsageBit::TRANSFER_DESTINATION};
+
 			if(ctx.m_texType == TextureType::_3D)
 			{
+				barrier.m_subresource = TextureVolumeInfo(mip);
 				TextureVolumeInfo vol(mip);
-				cmdb->setTextureVolumeBarrier(ctx.m_tex, TextureUsageBit::NONE, TextureUsageBit::TRANSFER_DESTINATION,
-											  vol);
 			}
 			else
 			{
-				TextureSurfaceInfo surf(mip, 0, face, layer);
-				cmdb->setTextureSurfaceBarrier(ctx.m_tex, TextureUsageBit::NONE, TextureUsageBit::TRANSFER_DESTINATION,
-											   surf);
+				barrier.m_subresource = TextureSurfaceInfo(mip, 0, face, layer);
 			}
 		}
+		cmdb->setPipelineBarrier({&barriers[0], barrierCount}, {}, {});
 
 		// Do the copies
 		Array<TransferGpuAllocatorHandle, MAX_COPIES_BEFORE_FLUSH> handles;
@@ -341,26 +346,26 @@ Error ImageResource::load(LoadingContext& ctx)
 		}
 
 		// Set the barriers of the batch
+		barrierCount = 0;
 		for(U32 i = begin; i < end; ++i)
 		{
 			U32 mip, layer, face;
 			unflatten3dArrayIndex(ctx.m_layerCount, ctx.m_faces, ctx.m_loader.getMipmapCount(), i, layer, face, mip);
 
+			TextureBarrierInfo& barrier = barriers[barrierCount++];
+			barrier.m_previousUsage = TextureUsageBit::TRANSFER_DESTINATION;
+			barrier.m_nextUsage = TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::SAMPLED_GEOMETRY;
+
 			if(ctx.m_texType == TextureType::_3D)
 			{
-				TextureVolumeInfo vol(mip);
-				cmdb->setTextureVolumeBarrier(ctx.m_tex, TextureUsageBit::TRANSFER_DESTINATION,
-											  TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::SAMPLED_GEOMETRY,
-											  vol);
+				barrier.m_subresource = TextureVolumeInfo(mip);
 			}
 			else
 			{
-				TextureSurfaceInfo surf(mip, 0, face, layer);
-				cmdb->setTextureSurfaceBarrier(ctx.m_tex, TextureUsageBit::TRANSFER_DESTINATION,
-											   TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::SAMPLED_GEOMETRY,
-											   surf);
+				barrier.m_subresource = TextureSurfaceInfo(mip, 0, face, layer);
 			}
 		}
+		cmdb->setPipelineBarrier({&barriers[0], barrierCount}, {}, {});
 
 		// Flush batch
 		FencePtr fence;

AnKi/Resource/MeshResource.cpp

@@ -181,8 +181,10 @@ Error MeshResource::load(const ResourceFilename& filename, Bool async)
 		cmdb->fillBuffer(m_vertexBuffer, m_vertexBuffersOffset, m_vertexBuffersSize, 0);
 		cmdb->fillBuffer(m_vertexBuffer, m_indexBufferOffset, indexBufferSize, 0);
 
-		cmdb->setBufferBarrier(m_vertexBuffer, BufferUsageBit::TRANSFER_DESTINATION, BufferUsageBit::VERTEX, 0,
-							   MAX_PTR_SIZE);
+		const BufferBarrierInfo barrier = {m_vertexBuffer.get(), BufferUsageBit::TRANSFER_DESTINATION,
+										   BufferUsageBit::VERTEX, 0, MAX_PTR_SIZE};
+
+		cmdb->setPipelineBarrier({}, {&barrier, 1}, {});
 
 		cmdb->flush();
 	}
@@ -278,8 +280,9 @@ Error MeshResource::loadAsync(MeshBinaryLoader& loader) const
 	CommandBufferPtr cmdb = gr.newCommandBuffer(cmdbinit);
 
 	// Set barriers
-	cmdb->setBufferBarrier(m_vertexBuffer, BufferUsageBit::VERTEX, BufferUsageBit::TRANSFER_DESTINATION, 0,
-						   MAX_PTR_SIZE);
+	const BufferBarrierInfo barrier = {m_vertexBuffer.get(), BufferUsageBit::VERTEX,
+									   BufferUsageBit::TRANSFER_DESTINATION, 0, MAX_PTR_SIZE};
+	cmdb->setPipelineBarrier({}, {&barrier, 1}, {});
 
 	// Write index buffer
 	{
@@ -322,23 +325,28 @@ Error MeshResource::loadAsync(MeshBinaryLoader& loader) const
 	// Build the BLAS
 	if(gr.getDeviceCapabilities().m_rayTracingEnabled)
 	{
-		cmdb->setBufferBarrier(m_vertexBuffer, BufferUsageBit::TRANSFER_DESTINATION,
-							   BufferUsageBit::ACCELERATION_STRUCTURE_BUILD | BufferUsageBit::VERTEX
-								   | BufferUsageBit::INDEX,
-							   0, MAX_PTR_SIZE);
+		const BufferBarrierInfo buffBarrier = {m_vertexBuffer.get(), BufferUsageBit::TRANSFER_DESTINATION,
+											   BufferUsageBit::ACCELERATION_STRUCTURE_BUILD | BufferUsageBit::VERTEX
+												   | BufferUsageBit::INDEX,
+											   0, MAX_PTR_SIZE};
+		const AccelerationStructureBarrierInfo asBarrier = {m_blas.get(), AccelerationStructureUsageBit::NONE,
+															AccelerationStructureUsageBit::BUILD};
 
-		cmdb->setAccelerationStructureBarrier(m_blas, AccelerationStructureUsageBit::NONE,
-											  AccelerationStructureUsageBit::BUILD);
+		cmdb->setPipelineBarrier({}, {&buffBarrier, 1}, {&asBarrier, 1});
 
 		cmdb->buildAccelerationStructure(m_blas);
 
-		cmdb->setAccelerationStructureBarrier(m_blas, AccelerationStructureUsageBit::BUILD,
-											  AccelerationStructureUsageBit::ALL_READ);
+		const AccelerationStructureBarrierInfo asBarrier2 = {m_blas.get(), AccelerationStructureUsageBit::BUILD,
+															 AccelerationStructureUsageBit::ALL_READ};
+
+		cmdb->setPipelineBarrier({}, {}, {&asBarrier2, 1});
 	}
 	else
 	{
-		cmdb->setBufferBarrier(m_vertexBuffer, BufferUsageBit::TRANSFER_DESTINATION,
-							   BufferUsageBit::VERTEX | BufferUsageBit::INDEX, 0, MAX_PTR_SIZE);
+		const BufferBarrierInfo buffBarrier = {m_vertexBuffer.get(), BufferUsageBit::TRANSFER_DESTINATION,
+											   BufferUsageBit::VERTEX | BufferUsageBit::INDEX, 0, MAX_PTR_SIZE};
+
+		cmdb->setPipelineBarrier({}, {&buffBarrier, 1}, {});
 	}
 
 	// Finalize

AnKi/Ui/Font.cpp

@@ -97,19 +97,25 @@ void Font::createTexture(const void* data, U32 width, U32 height)
 	CommandBufferInitInfo cmdbInit;
 	cmdbInit.m_flags = CommandBufferFlag::GENERAL_WORK | CommandBufferFlag::SMALL_BATCH;
 	CommandBufferPtr cmdb = m_manager->getGrManager().newCommandBuffer(cmdbInit);
-	{
-		TextureViewInitInfo viewInit(m_tex, surf, DepthStencilAspectBit::NONE, "TempFont");
-		TextureViewPtr tmpView = m_manager->getGrManager().newTextureView(viewInit);
 
-		cmdb->setTextureSurfaceBarrier(m_tex, TextureUsageBit::NONE, TextureUsageBit::TRANSFER_DESTINATION, surf);
-		cmdb->copyBufferToTextureView(buff, 0, buffSize, tmpView);
-		cmdb->setTextureSurfaceBarrier(m_tex, TextureUsageBit::TRANSFER_DESTINATION, TextureUsageBit::GENERATE_MIPMAPS,
-									   surf);
-	}
+	TextureViewInitInfo viewInit(m_tex, surf, DepthStencilAspectBit::NONE, "TempFont");
+	TextureViewPtr tmpView = m_manager->getGrManager().newTextureView(viewInit);
+
+	TextureBarrierInfo barrier = {m_tex.get(), TextureUsageBit::NONE, TextureUsageBit::TRANSFER_DESTINATION, surf};
+	cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
+
+	cmdb->copyBufferToTextureView(buff, 0, buffSize, tmpView);
+
+	barrier.m_previousUsage = TextureUsageBit::TRANSFER_DESTINATION;
+	barrier.m_nextUsage = TextureUsageBit::GENERATE_MIPMAPS;
+	cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
 	// Gen mips
 	cmdb->generateMipmaps2d(m_texView);
-	cmdb->setTextureSurfaceBarrier(m_tex, TextureUsageBit::GENERATE_MIPMAPS, TextureUsageBit::SAMPLED_FRAGMENT, surf);
+
+	barrier.m_previousUsage = TextureUsageBit::GENERATE_MIPMAPS;
+	barrier.m_nextUsage = TextureUsageBit::SAMPLED_FRAGMENT;
+	cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
 	cmdb->flush();
 }