Vulkan: Add some last bits for buffer barriers

src/anki/gr/CommandBuffer.inl.h

@@ -16,8 +16,8 @@ inline void CommandBuffer::uploadTextureSurfaceData(TexturePtr tex,
 	PtrSize& dataSize)
 {
 	PtrSize allocationSize;
-	BufferUsageBit usage;
-	getManager().getTextureSurfaceUploadInfo(tex, surf, allocationSize, usage);
+	const BufferUsageBit usage = BufferUsageBit::TEXTURE_UPLOAD_SOURCE;
+	getManager().getTextureSurfaceUploadInfo(tex, surf, allocationSize);
 	ANKI_ASSERT(dataSize <= allocationSize);
 
 	TransientMemoryToken token;
@@ -34,8 +34,8 @@ inline void CommandBuffer::tryUploadTextureSurfaceData(TexturePtr tex,
 	PtrSize& dataSize)
 {
 	PtrSize allocationSize;
-	BufferUsageBit usage;
-	getManager().getTextureSurfaceUploadInfo(tex, surf, allocationSize, usage);
+	const BufferUsageBit usage = BufferUsageBit::TEXTURE_UPLOAD_SOURCE;
+	getManager().getTextureSurfaceUploadInfo(tex, surf, allocationSize);
 	ANKI_ASSERT(dataSize <= allocationSize);
 
 	TransientMemoryToken token;
@@ -55,8 +55,8 @@ inline void CommandBuffer::uploadTextureSurfaceCopyData(TexturePtr tex,
 	PtrSize dataSize)
 {
 	PtrSize allocationSize;
-	BufferUsageBit usage;
-	getManager().getTextureSurfaceUploadInfo(tex, surf, allocationSize, usage);
+	const BufferUsageBit usage = BufferUsageBit::TEXTURE_UPLOAD_SOURCE;
+	getManager().getTextureSurfaceUploadInfo(tex, surf, allocationSize);
 	ANKI_ASSERT(dataSize <= allocationSize);
 
 	TransientMemoryToken token;
@@ -72,8 +72,8 @@ inline void CommandBuffer::uploadTextureVolumeCopyData(
 	TexturePtr tex, const TextureVolumeInfo& vol, void* data, PtrSize dataSize)
 {
 	PtrSize allocationSize;
-	BufferUsageBit usage;
-	getManager().getTextureVolumeUploadInfo(tex, vol, allocationSize, usage);
+	const BufferUsageBit usage = BufferUsageBit::TEXTURE_UPLOAD_SOURCE;
+	getManager().getTextureVolumeUploadInfo(tex, vol, allocationSize);
 	ANKI_ASSERT(dataSize <= allocationSize);
 
 	TransientMemoryToken token;

src/anki/gr/Enums.h

@@ -338,32 +338,50 @@ enum class BufferUsageBit : U32
 		| UNIFORM_FRAGMENT,
 	UNIFORM_ALL = UNIFORM_ALL_GRAPHICS | UNIFORM_COMPUTE,
 
-	STORAGE_VERTEX = 1 << 6,
-	STORAGE_TESSELLATION_EVALUATION = 1 << 7,
-	STORAGE_TESSELLATION_CONTROL = 1 << 8,
-	STORAGE_GEOMETRY = 1 << 9,
-	STORAGE_FRAGMENT = 1 << 10,
-	STORAGE_COMPUTE_READ = 1 << 11,
-	STORAGE_COMPUTE_WRITE = 1 << 12,
+	STORAGE_VERTEX_READ = 1 << 6,
+	STORAGE_VERTEX_WRITE = 1 << 7,
+	STORAGE_VERTEX_READ_WRITE = STORAGE_VERTEX_READ | STORAGE_VERTEX_WRITE,
+	STORAGE_TESSELLATION_EVALUATION_READ = 1 << 8,
+	STORAGE_TESSELLATION_EVALUATION_WRITE = 1 << 9,
+	STORAGE_TESSELLATION_EVALUATION_READ_WRITE =
+		STORAGE_TESSELLATION_EVALUATION_READ
+		| STORAGE_TESSELLATION_EVALUATION_WRITE,
+	STORAGE_TESSELLATION_CONTROL_READ = 1 << 10,
+	STORAGE_TESSELLATION_CONTROL_WRITE = 1 << 11,
+	STORAGE_TESSELLATION_CONTROL_READ_WRITE =
+		STORAGE_TESSELLATION_CONTROL_READ | STORAGE_TESSELLATION_CONTROL_WRITE,
+	STORAGE_GEOMETRY_READ = 1 << 12,
+	STORAGE_GEOMETRY_WRITE = 1 << 13,
+	STORAGE_GEOMETRY_READ_WRITE =
+		STORAGE_GEOMETRY_READ | STORAGE_GEOMETRY_WRITE,
+	STORAGE_FRAGMENT_READ = 1 << 14,
+	STORAGE_FRAGMENT_WRITE = 1 << 15,
+	STORAGE_FRAGMENT_READ_WRITE =
+		STORAGE_FRAGMENT_READ | STORAGE_FRAGMENT_WRITE,
+	STORAGE_COMPUTE_READ = 1 << 16,
+	STORAGE_COMPUTE_WRITE = 1 << 17,
 	STORAGE_COMPUTE_READ_WRITE = STORAGE_COMPUTE_READ | STORAGE_COMPUTE_WRITE,
-	STORAGE_ALL_GRAPHICS = STORAGE_VERTEX | STORAGE_TESSELLATION_EVALUATION
-		| STORAGE_TESSELLATION_CONTROL
-		| STORAGE_GEOMETRY
-		| STORAGE_FRAGMENT,
-	STORAGE_ALL =
-		STORAGE_ALL_GRAPHICS | STORAGE_COMPUTE_READ | STORAGE_COMPUTE_WRITE,
-
-	INDEX = 1 << 13,
-	VERTEX = 1 << 14,
-	INDIRECT = 1 << 15,
-
-	TRANSFER_SOURCE = 1 << 16,
-	TRANSFER_DESTINATION = 1 << 17,
-	TRANSFER_ANY = TRANSFER_SOURCE | TRANSFER_DESTINATION,
-
-	FILL = 1 << 18,
-	UPLOAD_DESTINATION = 1 << 19,
-	TEXTURE_UPLOAD_SOURCE = 1 << 20, ///< Source for texture upload.
+	STORAGE_ALL_GRAPHICS = STORAGE_VERTEX_READ | STORAGE_VERTEX_WRITE
+		| STORAGE_TESSELLATION_EVALUATION_READ
+		| STORAGE_TESSELLATION_EVALUATION_WRITE
+		| STORAGE_TESSELLATION_CONTROL_READ
+		| STORAGE_TESSELLATION_CONTROL_WRITE
+		| STORAGE_GEOMETRY_READ
+		| STORAGE_GEOMETRY_WRITE
+		| STORAGE_FRAGMENT_READ
+		| STORAGE_FRAGMENT_WRITE,
+	STORAGE_ALL = STORAGE_ALL_GRAPHICS | STORAGE_COMPUTE_READ_WRITE,
+
+	INDEX = 1 << 18,
+	VERTEX = 1 << 19,
+	INDIRECT = 1 << 20,
+
+	FILL = 1 << 21,
+	BUFFER_UPLOAD_SOURCE = 1 << 22,
+	BUFFER_UPLOAD_DESTINATION = 1 << 23, ///< Destination of buffer upload.
+	TEXTURE_UPLOAD_SOURCE = 1 << 24, ///< Source for texture upload.
+	TRANSFER_ALL = FILL | BUFFER_UPLOAD_SOURCE | BUFFER_UPLOAD_DESTINATION
+		| TEXTURE_UPLOAD_SOURCE,
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(BufferUsageBit, inline)
 

src/anki/gr/GrManager.h

@@ -88,14 +88,12 @@ public:
 	/// the memory for internal use.
 	void getTextureSurfaceUploadInfo(TexturePtr tex,
 		const TextureSurfaceInfo& surf,
-		PtrSize& expectedTransientAllocationSize,
-		BufferUsageBit& usage);
+		PtrSize& expectedTransientAllocationSize);
 
 	/// Same as getTextureSurfaceUploadInfo but for volumes.
 	void getTextureVolumeUploadInfo(TexturePtr tex,
 		const TextureVolumeInfo& vol,
-		PtrSize& expectedTransientAllocationSize,
-		BufferUsageBit& usage);
+		PtrSize& expectedTransientAllocationSize);
 
 anki_internal:
 	GrAllocator<U8>& getAllocator()

src/anki/gr/common/Misc.h

@@ -37,8 +37,8 @@ inline TransientBufferType bufferUsageToTransient(BufferUsageBit bit)
 	}
 	else
 	{
-		ANKI_ASSERT(
-			(bit & BufferUsageBit::TRANSFER_SOURCE) != BufferUsageBit::NONE);
+		ANKI_ASSERT(!!(bit & (BufferUsageBit::BUFFER_UPLOAD_SOURCE
+								 | BufferUsageBit::TEXTURE_UPLOAD_SOURCE)));
 		return TransientBufferType::TRANSFER;
 	}
 }

src/anki/gr/gl/BufferImpl.cpp

@@ -82,7 +82,7 @@ void BufferImpl::init(
 	//
 	GLbitfield flags = 0;
 	Bool shouldMap = false;
-	if((usage & BufferUsageBit::TRANSFER_ANY) != BufferUsageBit::NONE)
+	if((usage & BufferUsageBit::TRANSFER_ALL) != BufferUsageBit::NONE)
 	{
 		flags |= GL_DYNAMIC_STORAGE_BIT;
 	}

src/anki/gr/gl/GrManager.cpp

@@ -96,10 +96,8 @@ void* GrManager::tryAllocateFrameTransientMemory(
 }
 
 //==============================================================================
-void GrManager::getTextureSurfaceUploadInfo(TexturePtr tex,
-	const TextureSurfaceInfo& surf,
-	PtrSize& allocationSize,
-	BufferUsageBit& usage)
+void GrManager::getTextureSurfaceUploadInfo(
+	TexturePtr tex, const TextureSurfaceInfo& surf, PtrSize& allocationSize)
 {
 	const TextureImpl& impl = tex->getImplementation();
 	impl.checkSurface(surf);
@@ -107,15 +105,11 @@ void GrManager::getTextureSurfaceUploadInfo(TexturePtr tex,
 	U width = impl.m_width >> surf.m_level;
 	U height = impl.m_height >> surf.m_level;
 	allocationSize = computeSurfaceSize(width, height, impl.m_pformat);
-
-	usage = BufferUsageBit::TRANSFER_SOURCE;
 }
 
 //==============================================================================
-void GrManager::getTextureVolumeUploadInfo(TexturePtr tex,
-	const TextureVolumeInfo& vol,
-	PtrSize& allocationSize,
-	BufferUsageBit& usage)
+void GrManager::getTextureVolumeUploadInfo(
+	TexturePtr tex, const TextureVolumeInfo& vol, PtrSize& allocationSize)
 {
 	const TextureImpl& impl = tex->getImplementation();
 	impl.checkVolume(vol);
@@ -124,8 +118,6 @@ void GrManager::getTextureVolumeUploadInfo(TexturePtr tex,
 	U height = impl.m_height >> vol.m_level;
 	U depth = impl.m_depth >> vol.m_level;
 	allocationSize = computeVolumeSize(width, height, depth, impl.m_pformat);
-
-	usage = BufferUsageBit::TRANSFER_SOURCE;
 }
 
 } // end namespace anki

src/anki/gr/vulkan/BufferImpl.cpp

@@ -169,4 +169,150 @@ void* BufferImpl::map(PtrSize offset, PtrSize range, BufferMapAccessBit access)
 	return static_cast<void*>(static_cast<U8*>(ptr) + offset);
 }
 
+//==============================================================================
+VkPipelineStageFlags BufferImpl::computePplineStage(BufferUsageBit usage)
+{
+	VkPipelineStageFlags stageMask = 0;
+
+	if(!!(usage & (BufferUsageBit::UNIFORM_VERTEX
+					  | BufferUsageBit::STORAGE_VERTEX_READ_WRITE)))
+	{
+		stageMask |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
+	}
+
+	if(!!(usage
+		   & (BufferUsageBit::UNIFORM_TESSELLATION_EVALUATION
+				 | BufferUsageBit::STORAGE_TESSELLATION_EVALUATION_READ_WRITE)))
+	{
+		stageMask |= VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT;
+	}
+
+	if(!!(usage
+		   & (BufferUsageBit::UNIFORM_TESSELLATION_CONTROL
+				 | BufferUsageBit::STORAGE_TESSELLATION_CONTROL_READ_WRITE)))
+	{
+		stageMask |= VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT;
+	}
+
+	if(!!(usage & (BufferUsageBit::UNIFORM_GEOMETRY
+					  | BufferUsageBit::STORAGE_GEOMETRY_READ_WRITE)))
+	{
+		stageMask |= VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
+	}
+
+	if(!!(usage & (BufferUsageBit::UNIFORM_FRAGMENT
+					  | BufferUsageBit::STORAGE_FRAGMENT_READ_WRITE)))
+	{
+		stageMask |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
+	}
+
+	if(!!(usage & (BufferUsageBit::UNIFORM_COMPUTE
+					  | BufferUsageBit::STORAGE_COMPUTE_READ_WRITE)))
+	{
+		stageMask |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
+	}
+
+	if(!!(usage & (BufferUsageBit::INDEX | BufferUsageBit::VERTEX)))
+	{
+		stageMask |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT
+			| VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT
+			| VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
+			| VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
+	}
+
+	if(!!(usage & BufferUsageBit::INDIRECT))
+	{
+		stageMask |= VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
+	}
+
+	if(!!(usage & (BufferUsageBit::TRANSFER_ALL)))
+	{
+		stageMask |= VK_PIPELINE_STAGE_TRANSFER_BIT;
+	}
+
+	ANKI_ASSERT(stageMask);
+	return stageMask;
+}
+
+//==============================================================================
+VkAccessFlags BufferImpl::computeAccessMask(BufferUsageBit usage)
+{
+	VkAccessFlags mask = 0;
+
+	const BufferUsageBit SHADER_READ = BufferUsageBit::STORAGE_VERTEX_READ
+		| BufferUsageBit::STORAGE_TESSELLATION_CONTROL_READ
+		| BufferUsageBit::STORAGE_TESSELLATION_EVALUATION_READ
+		| BufferUsageBit::STORAGE_GEOMETRY_READ
+		| BufferUsageBit::STORAGE_FRAGMENT_READ
+		| BufferUsageBit::STORAGE_COMPUTE_READ;
+
+	const BufferUsageBit SHADER_WRITE = BufferUsageBit::STORAGE_VERTEX_WRITE
+		| BufferUsageBit::STORAGE_TESSELLATION_CONTROL_WRITE
+		| BufferUsageBit::STORAGE_TESSELLATION_EVALUATION_WRITE
+		| BufferUsageBit::STORAGE_GEOMETRY_WRITE
+		| BufferUsageBit::STORAGE_FRAGMENT_WRITE
+		| BufferUsageBit::STORAGE_COMPUTE_WRITE;
+
+	if(!!(usage & BufferUsageBit::UNIFORM_ALL))
+	{
+		mask |= VK_ACCESS_UNIFORM_READ_BIT;
+	}
+
+	if(!!(usage & SHADER_READ))
+	{
+		mask |= VK_ACCESS_SHADER_READ_BIT;
+	}
+
+	if(!!(usage & SHADER_WRITE))
+	{
+		mask |= VK_ACCESS_SHADER_WRITE_BIT;
+	}
+
+	if(!!(usage & BufferUsageBit::INDEX))
+	{
+		mask |= VK_ACCESS_INDEX_READ_BIT;
+	}
+
+	if(!!(usage & BufferUsageBit::VERTEX))
+	{
+		mask |= VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
+	}
+
+	if(!!(usage & BufferUsageBit::INDIRECT))
+	{
+		mask |= VK_ACCESS_INDIRECT_COMMAND_READ_BIT;
+	}
+
+	if(!!(usage & (BufferUsageBit::FILL
+					  | BufferUsageBit::BUFFER_UPLOAD_DESTINATION)))
+	{
+		mask |= VK_ACCESS_TRANSFER_WRITE_BIT;
+	}
+
+	if(!!(usage & (BufferUsageBit::BUFFER_UPLOAD_SOURCE
+					  | BufferUsageBit::TEXTURE_UPLOAD_SOURCE)))
+	{
+		mask |= VK_ACCESS_TRANSFER_READ_BIT;
+	}
+
+	ANKI_ASSERT(mask);
+	return mask;
+}
+
+//==============================================================================
+void BufferImpl::computeBarrierInfo(BufferUsageBit before,
+	BufferUsageBit after,
+	VkPipelineStageFlags& srcStages,
+	VkAccessFlags& srcAccesses,
+	VkPipelineStageFlags& dstStages,
+	VkAccessFlags& dstAccesses) const
+{
+	ANKI_ASSERT(usageValid(before) && usageValid(after));
+
+	srcStages = computePplineStage(before);
+	dstStages = computePplineStage(after);
+	srcAccesses = computeAccessMask(before);
+	dstAccesses = computeAccessMask(after);
+}
+
 } // end namespace anki

src/anki/gr/vulkan/BufferImpl.h

@@ -59,6 +59,13 @@ public:
 		return (m_usage & usage) == usage;
 	}
 
+	void computeBarrierInfo(BufferUsageBit before,
+		BufferUsageBit after,
+		VkPipelineStageFlags& srcStages,
+		VkAccessFlags& srcAccesses,
+		VkPipelineStageFlags& dstStages,
+		VkAccessFlags& dstAccesses) const;
+
 private:
 	VkBuffer m_handle = VK_NULL_HANDLE;
 	GpuMemoryAllocationHandle m_memHandle;
@@ -75,6 +82,9 @@ private:
 	{
 		return m_handle != VK_NULL_HANDLE;
 	}
+
+	static VkPipelineStageFlags computePplineStage(BufferUsageBit usage);
+	static VkAccessFlags computeAccessMask(BufferUsageBit usage);
 };
 /// @}
 

src/anki/gr/vulkan/CommandBuffer.cpp

@@ -240,6 +240,7 @@ void CommandBuffer::setBufferBarrier(BufferPtr buff,
 	PtrSize offset,
 	PtrSize size)
 {
+	m_impl->setBufferBarrier(buff, before, after, offset, size);
 }
 
 //==============================================================================

src/anki/gr/vulkan/CommandBufferImpl.h

@@ -146,6 +146,12 @@ public:
 		PtrSize size,
 		VkBuffer buff);
 
+	void setBufferBarrier(BufferPtr buff,
+		BufferUsageBit before,
+		BufferUsageBit after,
+		PtrSize offset,
+		PtrSize size);
+
 	void fillBuffer(BufferPtr buff, PtrSize offset, PtrSize size, U32 value);
 
 private:

src/anki/gr/vulkan/CommandBufferImpl.inl.h

@@ -182,6 +182,8 @@ inline void CommandBufferImpl::setBufferBarrier(VkPipelineStageFlags srcStage,
 	VkBuffer buff)
 {
 	ANKI_ASSERT(buff);
+	commandCommon();
+
 	VkBufferMemoryBarrier b = {};
 	b.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
 	b.srcAccessMask = srcAccess;
@@ -196,6 +198,33 @@ inline void CommandBufferImpl::setBufferBarrier(VkPipelineStageFlags srcStage,
 		m_handle, srcStage, dstStage, 0, 0, nullptr, 1, &b, 0, nullptr);
 }
 
+//==============================================================================
+inline void CommandBufferImpl::setBufferBarrier(BufferPtr buff,
+	BufferUsageBit before,
+	BufferUsageBit after,
+	PtrSize offset,
+	PtrSize size)
+{
+	const BufferImpl& impl = buff->getImplementation();
+
+	VkPipelineStageFlags srcStage;
+	VkAccessFlags srcAccess;
+	VkPipelineStageFlags dstStage;
+	VkAccessFlags dstAccess;
+	impl.computeBarrierInfo(
+		before, after, srcStage, srcAccess, dstStage, dstAccess);
+
+	setBufferBarrier(srcStage,
+		srcAccess,
+		dstStage,
+		dstAccess,
+		offset,
+		size,
+		impl.getHandle());
+
+	m_bufferList.pushBack(m_alloc, buff);
+}
+
 //==============================================================================
 inline void CommandBufferImpl::drawElements(U32 count,
 	U32 instanceCount,

src/anki/gr/vulkan/Common.cpp

@@ -549,13 +549,14 @@ VkBufferUsageFlags convertBufferUsageBit(BufferUsageBit usageMask)
 		out |= VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
 	}
 
-	if(!!(usageMask
-		   & (BufferUsageBit::TRANSFER_DESTINATION | BufferUsageBit::FILL)))
+	if(!!(usageMask & (BufferUsageBit::BUFFER_UPLOAD_DESTINATION
+						  | BufferUsageBit::FILL)))
 	{
 		out |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
 	}
 
-	if(!!(usageMask & BufferUsageBit::TRANSFER_SOURCE))
+	if(!!(usageMask & (BufferUsageBit::BUFFER_UPLOAD_SOURCE
+						  | BufferUsageBit::TEXTURE_UPLOAD_SOURCE)))
 	{
 		out |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
 	}

src/anki/gr/vulkan/GrManager.cpp

@@ -81,10 +81,8 @@ void* GrManager::tryAllocateFrameTransientMemory(
 }
 
 //==============================================================================
-void GrManager::getTextureSurfaceUploadInfo(TexturePtr tex,
-	const TextureSurfaceInfo& surf,
-	PtrSize& allocationSize,
-	BufferUsageBit& usage)
+void GrManager::getTextureSurfaceUploadInfo(
+	TexturePtr tex, const TextureSurfaceInfo& surf, PtrSize& allocationSize)
 {
 	const TextureImpl& impl = tex->getImplementation();
 	impl.checkSurface(surf);
@@ -111,15 +109,11 @@ void GrManager::getTextureSurfaceUploadInfo(TexturePtr tex,
 	{
 		ANKI_ASSERT(0);
 	}
-
-	usage = BufferUsageBit::TRANSFER_SOURCE;
 }
 
 //==============================================================================
-void GrManager::getTextureVolumeUploadInfo(TexturePtr tex,
-	const TextureVolumeInfo& vol,
-	PtrSize& allocationSize,
-	BufferUsageBit& usage)
+void GrManager::getTextureVolumeUploadInfo(
+	TexturePtr tex, const TextureVolumeInfo& vol, PtrSize& allocationSize)
 {
 	const TextureImpl& impl = tex->getImplementation();
 	impl.checkVolume(vol);
@@ -149,8 +143,6 @@ void GrManager::getTextureVolumeUploadInfo(TexturePtr tex,
 	{
 		ANKI_ASSERT(0);
 	}
-
-	usage = BufferUsageBit::TRANSFER_SOURCE;
 }
 
 } // end namespace anki

src/anki/gr/vulkan/TransientMemoryManager.cpp

@@ -22,8 +22,8 @@ Error TransientMemoryManager::init(const ConfigSet& cfg)
 			"gr.transferPerFrameMemorySize"}};
 
 	// This alignment satisfies the spec's condition for buffer to image
-	// copies: "bufferOffset must be a multiple of the calling command’s
-	// VkImage parameter’s texel size". This alignment works for all supported
+	// copies: "bufferOffset must be a multiple of the calling command's
+	// VkImage parameter's texel size". This alignment works for all supported
 	// formats
 	const U TRANSFER_ALIGNMENT = 96;
 
@@ -39,8 +39,9 @@ Error TransientMemoryManager::init(const ConfigSet& cfg)
 		{BufferUsageBit::UNIFORM_ALL,
 			BufferUsageBit::STORAGE_ALL,
 			BufferUsageBit::VERTEX,
-			BufferUsageBit::TRANSFER_SOURCE
-				| BufferUsageBit::TRANSFER_DESTINATION}};
+			BufferUsageBit::BUFFER_UPLOAD_SOURCE
+				| BufferUsageBit::BUFFER_UPLOAD_DESTINATION
+				| BufferUsageBit::TEXTURE_UPLOAD_SOURCE}};
 
 	auto alloc = m_manager->getAllocator();
 	for(TransientBufferType i = TransientBufferType::UNIFORM;

src/anki/renderer/Bloom.cpp

@@ -118,7 +118,8 @@ Error Bloom::initInternal(const ConfigSet& config)
 
 		descInit.m_storageBuffers[0].m_buffer =
 			m_r->getTm().getAverageLuminanceBuffer();
-		descInit.m_storageBuffers[0].m_usage = BufferUsageBit::STORAGE_FRAGMENT;
+		descInit.m_storageBuffers[0].m_usage =
+			BufferUsageBit::STORAGE_FRAGMENT_READ;
 
 		m_extractExposure.m_rsrc = gr.newInstance<ResourceGroup>(descInit);
 	}

src/anki/renderer/Fs.cpp

@@ -71,11 +71,11 @@ Error Fs::init(const ConfigSet&)
 			BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
 
 		init.m_storageBuffers[0].m_uploadedMemory = true;
-		init.m_storageBuffers[0].m_usage =
-			BufferUsageBit::STORAGE_FRAGMENT | BufferUsageBit::STORAGE_VERTEX;
+		init.m_storageBuffers[0].m_usage = BufferUsageBit::STORAGE_FRAGMENT_READ
+			| BufferUsageBit::STORAGE_VERTEX_READ;
 		init.m_storageBuffers[1].m_uploadedMemory = true;
-		init.m_storageBuffers[1].m_usage =
-			BufferUsageBit::STORAGE_FRAGMENT | BufferUsageBit::STORAGE_VERTEX;
+		init.m_storageBuffers[1].m_usage = BufferUsageBit::STORAGE_FRAGMENT_READ
+			| BufferUsageBit::STORAGE_VERTEX_READ;
 
 		m_globalResources = getGrManager().newInstance<ResourceGroup>(init);
 	}

src/anki/renderer/Ir.cpp

@@ -114,11 +114,11 @@ Error Ir::loadMesh(
 	PtrSize vertBuffSize =
 		loader.getHeader().m_totalVerticesCount * sizeof(Vec3);
 	vert = getGrManager().newInstance<Buffer>(vertBuffSize,
-		BufferUsageBit::VERTEX | BufferUsageBit::TRANSFER_DESTINATION,
+		BufferUsageBit::VERTEX | BufferUsageBit::BUFFER_UPLOAD_DESTINATION,
 		BufferMapAccessBit::NONE);
 
 	idx = getGrManager().newInstance<Buffer>(loader.getIndexDataSize(),
-		BufferUsageBit::INDEX | BufferUsageBit::TRANSFER_DESTINATION,
+		BufferUsageBit::INDEX | BufferUsageBit::BUFFER_UPLOAD_DESTINATION,
 		BufferMapAccessBit::NONE);
 
 	// Upload data
@@ -129,7 +129,7 @@ Error Ir::loadMesh(
 	TransientMemoryToken token;
 	Vec3* verts =
 		static_cast<Vec3*>(getGrManager().allocateFrameTransientMemory(
-			vertBuffSize, BufferUsageBit::TRANSFER_SOURCE, token));
+			vertBuffSize, BufferUsageBit::BUFFER_UPLOAD_SOURCE, token));
 
 	const U8* ptr = loader.getVertexData();
 	for(U i = 0; i < loader.getHeader().m_totalVerticesCount; ++i)
@@ -142,7 +142,7 @@ Error Ir::loadMesh(
 	cmdb->uploadBuffer(vert, 0, token);
 
 	void* cpuIds = getGrManager().allocateFrameTransientMemory(
-		loader.getIndexDataSize(), BufferUsageBit::TRANSFER_SOURCE, token);
+		loader.getIndexDataSize(), BufferUsageBit::BUFFER_UPLOAD_SOURCE, token);
 
 	memcpy(cpuIds, loader.getIndexData(), loader.getIndexDataSize());
 

src/anki/renderer/Is.cpp

@@ -185,11 +185,11 @@ Error Is::initInternal(const ConfigSet& config)
 			BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
 
 		init.m_storageBuffers[0].m_uploadedMemory = true;
-		init.m_storageBuffers[0].m_usage =
-			BufferUsageBit::STORAGE_FRAGMENT | BufferUsageBit::STORAGE_VERTEX;
+		init.m_storageBuffers[0].m_usage = BufferUsageBit::STORAGE_FRAGMENT_READ
+			| BufferUsageBit::STORAGE_VERTEX_READ;
 		init.m_storageBuffers[1].m_uploadedMemory = true;
-		init.m_storageBuffers[1].m_usage =
-			BufferUsageBit::STORAGE_FRAGMENT | BufferUsageBit::STORAGE_VERTEX;
+		init.m_storageBuffers[1].m_usage = BufferUsageBit::STORAGE_FRAGMENT_READ
+			| BufferUsageBit::STORAGE_VERTEX_READ;
 
 		m_rcGroup = getGrManager().newInstance<ResourceGroup>(init);
 	}

src/anki/renderer/Pps.cpp

@@ -158,7 +158,8 @@ Error Pps::run(RenderingContext& ctx)
 
 		rcInit.m_storageBuffers[0].m_buffer =
 			m_r->getTm().getAverageLuminanceBuffer();
-		rcInit.m_storageBuffers[0].m_usage = BufferUsageBit::STORAGE_FRAGMENT;
+		rcInit.m_storageBuffers[0].m_usage =
+			BufferUsageBit::STORAGE_FRAGMENT_READ;
 
 		rsrc = getGrManager().newInstance<ResourceGroup>(rcInit);
 

src/anki/renderer/Tm.cpp

@@ -38,14 +38,14 @@ Error Tm::create(const ConfigSet& initializer)
 	// Create buffer
 	m_luminanceBuff = getGrManager().newInstance<Buffer>(sizeof(Vec4),
 		BufferUsageBit::STORAGE_ALL | BufferUsageBit::UNIFORM_ALL
-			| BufferUsageBit::TRANSFER_DESTINATION,
+			| BufferUsageBit::BUFFER_UPLOAD_DESTINATION,
 		BufferMapAccessBit::NONE);
 
 	CommandBufferPtr cmdb =
 		getGrManager().newInstance<CommandBuffer>(CommandBufferInitInfo());
 	TransientMemoryToken token;
 	void* data = getGrManager().allocateFrameTransientMemory(
-		sizeof(Vec4), BufferUsageBit::TRANSFER_SOURCE, token);
+		sizeof(Vec4), BufferUsageBit::BUFFER_UPLOAD_SOURCE, token);
 	*static_cast<Vec4*>(data) = Vec4(0.5);
 	cmdb->uploadBuffer(m_luminanceBuff, 0, token);
 	cmdb->flush();

src/anki/resource/Mesh.cpp

@@ -47,7 +47,7 @@ Error MeshLoadTask::operator()(AsyncLoaderTaskContext& ctx)
 		TransientMemoryToken token;
 		void* data =
 			gr.tryAllocateFrameTransientMemory(m_loader.getVertexDataSize(),
-				BufferUsageBit::TRANSFER_SOURCE,
+				BufferUsageBit::BUFFER_UPLOAD_SOURCE,
 				token);
 
 		if(data)
@@ -58,14 +58,14 @@ Error MeshLoadTask::operator()(AsyncLoaderTaskContext& ctx)
 
 			cmdb->setBufferBarrier(m_vertBuff,
 				BufferUsageBit::VERTEX,
-				BufferUsageBit::UPLOAD_DESTINATION,
+				BufferUsageBit::BUFFER_UPLOAD_DESTINATION,
 				0,
 				MAX_PTR_SIZE);
 
 			cmdb->uploadBuffer(m_vertBuff, 0, token);
 
 			cmdb->setBufferBarrier(m_vertBuff,
-				BufferUsageBit::UPLOAD_DESTINATION,
+				BufferUsageBit::BUFFER_UPLOAD_DESTINATION,
 				BufferUsageBit::VERTEX,
 				0,
 				MAX_PTR_SIZE);
@@ -85,7 +85,7 @@ Error MeshLoadTask::operator()(AsyncLoaderTaskContext& ctx)
 		TransientMemoryToken token;
 		void* data =
 			gr.tryAllocateFrameTransientMemory(m_loader.getIndexDataSize(),
-				BufferUsageBit::TRANSFER_SOURCE,
+				BufferUsageBit::BUFFER_UPLOAD_SOURCE,
 				token);
 
 		if(data)
@@ -99,14 +99,14 @@ Error MeshLoadTask::operator()(AsyncLoaderTaskContext& ctx)
 
 			cmdb->setBufferBarrier(m_indicesBuff,
 				BufferUsageBit::INDEX,
-				BufferUsageBit::UPLOAD_DESTINATION,
+				BufferUsageBit::BUFFER_UPLOAD_DESTINATION,
 				0,
 				MAX_PTR_SIZE);
 
 			cmdb->uploadBuffer(m_indicesBuff, 0, token);
 
 			cmdb->setBufferBarrier(m_indicesBuff,
-				BufferUsageBit::UPLOAD_DESTINATION,
+				BufferUsageBit::BUFFER_UPLOAD_DESTINATION,
 				BufferUsageBit::INDEX,
 				0,
 				MAX_PTR_SIZE);
@@ -185,11 +185,11 @@ Error Mesh::load(const ResourceFilename& filename)
 	GrManager& gr = getManager().getGrManager();
 
 	m_vertBuff = gr.newInstance<Buffer>(loader.getVertexDataSize(),
-		BufferUsageBit::VERTEX | BufferUsageBit::TRANSFER_DESTINATION,
+		BufferUsageBit::VERTEX | BufferUsageBit::BUFFER_UPLOAD_DESTINATION,
 		BufferMapAccessBit::NONE);
 
 	m_indicesBuff = gr.newInstance<Buffer>(loader.getIndexDataSize(),
-		BufferUsageBit::INDEX | BufferUsageBit::TRANSFER_DESTINATION,
+		BufferUsageBit::INDEX | BufferUsageBit::BUFFER_UPLOAD_DESTINATION,
 		BufferMapAccessBit::NONE);
 
 	// Clear them

src/anki/resource/TextureResource.cpp

@@ -57,7 +57,8 @@ Error TexUploadTask::operator()(AsyncLoaderTaskContext& ctx)
 				PtrSize surfOrVolSize;
 				const void* surfOrVolData;
 				PtrSize allocationSize;
-				BufferUsageBit uploadBuffUsage;
+				const BufferUsageBit uploadBuffUsage =
+					BufferUsageBit::TEXTURE_UPLOAD_SOURCE;
 
 				if(m_texType == TextureType::_3D)
 				{
@@ -65,10 +66,8 @@ Error TexUploadTask::operator()(AsyncLoaderTaskContext& ctx)
 					surfOrVolSize = vol.m_data.getSize();
 					surfOrVolData = &vol.m_data[0];
 
-					m_gr->getTextureVolumeUploadInfo(m_tex,
-						TextureVolumeInfo(mip),
-						allocationSize,
-						uploadBuffUsage);
+					m_gr->getTextureVolumeUploadInfo(
+						m_tex, TextureVolumeInfo(mip), allocationSize);
 				}
 				else
 				{
@@ -78,8 +77,7 @@ Error TexUploadTask::operator()(AsyncLoaderTaskContext& ctx)
 
 					m_gr->getTextureSurfaceUploadInfo(m_tex,
 						TextureSurfaceInfo(mip, 0, face, layer),
-						allocationSize,
-						uploadBuffUsage);
+						allocationSize);
 				}
 
 				ANKI_ASSERT(allocationSize >= surfOrVolSize);

src/anki/ui/UiInterfaceImpl.cpp

@@ -222,7 +222,7 @@ Error UiInterfaceImpl::createR8Image(
 		m_gr->newInstance<CommandBuffer>(CommandBufferInitInfo());
 	TransientMemoryToken token;
 	void* loadData = m_gr->allocateFrameTransientMemory(
-		data.getSize(), BufferUsageBit::TRANSFER_SOURCE, token);
+		data.getSize(), BufferUsageBit::TEXTURE_UPLOAD_SOURCE, token);
 	memcpy(loadData, &data[0], data.getSize());
 	cmdb->uploadTextureSurface(tex, TextureSurfaceInfo(0, 0, 0, 0), token);