Vulkan: Making image load/store work and some other additions

include/anki/gr/Enums.h

@@ -164,26 +164,25 @@ enum class TextureUsageBit : U16
 
 	/// @name Sampled
 	/// @{
-	VERTEX_SHADER_SAMPLED = 1 << 0,
-	TESSELLATION_CONTROL_SHADER_SAMPLED = 1 << 1,
-	TESSELLATION_EVALUATION_SHADER_SAMPLED = 1 << 2,
-	GEOMETRY_SHADER_SAMPLED = 1 << 3,
-	FRAGMENT_SHADER_SAMPLED = 1 << 4,
-	COMPUTE_SHADER_SAMPLED = 1 << 5,
-	ANY_GRAPHICS_SHADER_SAMPLED = VERTEX_SHADER_SAMPLED
-		| TESSELLATION_CONTROL_SHADER_SAMPLED
-		| TESSELLATION_EVALUATION_SHADER_SAMPLED
-		| GEOMETRY_SHADER_SAMPLED
-		| FRAGMENT_SHADER_SAMPLED,
-	ANY_SHADER_SAMPLED = ANY_GRAPHICS_SHADER_SAMPLED | COMPUTE_SHADER_SAMPLED,
+	SAMPLED_VERTEX = 1 << 0,
+	SAMPLED_TESSELLATION_CONTROL = 1 << 1,
+	SAMPLED_TESSELLATION_EVALUATION = 1 << 2,
+	SAMPLED_GEOMETRY = 1 << 3,
+	SAMPLED_FRAGMENT = 1 << 4,
+	SAMPLED_COMPUTE = 1 << 5,
+	SAMPLED_ALL_GRAPHICS = SAMPLED_VERTEX | SAMPLED_TESSELLATION_CONTROL
+		| SAMPLED_TESSELLATION_EVALUATION
+		| SAMPLED_GEOMETRY
+		| SAMPLED_FRAGMENT,
+	SAMPLED_ALL = SAMPLED_ALL_GRAPHICS | SAMPLED_COMPUTE,
 	/// @}
 
 	/// @name Image_load_store
 	/// @{
-	COMPUTE_SHADER_IMAGE_READ = 1 << 6,
-	COMPUTE_SHADER_IMAGE_WRITE = 1 << 7,
-	COMPUTE_SHADER_IMAGE_READ_WRITE =
-		COMPUTE_SHADER_IMAGE_READ | COMPUTE_SHADER_IMAGE_WRITE,
+	IMAGE_COMPUTE_READ = 1 << 6,
+	IMAGE_COMPUTE_WRITE = 1 << 7,
+	IMAGE_COMPUTE_READ_WRITE = IMAGE_COMPUTE_READ | IMAGE_COMPUTE_WRITE,
+	IMAGE_ALL = IMAGE_COMPUTE_READ_WRITE,
 	/// @}
 
 	/// @name Attachment
@@ -329,32 +328,32 @@ enum class BufferUsageBit : U32
 {
 	NONE = 0,
 
-	UNIFORM_VERTEX_SHADER = 1 << 0,
-	UNIFORM_TESSELLATION_EVALUATION_SHADER = 1 << 1,
-	UNIFORM_TESSELLATION_CONTROL_SHADER = 1 << 2,
-	UNIFORM_GEOMETRY_SHADER = 1 << 3,
-	UNIFORM_FRAGMENT_SHADER = 1 << 4,
-	UNIFORM_COMPUTE_SHADER = 1 << 5,
-	UNIFORM_ANY_SHADER = UNIFORM_VERTEX_SHADER
-		| UNIFORM_TESSELLATION_EVALUATION_SHADER
-		| UNIFORM_TESSELLATION_CONTROL_SHADER
-		| UNIFORM_GEOMETRY_SHADER
-		| UNIFORM_FRAGMENT_SHADER
-		| UNIFORM_COMPUTE_SHADER,
-
-	STORAGE_VERTEX_SHADER = 1 << 6,
-	STORAGE_TESSELLATION_EVALUATION_SHADER = 1 << 7,
-	STORAGE_TESSELLATION_CONTROL_SHADER = 1 << 8,
-	STORAGE_GEOMETRY_SHADER = 1 << 9,
-	STORAGE_FRAGMENT_SHADER = 1 << 10,
-	STORAGE_COMPUTE_SHADER_READ = 1 << 11,
-	STORAGE_COMPUTE_SHADER_WRITE = 1 << 12,
-	STORAGE_ANY = STORAGE_VERTEX_SHADER | STORAGE_TESSELLATION_EVALUATION_SHADER
-		| STORAGE_TESSELLATION_CONTROL_SHADER
-		| STORAGE_GEOMETRY_SHADER
-		| STORAGE_FRAGMENT_SHADER
-		| STORAGE_COMPUTE_SHADER_READ
-		| STORAGE_COMPUTE_SHADER_WRITE,
+	UNIFORM_VERTEX = 1 << 0,
+	UNIFORM_TESSELLATION_EVALUATION = 1 << 1,
+	UNIFORM_TESSELLATION_CONTROL = 1 << 2,
+	UNIFORM_GEOMETRY = 1 << 3,
+	UNIFORM_FRAGMENT = 1 << 4,
+	UNIFORM_COMPUTE = 1 << 5,
+	UNIFORM_ALL_GRAPHICS = UNIFORM_VERTEX | UNIFORM_TESSELLATION_EVALUATION
+		| UNIFORM_TESSELLATION_CONTROL
+		| UNIFORM_GEOMETRY
+		| 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_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,

include/anki/gr/ResourceGroup.h

@@ -22,7 +22,7 @@ class TextureBinding
 public:
 	TexturePtr m_texture;
 	SamplerPtr m_sampler; ///< Use it to override texture's sampler.
-	TextureUsageBit m_usage = TextureUsageBit::FRAGMENT_SHADER_SAMPLED;
+	TextureUsageBit m_usage = TextureUsageBit::SAMPLED_FRAGMENT;
 };
 
 /// Buffer binding info.
@@ -33,6 +33,7 @@ public:
 	PtrSize m_offset = 0;
 	PtrSize m_range = 0; ///< If zero it means the whole buffer.
 	Bool m_uploadedMemory = false;
+	BufferUsageBit m_usage = BufferUsageBit::NONE;
 };
 
 /// Image binding info.
@@ -41,7 +42,7 @@ class ImageBinding
 public:
 	TexturePtr m_texture;
 	U8 m_level = 0;
-	TextureUsageBit m_usage = TextureUsageBit::COMPUTE_SHADER_IMAGE_READ_WRITE;
+	TextureUsageBit m_usage = TextureUsageBit::IMAGE_COMPUTE_READ_WRITE;
 };
 
 /// Resource group initializer.

include/anki/gr/common/Misc.h

@@ -23,11 +23,11 @@ ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(TransientBufferType, inline)
 /// Convert buff usage to TransientBufferType.
 inline TransientBufferType bufferUsageToTransient(BufferUsageBit bit)
 {
-	if((bit & BufferUsageBit::UNIFORM_ANY_SHADER) != BufferUsageBit::NONE)
+	if(!!(bit & BufferUsageBit::UNIFORM_ALL))
 	{
 		return TransientBufferType::UNIFORM;
 	}
-	else if((bit & BufferUsageBit::STORAGE_ANY) != BufferUsageBit::NONE)
+	else if(!!(bit & BufferUsageBit::STORAGE_ALL))
 	{
 		return TransientBufferType::STORAGE;
 	}

include/anki/gr/vulkan/ResourceGroupImpl.h

@@ -66,11 +66,18 @@ public:
 		return false;
 	}
 
+	VkPipelineBindPoint getPipelineBindPoint() const
+	{
+		ANKI_ASSERT(m_bindPoint != VK_PIPELINE_BIND_POINT_MAX_ENUM);
+		return m_bindPoint;
+	}
+
 private:
 	VkDescriptorSet m_handle = VK_NULL_HANDLE;
 	Array<VkBuffer, MAX_VERTEX_ATTRIBUTES> m_vertBuffs = {{}};
 	Array<VkDeviceSize, MAX_VERTEX_ATTRIBUTES> m_offsets = {{}};
 	U32 m_bindingCount = 0;
+	VkPipelineBindPoint m_bindPoint = VK_PIPELINE_BIND_POINT_MAX_ENUM;
 
 	// For dynamic binding
 	U8 m_uniBindingCount = 0;
@@ -87,8 +94,11 @@ private:
 	/// gracefully
 	DynamicArray<GrObjectPtr<GrObject>> m_refs;
 
-	static U calcRefCount(
+	U calcRefCount(
 		const ResourceGroupInitInfo& init, Bool& hasUploaded, Bool& needsDSet);
+
+	void updateBindPoint(TextureUsageBit usage);
+	void updateBindPoint(BufferUsageBit usage);
 };
 /// @}
 

src/gr/gl/BufferImpl.cpp

@@ -28,7 +28,7 @@ void BufferImpl::init(
 	// creation
 	m_target = GL_ARRAY_BUFFER;
 
-	if((usage & BufferUsageBit::UNIFORM_ANY_SHADER) != BufferUsageBit::NONE)
+	if((usage & BufferUsageBit::UNIFORM_ALL) != BufferUsageBit::NONE)
 	{
 		GLint64 maxBufferSize;
 		glGetInteger64v(GL_MAX_UNIFORM_BLOCK_SIZE, &maxBufferSize);
@@ -50,7 +50,7 @@ void BufferImpl::init(
 		m_target = GL_UNIFORM_BUFFER;
 	}
 
-	if((usage & BufferUsageBit::STORAGE_ANY) != BufferUsageBit::NONE)
+	if((usage & BufferUsageBit::STORAGE_ALL) != BufferUsageBit::NONE)
 	{
 		GLint64 maxBufferSize;
 		glGetInteger64v(GL_MAX_SHADER_STORAGE_BLOCK_SIZE, &maxBufferSize);

src/gr/vulkan/CommandBufferImpl.cpp

@@ -229,8 +229,6 @@ void CommandBufferImpl::endRecording()
 void CommandBufferImpl::bindResourceGroup(
 	ResourceGroupPtr rc, U slot, const TransientMemoryInfo* dynInfo)
 {
-	// TODO set the correct binding point
-
 	commandCommon();
 	const ResourceGroupImpl& impl = rc->getImplementation();
 
@@ -243,7 +241,7 @@ void CommandBufferImpl::bindResourceGroup(
 
 		VkDescriptorSet dset = impl.getHandle();
 		vkCmdBindDescriptorSets(m_handle,
-			VK_PIPELINE_BIND_POINT_GRAPHICS,
+			impl.getPipelineBindPoint(),
 			getGrManagerImpl().getGlobalPipelineLayout(),
 			slot,
 			1,

src/gr/vulkan/Common.cpp

@@ -491,12 +491,12 @@ VkBufferUsageFlags convertBufferUsageBit(BufferUsageBit usageMask)
 {
 	VkBufferUsageFlags out = 0;
 
-	if((usageMask & BufferUsageBit::UNIFORM_ANY_SHADER) != BufferUsageBit::NONE)
+	if((usageMask & BufferUsageBit::UNIFORM_ALL) != BufferUsageBit::NONE)
 	{
 		out |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
 	}
 
-	if((usageMask & BufferUsageBit::STORAGE_ANY) != BufferUsageBit::NONE)
+	if((usageMask & BufferUsageBit::STORAGE_ALL) != BufferUsageBit::NONE)
 	{
 		out |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
 	}
@@ -594,13 +594,17 @@ VkImageUsageFlags convertTextureUsage(
 {
 	VkImageUsageFlags out = 0;
 
-	if((ak & TextureUsageBit::ANY_SHADER_SAMPLED) != TextureUsageBit::NONE)
+	if(!!(ak & TextureUsageBit::SAMPLED_ALL))
 	{
 		out |= VK_IMAGE_USAGE_SAMPLED_BIT;
 	}
 
-	if((ak & TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE)
-		!= TextureUsageBit::NONE)
+	if(!!(ak & TextureUsageBit::IMAGE_ALL))
+	{
+		out |= VK_IMAGE_USAGE_STORAGE_BIT;
+	}
+
+	if(!!(ak & TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE))
 	{
 		if(formatIsDepthStencil(format))
 		{
@@ -612,18 +616,18 @@ VkImageUsageFlags convertTextureUsage(
 		}
 	}
 
-	if((ak & TextureUsageBit::GENERATE_MIPMAPS) != TextureUsageBit::NONE)
+	if(!!(ak & TextureUsageBit::GENERATE_MIPMAPS))
 	{
 		out |=
 			VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
 	}
 
-	if((ak & TextureUsageBit::UPLOAD) != TextureUsageBit::NONE)
+	if(!!(ak & TextureUsageBit::UPLOAD))
 	{
 		out |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
 	}
 
-	if((ak & TextureUsageBit::CLEAR) != TextureUsageBit::NONE)
+	if(!!(ak & TextureUsageBit::CLEAR))
 	{
 		out |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
 	}

src/gr/vulkan/ResourceGroupImpl.cpp

@@ -24,6 +24,64 @@ ResourceGroupImpl::~ResourceGroupImpl()
 	m_refs.destroy(getAllocator());
 }
 
+//==============================================================================
+void ResourceGroupImpl::updateBindPoint(TextureUsageBit usage)
+{
+	ANKI_ASSERT(!!usage);
+
+	VkPipelineBindPoint bindPoint = VK_PIPELINE_BIND_POINT_MAX_ENUM;
+	const TextureUsageBit allCompute = TextureUsageBit::IMAGE_COMPUTE_READ_WRITE
+		| TextureUsageBit::SAMPLED_COMPUTE;
+
+	if(!!(usage & allCompute))
+	{
+		ANKI_ASSERT(
+			!(usage & ~allCompute) && "Can't have compute with something else");
+		bindPoint = VK_PIPELINE_BIND_POINT_COMPUTE;
+	}
+	else
+	{
+		ANKI_ASSERT(!!(usage & ~allCompute));
+		bindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
+	}
+
+	if(m_bindPoint != VK_PIPELINE_BIND_POINT_MAX_ENUM)
+	{
+		ANKI_ASSERT(m_bindPoint == bindPoint);
+	}
+
+	m_bindPoint = bindPoint;
+}
+
+//==============================================================================
+void ResourceGroupImpl::updateBindPoint(BufferUsageBit usage)
+{
+	ANKI_ASSERT(!!usage);
+
+	VkPipelineBindPoint bindPoint = VK_PIPELINE_BIND_POINT_MAX_ENUM;
+	const BufferUsageBit allCompute = BufferUsageBit::UNIFORM_COMPUTE
+		| BufferUsageBit::STORAGE_COMPUTE_READ_WRITE;
+
+	if(!!(usage & allCompute))
+	{
+		ANKI_ASSERT(
+			!(usage & ~allCompute) && "Can't have compute with something else");
+		bindPoint = VK_PIPELINE_BIND_POINT_COMPUTE;
+	}
+	else
+	{
+		ANKI_ASSERT(!!(usage & ~allCompute));
+		bindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
+	}
+
+	if(m_bindPoint != VK_PIPELINE_BIND_POINT_MAX_ENUM)
+	{
+		ANKI_ASSERT(m_bindPoint == bindPoint);
+	}
+
+	m_bindPoint = bindPoint;
+}
+
 //==============================================================================
 U ResourceGroupImpl::calcRefCount(
 	const ResourceGroupInitInfo& init, Bool& hasUploaded, Bool& needsDSet)
@@ -38,6 +96,10 @@ U ResourceGroupImpl::calcRefCount(
 		{
 			++count;
 			needsDSet = true;
+			updateBindPoint(init.m_textures[i].m_usage);
+			ANKI_ASSERT(
+				init.m_textures[i].m_texture->getImplementation().usageValid(
+					init.m_textures[i].m_usage));
 		}
 
 		if(init.m_textures[i].m_sampler)
@@ -53,11 +115,21 @@ U ResourceGroupImpl::calcRefCount(
 		{
 			++count;
 			needsDSet = true;
+			updateBindPoint(init.m_uniformBuffers[i].m_usage);
+			ANKI_ASSERT(!!(init.m_uniformBuffers[i].m_usage
+							& BufferUsageBit::UNIFORM_ALL)
+				&& !(init.m_uniformBuffers[i].m_usage
+					   & ~BufferUsageBit::UNIFORM_ALL));
 		}
 		else if(init.m_uniformBuffers[i].m_uploadedMemory)
 		{
 			hasUploaded = true;
 			needsDSet = true;
+			updateBindPoint(init.m_uniformBuffers[i].m_usage);
+			ANKI_ASSERT(!!(init.m_uniformBuffers[i].m_usage
+							& BufferUsageBit::UNIFORM_ALL)
+				&& !(init.m_uniformBuffers[i].m_usage
+					   & ~BufferUsageBit::UNIFORM_ALL));
 		}
 	}
 
@@ -67,11 +139,21 @@ U ResourceGroupImpl::calcRefCount(
 		{
 			++count;
 			needsDSet = true;
+			updateBindPoint(init.m_storageBuffers[i].m_usage);
+			ANKI_ASSERT(!!(init.m_uniformBuffers[i].m_usage
+							& BufferUsageBit::STORAGE_ALL)
+				&& !(init.m_uniformBuffers[i].m_usage
+					   & ~BufferUsageBit::STORAGE_ALL));
 		}
 		else if(init.m_storageBuffers[i].m_uploadedMemory)
 		{
 			hasUploaded = true;
 			needsDSet = true;
+			updateBindPoint(init.m_storageBuffers[i].m_usage);
+			ANKI_ASSERT(!!(init.m_uniformBuffers[i].m_usage
+							& BufferUsageBit::STORAGE_ALL)
+				&& !(init.m_uniformBuffers[i].m_usage
+					   & ~BufferUsageBit::STORAGE_ALL));
 		}
 	}
 
@@ -81,6 +163,10 @@ U ResourceGroupImpl::calcRefCount(
 		{
 			++count;
 			needsDSet = true;
+			updateBindPoint(init.m_images[i].m_usage);
+			ANKI_ASSERT(
+				init.m_images[i].m_texture->getImplementation().usageValid(
+					init.m_textures[i].m_usage));
 		}
 	}
 
@@ -123,6 +209,7 @@ Error ResourceGroupImpl::init(const ResourceGroupInitInfo& init)
 	if(needsDSet)
 	{
 		ANKI_CHECK(getGrManagerImpl().allocateDescriptorSet(m_handle));
+		ANKI_ASSERT(m_bindPoint != VK_PIPELINE_BIND_POINT_MAX_ENUM);
 	}
 
 	// Update
@@ -208,7 +295,7 @@ Error ResourceGroupImpl::init(const ResourceGroupInitInfo& init)
 			VkDescriptorBufferInfo& inf = unis[uniCount++];
 			inf.buffer =
 				getGrManagerImpl().getTransientMemoryManager().getBufferHandle(
-					BufferUsageBit::UNIFORM_ANY_SHADER);
+					BufferUsageBit::UNIFORM_ALL);
 			inf.range = VK_WHOLE_SIZE;
 
 			m_dynamicBuffersMask.set(i);
@@ -253,7 +340,7 @@ Error ResourceGroupImpl::init(const ResourceGroupInitInfo& init)
 			VkDescriptorBufferInfo& inf = storages[storageCount++];
 			inf.buffer =
 				getGrManagerImpl().getTransientMemoryManager().getBufferHandle(
-					BufferUsageBit::STORAGE_ANY);
+					BufferUsageBit::STORAGE_ALL);
 			inf.range = VK_WHOLE_SIZE;
 
 			m_dynamicBuffersMask.set(MAX_UNIFORM_BUFFER_BINDINGS + i);
@@ -384,8 +471,7 @@ void ResourceGroupImpl::setupDynamicOffsets(
 					dynInfo->m_uniformBuffers[i];
 
 				ANKI_ASSERT(token.m_range);
-				ANKI_ASSERT(
-					!!(token.m_usage & BufferUsageBit::UNIFORM_ANY_SHADER));
+				ANKI_ASSERT(!!(token.m_usage & BufferUsageBit::UNIFORM_ALL));
 				dynOffsets[i] = token.m_offset;
 			}
 		}
@@ -399,7 +485,7 @@ void ResourceGroupImpl::setupDynamicOffsets(
 					dynInfo->m_storageBuffers[i];
 
 				ANKI_ASSERT(token.m_range);
-				ANKI_ASSERT(!!(token.m_usage & BufferUsageBit::STORAGE_ANY));
+				ANKI_ASSERT(!!(token.m_usage & BufferUsageBit::STORAGE_ALL));
 				dynOffsets[MAX_UNIFORM_BUFFER_BINDINGS + i] = token.m_offset;
 			}
 		}

src/gr/vulkan/TextureImpl.cpp

@@ -87,7 +87,7 @@ VkFormatFeatureFlags TextureImpl::calcFeatures(const TextureInitInfo& init)
 		}
 	}
 
-	if(!!(init.m_usage & TextureUsageBit::ANY_SHADER_SAMPLED))
+	if(!!(init.m_usage & TextureUsageBit::SAMPLED_ALL))
 	{
 		flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
 	}
@@ -354,7 +354,7 @@ Error TextureImpl::initView(CreateContext& ctx)
 	ANKI_VK_CHECK(vkCreateImageView(getDevice(), &ci, nullptr, &m_viewHandle));
 
 	// Create the rest of the views
-	if(!!(m_usage & TextureUsageBit::COMPUTE_SHADER_IMAGE_READ_WRITE))
+	if(!!(m_usage & TextureUsageBit::IMAGE_COMPUTE_READ_WRITE))
 	{
 		ci.subresourceRange.levelCount = 1;
 
@@ -362,7 +362,7 @@ Error TextureImpl::initView(CreateContext& ctx)
 
 		for(U i = 0; i < m_viewsEveryLevel.getSize(); ++i)
 		{
-			ci.subresourceRange.baseArrayLayer = i + 1;
+			ci.subresourceRange.baseMipLevel = i + 1;
 			ANKI_VK_CHECK(vkCreateImageView(
 				getDevice(), &ci, nullptr, &m_viewsEveryLevel[i]));
 		}
@@ -391,18 +391,49 @@ void TextureImpl::computeBarrierInfo(TextureUsageBit before,
 	//
 	// Before
 	//
-	if(!!(before & TextureUsageBit::FRAGMENT_SHADER_SAMPLED))
+	if(!!(before & TextureUsageBit::SAMPLED_VERTEX))
+	{
+		srcStages |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
+		srcAccesses |= VK_ACCESS_SHADER_READ_BIT;
+	}
+
+	if(!!(before & TextureUsageBit::SAMPLED_TESSELLATION_CONTROL))
+	{
+		srcStages |= VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT;
+		srcAccesses |= VK_ACCESS_SHADER_READ_BIT;
+	}
+
+	if(!!(before & TextureUsageBit::SAMPLED_TESSELLATION_EVALUATION))
+	{
+		srcStages |= VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT;
+		srcAccesses |= VK_ACCESS_SHADER_READ_BIT;
+	}
+
+	if(!!(before & TextureUsageBit::SAMPLED_GEOMETRY))
+	{
+		srcStages |= VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
+		srcAccesses |= VK_ACCESS_SHADER_READ_BIT;
+	}
+
+	if(!!(before & TextureUsageBit::SAMPLED_FRAGMENT))
 	{
 		srcStages |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
 		srcAccesses |= VK_ACCESS_SHADER_READ_BIT;
 	}
 
-	if(!!(before & TextureUsageBit::COMPUTE_SHADER_SAMPLED))
+	if(!!(before & TextureUsageBit::SAMPLED_COMPUTE)
+		|| !!(before & TextureUsageBit::IMAGE_COMPUTE_READ))
 	{
 		srcStages |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
 		srcAccesses |= VK_ACCESS_SHADER_READ_BIT;
 	}
 
+	if(!!(before & TextureUsageBit::IMAGE_COMPUTE_WRITE))
+	{
+		srcStages |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
+		srcAccesses |= VK_ACCESS_SHADER_WRITE_BIT;
+	}
+
 	if(!!(before & TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ))
 	{
 		if(m_depthStencil)
@@ -466,18 +497,49 @@ void TextureImpl::computeBarrierInfo(TextureUsageBit before,
 	//
 	// After
 	//
-	if(!!(after & TextureUsageBit::FRAGMENT_SHADER_SAMPLED))
+	if(!!(after & TextureUsageBit::SAMPLED_VERTEX))
+	{
+		dstStages |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
+		dstAccesses |= VK_ACCESS_SHADER_READ_BIT;
+	}
+
+	if(!!(after & TextureUsageBit::SAMPLED_TESSELLATION_CONTROL))
+	{
+		dstStages |= VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT;
+		dstAccesses |= VK_ACCESS_SHADER_READ_BIT;
+	}
+
+	if(!!(after & TextureUsageBit::SAMPLED_TESSELLATION_EVALUATION))
+	{
+		dstStages |= VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT;
+		dstAccesses |= VK_ACCESS_SHADER_READ_BIT;
+	}
+
+	if(!!(after & TextureUsageBit::SAMPLED_GEOMETRY))
+	{
+		dstStages |= VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
+		dstAccesses |= VK_ACCESS_SHADER_READ_BIT;
+	}
+
+	if(!!(after & TextureUsageBit::SAMPLED_FRAGMENT))
 	{
 		dstStages |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
 		dstAccesses |= VK_ACCESS_SHADER_READ_BIT;
 	}
 
-	if(!!(after & TextureUsageBit::COMPUTE_SHADER_SAMPLED))
+	if(!!(after & TextureUsageBit::SAMPLED_COMPUTE)
+		|| !!(after & TextureUsageBit::IMAGE_COMPUTE_READ))
 	{
 		dstStages |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
 		dstAccesses |= VK_ACCESS_SHADER_READ_BIT;
 	}
 
+	if(!!(after & TextureUsageBit::IMAGE_COMPUTE_WRITE))
+	{
+		dstStages |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
+		dstAccesses |= VK_ACCESS_SHADER_WRITE_BIT;
+	}
+
 	if(!!(after & TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ))
 	{
 		if(m_depthStencil)
@@ -550,13 +612,13 @@ VkImageLayout TextureImpl::computeLayout(TextureUsageBit usage, U level) const
 	{
 		out = VK_IMAGE_LAYOUT_UNDEFINED;
 	}
-	else if(!!(usage & TextureUsageBit::ANY_SHADER_SAMPLED)
-		&& !(usage & ~TextureUsageBit::ANY_SHADER_SAMPLED))
+	else if(!!(usage & TextureUsageBit::SAMPLED_ALL)
+		&& !(usage & ~TextureUsageBit::SAMPLED_ALL))
 	{
 		out = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 	}
-	else if(!!(usage & TextureUsageBit::COMPUTE_SHADER_IMAGE_READ_WRITE)
-		&& !(usage & ~TextureUsageBit::COMPUTE_SHADER_IMAGE_READ_WRITE))
+	else if(!!(usage & TextureUsageBit::IMAGE_COMPUTE_READ_WRITE)
+		&& !(usage & ~TextureUsageBit::IMAGE_COMPUTE_READ_WRITE))
 	{
 		out = VK_IMAGE_LAYOUT_GENERAL;
 	}
@@ -574,9 +636,9 @@ VkImageLayout TextureImpl::computeLayout(TextureUsageBit usage, U level) const
 	}
 	else if(m_depthStencil
 		&& !!(usage & TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ)
-		&& !!(usage & TextureUsageBit::ANY_GRAPHICS_SHADER_SAMPLED)
+		&& !!(usage & TextureUsageBit::SAMPLED_ALL_GRAPHICS)
 		&& !(usage
-				& ~(TextureUsageBit::ANY_GRAPHICS_SHADER_SAMPLED
+				& ~(TextureUsageBit::SAMPLED_ALL_GRAPHICS
 					  | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ)))
 	{
 		out = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;

src/gr/vulkan/TransientMemoryManager.cpp

@@ -30,8 +30,8 @@ Error TransientMemoryManager::init(const ConfigSet& cfg)
 			sizeof(F32) * 4}};
 
 	Array<BufferUsageBit, U(TransientBufferType::COUNT)> usages = {
-		{BufferUsageBit::UNIFORM_ANY_SHADER,
-			BufferUsageBit::STORAGE_ANY,
+		{BufferUsageBit::UNIFORM_ALL,
+			BufferUsageBit::STORAGE_ALL,
 			BufferUsageBit::VERTEX,
 			BufferUsageBit::TRANSFER_SOURCE}};
 

src/renderer/Bloom.cpp

@@ -42,7 +42,7 @@ Error Bloom::initInternal(const ConfigSet& config)
 	m_r->createRenderTarget(m_extractExposure.m_width,
 		m_extractExposure.m_height,
 		RT_PIXEL_FORMAT,
-		TextureUsageBit::FRAGMENT_SHADER_SAMPLED
+		TextureUsageBit::SAMPLED_FRAGMENT
 			| TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
 		SamplingFilter::LINEAR,
 		1,
@@ -51,7 +51,7 @@ Error Bloom::initInternal(const ConfigSet& config)
 	m_r->createRenderTarget(m_upscale.m_width,
 		m_upscale.m_height,
 		RT_PIXEL_FORMAT,
-		TextureUsageBit::FRAGMENT_SHADER_SAMPLED
+		TextureUsageBit::SAMPLED_FRAGMENT
 			| TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE,
 		SamplingFilter::LINEAR,
 		1,
@@ -114,9 +114,11 @@ Error Bloom::initInternal(const ConfigSet& config)
 		ResourceGroupInitInfo descInit;
 		descInit.m_textures[0].m_texture = m_r->getIs().getRt();
 		descInit.m_uniformBuffers[0].m_uploadedMemory = true;
+		descInit.m_uniformBuffers[0].m_usage = BufferUsageBit::UNIFORM_FRAGMENT;
 
 		descInit.m_storageBuffers[0].m_buffer =
 			m_r->getTm().getAverageLuminanceBuffer();
+		descInit.m_storageBuffers[0].m_usage = BufferUsageBit::STORAGE_FRAGMENT;
 
 		m_extractExposure.m_rsrc = gr.newInstance<ResourceGroup>(descInit);
 	}
@@ -156,7 +158,7 @@ void Bloom::run(RenderingContext& ctx)
 	TransientMemoryInfo dyn;
 	Vec4* uniforms = static_cast<Vec4*>(
 		getGrManager().allocateFrameTransientMemory(sizeof(Vec4),
-			BufferUsageBit::UNIFORM_ANY_SHADER,
+			BufferUsageBit::UNIFORM_ALL,
 			dyn.m_uniformBuffers[0]));
 	*uniforms = Vec4(m_threshold, m_scale, 0.0, 0.0);
 
@@ -168,7 +170,7 @@ void Bloom::run(RenderingContext& ctx)
 	// pass 1
 	cmdb->setTextureBarrier(m_extractExposure.m_rt,
 		TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
-		TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+		TextureUsageBit::SAMPLED_FRAGMENT,
 		TextureSurfaceInfo(0, 0, 0, 0));
 
 	cmdb->setTextureBarrier(m_upscale.m_rt,
@@ -197,7 +199,7 @@ void Bloom::setPostRunBarriers(RenderingContext& ctx)
 {
 	ctx.m_commandBuffer->setTextureBarrier(m_upscale.m_rt,
 		TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
-		TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+		TextureUsageBit::SAMPLED_FRAGMENT,
 		TextureSurfaceInfo(0, 0, 0, 0));
 }
 

src/renderer/DownscaleBlur.cpp

@@ -99,7 +99,7 @@ void DownscaleBlur::run(RenderingContext& ctx)
 		{
 			cmdb->setTextureBarrier(m_r->getIs().getRt(),
 				TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
-				TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+				TextureUsageBit::SAMPLED_FRAGMENT,
 				TextureSurfaceInfo(i, 0, 0, 0));
 		}
 

src/renderer/Drawer.cpp

@@ -216,7 +216,7 @@ void RenderableDrawer::setupUniforms(DrawContext& ctx,
 	U8* uniforms =
 		static_cast<U8*>(m_r->getGrManager().allocateFrameTransientMemory(
 			variant.getDefaultBlockSize(),
-			BufferUsageBit::UNIFORM_ANY_SHADER,
+			BufferUsageBit::UNIFORM_ALL,
 			ctx.m_dynBufferInfo.m_uniformBuffers[0]));
 
 	// Call the visitor

src/renderer/Fs.cpp

@@ -29,7 +29,7 @@ Error Fs::init(const ConfigSet&)
 	m_r->createRenderTarget(m_width,
 		m_height,
 		IS_COLOR_ATTACHMENT_PIXEL_FORMAT,
-		TextureUsageBit::FRAGMENT_SHADER_SAMPLED
+		TextureUsageBit::SAMPLED_FRAGMENT
 			| TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE,
 		SamplingFilter::NEAREST,
 		1,
@@ -45,6 +45,9 @@ Error Fs::init(const ConfigSet&)
 	fbInit.m_depthStencilAttachment.m_texture = m_r->getMs().getDepthRt();
 	fbInit.m_depthStencilAttachment.m_loadOperation =
 		AttachmentLoadOperation::LOAD;
+	fbInit.m_depthStencilAttachment.m_usageInsideRenderPass =
+		TextureUsageBit::SAMPLED_FRAGMENT
+		| TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ;
 	fbInit.m_depthStencilAttachment.m_surface.m_level = 1;
 	m_fb = getGrManager().newInstance<Framebuffer>(fbInit);
 
@@ -52,15 +55,27 @@ Error Fs::init(const ConfigSet&)
 	{
 		ResourceGroupInitInfo init;
 		init.m_textures[0].m_texture = m_r->getMs().getDepthRt();
+		init.m_textures[0].m_usage = TextureUsageBit::SAMPLED_FRAGMENT
+			| TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ;
 		init.m_textures[1].m_texture = m_r->getSm().getSpotTextureArray();
 		init.m_textures[2].m_texture = m_r->getSm().getOmniTextureArray();
 
 		init.m_uniformBuffers[0].m_uploadedMemory = true;
+		init.m_uniformBuffers[0].m_usage =
+			BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
 		init.m_uniformBuffers[1].m_uploadedMemory = true;
+		init.m_uniformBuffers[1].m_usage =
+			BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
 		init.m_uniformBuffers[2].m_uploadedMemory = true;
+		init.m_uniformBuffers[1].m_usage =
+			BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
 
 		init.m_storageBuffers[0].m_uploadedMemory = true;
+		init.m_storageBuffers[0].m_usage =
+			BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
 		init.m_storageBuffers[1].m_uploadedMemory = true;
+		init.m_storageBuffers[1].m_usage =
+			BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
 
 		m_globalResources = getGrManager().newInstance<ResourceGroup>(init);
 	}
@@ -124,7 +139,7 @@ void Fs::setPostRunBarriers(RenderingContext& ctx)
 {
 	ctx.m_commandBuffer->setTextureBarrier(m_rt,
 		TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE,
-		TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+		TextureUsageBit::SAMPLED_FRAGMENT,
 		TextureSurfaceInfo(0, 0, 0, 0));
 }
 

src/renderer/Ir.cpp

@@ -171,7 +171,7 @@ void Ir::initFaceInfo(U cacheEntryIdx, U faceIdx)
 	texinit.m_samples = 1;
 	texinit.m_sampling.m_minMagFilter = SamplingFilter::NEAREST;
 	texinit.m_sampling.m_mipmapFilter = SamplingFilter::NEAREST;
-	texinit.m_usage = TextureUsageBit::FRAGMENT_SHADER_SAMPLED
+	texinit.m_usage = TextureUsageBit::SAMPLED_FRAGMENT
 		| TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE;
 
 	// Create color attachments
@@ -226,7 +226,7 @@ void Ir::initFaceInfo(U cacheEntryIdx, U faceIdx)
 	fbInit.m_depthStencilAttachment.m_texture = face.m_gbufferDepthRt;
 	fbInit.m_depthStencilAttachment.m_usageInsideRenderPass =
 		TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ
-		| TextureUsageBit::FRAGMENT_SHADER_SAMPLED;
+		| TextureUsageBit::SAMPLED_FRAGMENT;
 
 	face.m_isFb = getGrManager().newInstance<Framebuffer>(fbInit);
 
@@ -236,9 +236,15 @@ void Ir::initFaceInfo(U cacheEntryIdx, U faceIdx)
 	rcinit.m_textures[1].m_texture = face.m_gbufferColorRts[1];
 	rcinit.m_textures[2].m_texture = face.m_gbufferColorRts[2];
 	rcinit.m_textures[3].m_texture = face.m_gbufferDepthRt;
+	rcinit.m_textures[3].m_usage = TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ
+		| TextureUsageBit::SAMPLED_FRAGMENT;
 
 	rcinit.m_uniformBuffers[0].m_uploadedMemory = true;
+	rcinit.m_uniformBuffers[0].m_usage =
+		BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
 	rcinit.m_uniformBuffers[1].m_uploadedMemory = true;
+	rcinit.m_uniformBuffers[1].m_usage =
+		BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
 
 	rcinit.m_vertexBuffers[0].m_buffer = m_is.m_plightPositions;
 	rcinit.m_indexBuffer.m_buffer = m_is.m_plightIndices;
@@ -280,7 +286,7 @@ Error Ir::initIs()
 	texinit.m_samples = 1;
 	texinit.m_sampling.m_minMagFilter = SamplingFilter::LINEAR;
 	texinit.m_sampling.m_mipmapFilter = SamplingFilter::LINEAR;
-	texinit.m_usage = TextureUsageBit::FRAGMENT_SHADER_SAMPLED
+	texinit.m_usage = TextureUsageBit::SAMPLED_FRAGMENT
 		| TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE
 		| TextureUsageBit::CLEAR;
 	texinit.m_format = IS_COLOR_ATTACHMENT_PIXEL_FORMAT;
@@ -308,7 +314,7 @@ Error Ir::initIs()
 
 				cmdb->setTextureBarrier(m_is.m_lightRt,
 					TextureUsageBit::CLEAR,
-					TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+					TextureUsageBit::SAMPLED_FRAGMENT,
 					surf);
 			}
 		}
@@ -398,7 +404,7 @@ Error Ir::initIrradiance()
 	texinit.m_samples = 1;
 	texinit.m_sampling.m_minMagFilter = SamplingFilter::LINEAR;
 	texinit.m_sampling.m_mipmapFilter = SamplingFilter::LINEAR;
-	texinit.m_usage = TextureUsageBit::FRAGMENT_SHADER_SAMPLED
+	texinit.m_usage = TextureUsageBit::SAMPLED_FRAGMENT
 		| TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE
 		| TextureUsageBit::CLEAR;
 	texinit.m_format = IS_COLOR_ATTACHMENT_PIXEL_FORMAT;
@@ -425,6 +431,8 @@ Error Ir::initIrradiance()
 	// Create the resources
 	ResourceGroupInitInfo rcInit;
 	rcInit.m_uniformBuffers[0].m_uploadedMemory = true;
+	rcInit.m_uniformBuffers[0].m_usage =
+		BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
 	rcInit.m_textures[0].m_texture = m_is.m_lightRt;
 
 	m_irradiance.m_rsrc = getGrManager().newInstance<ResourceGroup>(rcInit);
@@ -451,7 +459,7 @@ Error Ir::initIrradiance()
 
 				cmdb->setTextureBarrier(m_is.m_lightRt,
 					TextureUsageBit::CLEAR,
-					TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+					TextureUsageBit::SAMPLED_FRAGMENT,
 					surf);
 			}
 		}
@@ -508,13 +516,13 @@ Error Ir::runMs(
 	{
 		cmdb->setTextureBarrier(face.m_gbufferColorRts[i],
 			TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
-			TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+			TextureUsageBit::SAMPLED_FRAGMENT,
 			TextureSurfaceInfo(0, 0, 0, 0));
 	}
 
 	cmdb->setTextureBarrier(face.m_gbufferDepthRt,
 		TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE,
-		TextureUsageBit::FRAGMENT_SHADER_SAMPLED
+		TextureUsageBit::SAMPLED_FRAGMENT
 			| TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ,
 		TextureSurfaceInfo(0, 0, 0, 0));
 
@@ -556,7 +564,7 @@ void Ir::runIs(
 		// Update uniforms
 		IrVertex* vert = static_cast<IrVertex*>(
 			getGrManager().allocateFrameTransientMemory(sizeof(IrVertex),
-				BufferUsageBit::UNIFORM_ANY_SHADER,
+				BufferUsageBit::UNIFORM_ALL,
 				transient.m_uniformBuffers[0]));
 
 		Mat4 modelM(movec.getWorldTransform().getOrigin().xyz1(),
@@ -567,7 +575,7 @@ void Ir::runIs(
 
 		IrPointLight* light = static_cast<IrPointLight*>(
 			getGrManager().allocateFrameTransientMemory(sizeof(IrPointLight),
-				BufferUsageBit::UNIFORM_ANY_SHADER,
+				BufferUsageBit::UNIFORM_ALL,
 				transient.m_uniformBuffers[1]));
 
 		Vec4 pos = vMat * movec.getWorldTransform().getOrigin().xyz1();
@@ -616,7 +624,7 @@ void Ir::runIs(
 		// Update vertex uniforms
 		IrVertex* vert = static_cast<IrVertex*>(
 			getGrManager().allocateFrameTransientMemory(sizeof(IrVertex),
-				BufferUsageBit::UNIFORM_ANY_SHADER,
+				BufferUsageBit::UNIFORM_ALL,
 				transient.m_uniformBuffers[0]));
 
 		vert->m_mvp = vpMat * modelM;
@@ -624,7 +632,7 @@ void Ir::runIs(
 		// Update fragment uniforms
 		IrSpotLight* light = static_cast<IrSpotLight*>(
 			getGrManager().allocateFrameTransientMemory(sizeof(IrSpotLight),
-				BufferUsageBit::UNIFORM_ANY_SHADER,
+				BufferUsageBit::UNIFORM_ALL,
 				transient.m_uniformBuffers[1]));
 
 		light->m_projectionParams = frc.getProjectionParameters();
@@ -664,7 +672,7 @@ void Ir::runIs(
 
 	cmdb->setTextureBarrier(m_is.m_lightRt,
 		TextureUsageBit::GENERATE_MIPMAPS,
-		TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+		TextureUsageBit::SAMPLED_FRAGMENT,
 		TextureSurfaceInfo(0, 0, faceIdx, layer));
 }
 
@@ -686,7 +694,7 @@ void Ir::computeIrradiance(RenderingContext& rctx, U layer, U faceIdx)
 	TransientMemoryInfo dinf;
 	UVec4* faceIdxArrayIdx = static_cast<UVec4*>(
 		getGrManager().allocateFrameTransientMemory(sizeof(UVec4),
-			BufferUsageBit::UNIFORM_ANY_SHADER,
+			BufferUsageBit::UNIFORM_ALL,
 			dinf.m_uniformBuffers[0]));
 	faceIdxArrayIdx->x() = faceIdx;
 	faceIdxArrayIdx->y() = layer;
@@ -708,7 +716,7 @@ void Ir::computeIrradiance(RenderingContext& rctx, U layer, U faceIdx)
 
 	cmdb->setTextureBarrier(m_irradiance.m_cubeArr,
 		TextureUsageBit::GENERATE_MIPMAPS,
-		TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+		TextureUsageBit::SAMPLED_FRAGMENT,
 		TextureSurfaceInfo(0, 0, faceIdx, layer));
 }
 

src/renderer/Is.cpp

@@ -137,9 +137,9 @@ Error Is::initInternal(const ConfigSet& config)
 	m_r->createRenderTarget(m_r->getWidth(),
 		m_r->getHeight(),
 		IS_COLOR_ATTACHMENT_PIXEL_FORMAT,
-		TextureUsageBit::FRAGMENT_SHADER_SAMPLED
+		TextureUsageBit::SAMPLED_FRAGMENT
 			| TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE
-			| TextureUsageBit::COMPUTE_SHADER_SAMPLED,
+			| TextureUsageBit::SAMPLED_COMPUTE,
 		SamplingFilter::LINEAR,
 		m_rtMipCount,
 		m_rt);
@@ -172,12 +172,24 @@ Error Is::initInternal(const ConfigSet& config)
 		init.m_textures[8].m_sampler = m_r->getIr().getIntegrationLutSampler();
 
 		init.m_uniformBuffers[0].m_uploadedMemory = true;
+		init.m_uniformBuffers[0].m_usage =
+			BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
 		init.m_uniformBuffers[1].m_uploadedMemory = true;
+		init.m_uniformBuffers[1].m_usage =
+			BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
 		init.m_uniformBuffers[2].m_uploadedMemory = true;
+		init.m_uniformBuffers[2].m_usage =
+			BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
 		init.m_uniformBuffers[3].m_uploadedMemory = true;
+		init.m_uniformBuffers[3].m_usage =
+			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[1].m_uploadedMemory = true;
+		init.m_storageBuffers[1].m_usage =
+			BufferUsageBit::STORAGE_FRAGMENT | BufferUsageBit::STORAGE_VERTEX;
 
 		m_rcGroup = getGrManager().newInstance<ResourceGroup>(init);
 	}
@@ -224,7 +236,7 @@ void Is::updateCommonBlock(RenderingContext& ctx)
 	ShaderCommonUniforms* blk = static_cast<ShaderCommonUniforms*>(
 		getGrManager().allocateFrameTransientMemory(
 			sizeof(ShaderCommonUniforms),
-			BufferUsageBit::UNIFORM_ANY_SHADER,
+			BufferUsageBit::UNIFORM_ALL,
 			ctx.m_is.m_dynBufferInfo.m_uniformBuffers[COMMON_VARS_LOCATION]));
 
 	// Start writing

src/renderer/Lf.cpp

@@ -136,6 +136,8 @@ Error Lf::initOcclusion(const ConfigSet& config)
 		ResourceGroupInitInfo rcInit;
 		rcInit.m_vertexBuffers[0].m_uploadedMemory = true;
 		rcInit.m_uniformBuffers[0].m_uploadedMemory = true;
+		rcInit.m_uniformBuffers[0].m_usage =
+			BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
 		m_occlusionRcGroup = getGrManager().newInstance<ResourceGroup>(rcInit);
 	}
 
@@ -173,7 +175,7 @@ void Lf::runOcclusionTests(RenderingContext& ctx)
 		TransientMemoryToken token;
 		Mat4* mvp =
 			static_cast<Mat4*>(getGrManager().allocateFrameTransientMemory(
-				sizeof(Mat4), BufferUsageBit::UNIFORM_ANY_SHADER, token));
+				sizeof(Mat4), BufferUsageBit::UNIFORM_ALL, token));
 		*mvp = camFr.getViewProjectionMatrix();
 
 		// Alloc dyn mem
@@ -258,7 +260,7 @@ void Lf::run(RenderingContext& ctx)
 			Sprite* tmpSprites = static_cast<Sprite*>(
 				getGrManager().allocateFrameTransientMemory(
 					spritesCount * sizeof(Sprite),
-					BufferUsageBit::UNIFORM_ANY_SHADER,
+					BufferUsageBit::UNIFORM_ALL,
 					token));
 			WeakArray<Sprite> sprites(tmpSprites, spritesCount);
 

src/renderer/LightBin.cpp

@@ -380,7 +380,7 @@ Error LightBin::bin(FrustumComponent& frc,
 		ShaderPointLight* data =
 			static_cast<ShaderPointLight*>(m_gr->allocateFrameTransientMemory(
 				sizeof(ShaderPointLight) * visiblePointLightsCount,
-				BufferUsageBit::UNIFORM_ANY_SHADER,
+				BufferUsageBit::UNIFORM_ALL,
 				pointLightsToken));
 
 		ctx.m_pointLights =
@@ -400,7 +400,7 @@ Error LightBin::bin(FrustumComponent& frc,
 		ShaderSpotLight* data =
 			static_cast<ShaderSpotLight*>(m_gr->allocateFrameTransientMemory(
 				sizeof(ShaderSpotLight) * visibleSpotLightsCount,
-				BufferUsageBit::UNIFORM_ANY_SHADER,
+				BufferUsageBit::UNIFORM_ALL,
 				spotLightsToken));
 
 		ctx.m_spotLights =
@@ -422,7 +422,7 @@ Error LightBin::bin(FrustumComponent& frc,
 			ShaderProbe* data =
 				static_cast<ShaderProbe*>(m_gr->allocateFrameTransientMemory(
 					sizeof(ShaderProbe) * visibleProbeCount,
-					BufferUsageBit::UNIFORM_ANY_SHADER,
+					BufferUsageBit::UNIFORM_ALL,
 					*probesToken));
 
 			ctx.m_probes = WeakArray<ShaderProbe>(data, visibleProbeCount);
@@ -443,7 +443,7 @@ Error LightBin::bin(FrustumComponent& frc,
 	ShaderCluster* data =
 		static_cast<ShaderCluster*>(m_gr->allocateFrameTransientMemory(
 			sizeof(ShaderCluster) * m_clusterCount,
-			BufferUsageBit::STORAGE_ANY,
+			BufferUsageBit::STORAGE_ALL,
 			clustersToken));
 
 	ctx.m_clusters = WeakArray<ShaderCluster>(data, m_clusterCount);
@@ -451,7 +451,7 @@ Error LightBin::bin(FrustumComponent& frc,
 	// Allocate light IDs
 	U32* data2 = static_cast<U32*>(
 		m_gr->allocateFrameTransientMemory(maxLightIndices * sizeof(U32),
-			BufferUsageBit::STORAGE_ANY,
+			BufferUsageBit::STORAGE_ALL,
 			lightIndicesToken));
 
 	ctx.m_lightIds = WeakArray<U32>(data2, maxLightIndices);

src/renderer/Ms.cpp

@@ -36,7 +36,7 @@ Error Ms::createRt(U32 samples)
 	m_r->createRenderTarget(m_r->getWidth(),
 		m_r->getHeight(),
 		DEPTH_RT_PIXEL_FORMAT,
-		TextureUsageBit::FRAGMENT_SHADER_SAMPLED
+		TextureUsageBit::SAMPLED_FRAGMENT
 			| TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE
 			| TextureUsageBit::GENERATE_MIPMAPS,
 		SamplingFilter::NEAREST,
@@ -46,7 +46,7 @@ Error Ms::createRt(U32 samples)
 	m_r->createRenderTarget(m_r->getWidth(),
 		m_r->getHeight(),
 		RT_PIXEL_FORMATS[0],
-		TextureUsageBit::FRAGMENT_SHADER_SAMPLED
+		TextureUsageBit::SAMPLED_FRAGMENT
 			| TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
 		SamplingFilter::NEAREST,
 		1,
@@ -55,7 +55,7 @@ Error Ms::createRt(U32 samples)
 	m_r->createRenderTarget(m_r->getWidth(),
 		m_r->getHeight(),
 		RT_PIXEL_FORMATS[1],
-		TextureUsageBit::FRAGMENT_SHADER_SAMPLED
+		TextureUsageBit::SAMPLED_FRAGMENT
 			| TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
 		SamplingFilter::NEAREST,
 		1,
@@ -64,7 +64,7 @@ Error Ms::createRt(U32 samples)
 	m_r->createRenderTarget(m_r->getWidth(),
 		m_r->getHeight(),
 		RT_PIXEL_FORMATS[2],
-		TextureUsageBit::FRAGMENT_SHADER_SAMPLED
+		TextureUsageBit::SAMPLED_FRAGMENT
 			| TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE
 			| TextureUsageBit::GENERATE_MIPMAPS,
 		SamplingFilter::NEAREST,
@@ -233,22 +233,22 @@ void Ms::setPostRunBarriers(RenderingContext& ctx)
 
 	cmdb->setTextureBarrier(m_rt0,
 		TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
-		TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+		TextureUsageBit::SAMPLED_FRAGMENT,
 		surf);
 
 	cmdb->setTextureBarrier(m_rt1,
 		TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
-		TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+		TextureUsageBit::SAMPLED_FRAGMENT,
 		surf);
 
 	cmdb->setTextureBarrier(m_rt2,
 		TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
-		TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+		TextureUsageBit::SAMPLED_FRAGMENT,
 		surf);
 
 	cmdb->setTextureBarrier(m_depthRt,
 		TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE,
-		TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+		TextureUsageBit::SAMPLED_FRAGMENT,
 		surf);
 
 	ANKI_TRACE_STOP_EVENT(RENDER_MS);

src/renderer/Pps.cpp

@@ -43,7 +43,7 @@ Error Pps::initInternal(const ConfigSet& config)
 	m_r->createRenderTarget(m_r->getWidth(),
 		m_r->getHeight(),
 		RT_PIXEL_FORMAT,
-		TextureUsageBit::FRAGMENT_SHADER_SAMPLED
+		TextureUsageBit::SAMPLED_FRAGMENT
 			| TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
 		SamplingFilter::LINEAR,
 		1,
@@ -92,6 +92,7 @@ Error Pps::initInternal(const ConfigSet& config)
 
 	rcInit.m_storageBuffers[0].m_buffer =
 		m_r->getTm().getAverageLuminanceBuffer();
+	rcInit.m_storageBuffers[0].m_usage = BufferUsageBit::STORAGE_FRAGMENT;
 
 	m_rcGroup = getGrManager().newInstance<ResourceGroup>(rcInit);
 

src/renderer/Renderer.cpp

@@ -193,7 +193,7 @@ Error Renderer::render(RenderingContext& ctx)
 	RendererCommonUniforms* commonUniforms =
 		static_cast<RendererCommonUniforms*>(
 			getGrManager().allocateFrameTransientMemory(sizeof(*commonUniforms),
-				BufferUsageBit::UNIFORM_ANY_SHADER,
+				BufferUsageBit::UNIFORM_ALL,
 				m_commonUniformsToken));
 
 	commonUniforms->m_projectionParams = frc.getProjectionParameters();
@@ -246,12 +246,12 @@ Error Renderer::render(RenderingContext& ctx)
 	m_is->run(ctx);
 
 	cmdb->setTextureBarrier(m_ms->getDepthRt(),
-		TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+		TextureUsageBit::SAMPLED_FRAGMENT,
 		TextureUsageBit::GENERATE_MIPMAPS,
 		TextureSurfaceInfo(0, 0, 0, 0));
 
 	cmdb->setTextureBarrier(m_ms->getRt2(),
-		TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+		TextureUsageBit::SAMPLED_FRAGMENT,
 		TextureUsageBit::GENERATE_MIPMAPS,
 		TextureSurfaceInfo(0, 0, 0, 0));
 
@@ -262,13 +262,13 @@ Error Renderer::render(RenderingContext& ctx)
 	{
 		cmdb->setTextureBarrier(m_ms->getDepthRt(),
 			TextureUsageBit::GENERATE_MIPMAPS,
-			TextureUsageBit::FRAGMENT_SHADER_SAMPLED
+			TextureUsageBit::SAMPLED_FRAGMENT
 				| TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ,
 			TextureSurfaceInfo(i, 0, 0, 0));
 
 		cmdb->setTextureBarrier(m_ms->getRt2(),
 			TextureUsageBit::GENERATE_MIPMAPS,
-			TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+			TextureUsageBit::SAMPLED_FRAGMENT,
 			TextureSurfaceInfo(i, 0, 0, 0));
 	}
 
@@ -286,19 +286,23 @@ Error Renderer::render(RenderingContext& ctx)
 
 	cmdb->setTextureBarrier(m_is->getRt(),
 		TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE,
-		TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+		TextureUsageBit::SAMPLED_FRAGMENT,
 		TextureSurfaceInfo(0, 0, 0, 0));
 
 	m_downscale->run(ctx);
 
 	cmdb->setTextureBarrier(m_is->getRt(),
 		TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
-		TextureUsageBit::FRAGMENT_SHADER_SAMPLED
-			| TextureUsageBit::COMPUTE_SHADER_SAMPLED,
+		TextureUsageBit::SAMPLED_COMPUTE,
 		TextureSurfaceInfo(m_is->getRtMipmapCount() - 1, 0, 0, 0));
 
 	m_tm->run(ctx);
 
+	cmdb->setTextureBarrier(m_is->getRt(),
+		TextureUsageBit::SAMPLED_COMPUTE,
+		TextureUsageBit::SAMPLED_FRAGMENT,
+		TextureSurfaceInfo(m_is->getRtMipmapCount() - 1, 0, 0, 0));
+
 	m_bloom->run(ctx);
 	m_sslf->run(ctx);
 	cmdb->endRenderPass();

src/renderer/Sm.cpp

@@ -34,7 +34,7 @@ Error Sm::init(const ConfigSet& config)
 
 	// Create shadowmaps array
 	TextureInitInfo sminit;
-	sminit.m_usage = TextureUsageBit::FRAGMENT_SHADER_SAMPLED
+	sminit.m_usage = TextureUsageBit::SAMPLED_FRAGMENT
 		| TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE;
 	sminit.m_type = TextureType::_2D_ARRAY;
 	sminit.m_width = m_resolution;
@@ -500,7 +500,7 @@ void Sm::setPostRunBarriers(RenderingContext& ctx)
 
 		cmdb->setTextureBarrier(m_spotTexArray,
 			TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE,
-			TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+			TextureUsageBit::SAMPLED_FRAGMENT,
 			TextureSurfaceInfo(0, 0, 0, layer));
 	}
 
@@ -513,7 +513,7 @@ void Sm::setPostRunBarriers(RenderingContext& ctx)
 
 			cmdb->setTextureBarrier(m_omniTexArray,
 				TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE,
-				TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+				TextureUsageBit::SAMPLED_FRAGMENT,
 				TextureSurfaceInfo(0, 0, j, layer));
 		}
 	}

src/renderer/Ssao.cpp

@@ -68,7 +68,7 @@ Error Ssao::createFb(FramebufferPtr& fb, TexturePtr& rt)
 	m_r->createRenderTarget(m_width,
 		m_height,
 		RT_PIXEL_FORMAT,
-		TextureUsageBit::FRAGMENT_SHADER_SAMPLED
+		TextureUsageBit::SAMPLED_FRAGMENT
 			| TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
 		SamplingFilter::LINEAR,
 		1,
@@ -114,8 +114,7 @@ Error Ssao::initInternal(const ConfigSet& config)
 	//
 	TextureInitInfo tinit;
 
-	tinit.m_usage =
-		TextureUsageBit::FRAGMENT_SHADER_SAMPLED | TextureUsageBit::UPLOAD;
+	tinit.m_usage = TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::UPLOAD;
 	tinit.m_width = tinit.m_height = NOISE_TEX_SIZE;
 	tinit.m_depth = 1;
 	tinit.m_layerCount = 1;
@@ -246,6 +245,8 @@ Error Ssao::initInternal(const ConfigSet& config)
 
 	rcinit.m_textures[0].m_texture = m_r->getMs().getDepthRt();
 	rcinit.m_textures[0].m_sampler = gr.newInstance<Sampler>(sinit);
+	rcinit.m_textures[0].m_usage = TextureUsageBit::SAMPLED_FRAGMENT
+		| TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ;
 
 	rcinit.m_textures[1].m_texture = m_r->getMs().getRt2();
 	rcinit.m_textures[1].m_sampler = rcinit.m_textures[0].m_sampler;
@@ -253,6 +254,7 @@ Error Ssao::initInternal(const ConfigSet& config)
 	rcinit.m_textures[2].m_texture = m_noiseTex;
 
 	rcinit.m_uniformBuffers[0].m_uploadedMemory = true;
+	rcinit.m_uniformBuffers[0].m_usage = BufferUsageBit::UNIFORM_FRAGMENT;
 	m_rcFirst = gr.newInstance<ResourceGroup>(rcinit);
 
 	rcinit = ResourceGroupInitInfo();
@@ -294,7 +296,7 @@ void Ssao::setPostRunBarriers(RenderingContext& ctx)
 {
 	ctx.m_commandBuffer->setTextureBarrier(m_vblurRt,
 		TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
-		TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+		TextureUsageBit::SAMPLED_FRAGMENT,
 		TextureSurfaceInfo(0, 0, 0, 0));
 }
 
@@ -324,7 +326,7 @@ void Ssao::run(RenderingContext& ctx)
 		// hpass
 		cmdb->setTextureBarrier(m_vblurRt,
 			TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
-			TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+			TextureUsageBit::SAMPLED_FRAGMENT,
 			TextureSurfaceInfo(0, 0, 0, 0));
 		cmdb->setTextureBarrier(m_hblurRt,
 			TextureUsageBit::NONE,
@@ -339,7 +341,7 @@ void Ssao::run(RenderingContext& ctx)
 		// vpass
 		cmdb->setTextureBarrier(m_hblurRt,
 			TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
-			TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+			TextureUsageBit::SAMPLED_FRAGMENT,
 			TextureSurfaceInfo(0, 0, 0, 0));
 		cmdb->setTextureBarrier(m_vblurRt,
 			TextureUsageBit::NONE,

src/renderer/Tiler.cpp

@@ -68,7 +68,7 @@ Error Tiler::initInternal()
 	{
 		// Create the buffer
 		m_outBuffers[i] = getGrManager().newInstance<Buffer>(
-			pboSize, BufferUsageBit::STORAGE_ANY, BufferMapAccessBit::READ);
+			pboSize, BufferUsageBit::STORAGE_ALL, BufferMapAccessBit::READ);
 
 		// Create graphics resources
 		ResourceGroupInitInfo rcinit;

src/renderer/Tm.cpp

@@ -37,7 +37,7 @@ Error Tm::create(const ConfigSet& initializer)
 
 	// Create buffer
 	m_luminanceBuff = getGrManager().newInstance<Buffer>(sizeof(Vec4),
-		BufferUsageBit::STORAGE_ANY | BufferUsageBit::UNIFORM_ANY_SHADER
+		BufferUsageBit::STORAGE_ALL | BufferUsageBit::UNIFORM_ALL
 			| BufferUsageBit::TRANSFER_DESTINATION,
 		BufferMapAccessBit::NONE);
 
@@ -54,7 +54,10 @@ Error Tm::create(const ConfigSet& initializer)
 	ResourceGroupInitInfo rcinit;
 	rcinit.m_storageBuffers[0].m_buffer = m_luminanceBuff;
 	rcinit.m_storageBuffers[0].m_range = sizeof(Vec4);
+	rcinit.m_storageBuffers[0].m_usage =
+		BufferUsageBit::STORAGE_COMPUTE_READ_WRITE;
 	rcinit.m_textures[0].m_texture = m_r->getIs().getRt();
+	rcinit.m_textures[0].m_usage = TextureUsageBit::SAMPLED_COMPUTE;
 
 	m_rcGroup = getGrManager().newInstance<ResourceGroup>(rcinit);
 
@@ -70,9 +73,6 @@ void Tm::run(RenderingContext& ctx)
 	cmdb->bindResourceGroup(m_rcGroup, 0, nullptr);
 
 	cmdb->dispatchCompute(1, 1, 1);
-	cmdb->setBufferBarrier(m_luminanceBuff,
-		BufferUsageBit::STORAGE_COMPUTE_SHADER_WRITE,
-		BufferUsageBit::UNIFORM_FRAGMENT_SHADER);
 }
 
 } // end namespace anki

src/renderer/Upsample.cpp

@@ -25,11 +25,15 @@ Error Upsample::init(const ConfigSet& config)
 	sinit.m_repeat = false;
 
 	rcInit.m_textures[0].m_texture = m_r->getMs().getDepthRt();
+	rcInit.m_textures[0].m_usage = TextureUsageBit::SAMPLED_FRAGMENT
+		| TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ;
 
 	sinit.m_minLod = 1.0;
 	sinit.m_mipmapFilter = SamplingFilter::NEAREST;
 	rcInit.m_textures[1].m_texture = m_r->getMs().getDepthRt();
 	rcInit.m_textures[1].m_sampler = gr.newInstance<Sampler>(sinit);
+	rcInit.m_textures[1].m_usage = TextureUsageBit::SAMPLED_FRAGMENT
+		| TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ;
 
 	sinit.m_minLod = 0.0;
 	rcInit.m_textures[2].m_texture = m_r->getFs().getRt();
@@ -42,6 +46,7 @@ Error Upsample::init(const ConfigSet& config)
 	rcInit.m_textures[4].m_texture = m_r->getSsao().getRt();
 
 	rcInit.m_uniformBuffers[0].m_uploadedMemory = true;
+	rcInit.m_uniformBuffers[0].m_usage = BufferUsageBit::UNIFORM_FRAGMENT;
 
 	m_rcGroup = getGrManager().newInstance<ResourceGroup>(rcInit);
 
@@ -96,7 +101,7 @@ void Upsample::run(RenderingContext& ctx)
 
 	Vec4* linearDepth = static_cast<Vec4*>(
 		getGrManager().allocateFrameTransientMemory(sizeof(Vec4),
-			BufferUsageBit::UNIFORM_ANY_SHADER,
+			BufferUsageBit::UNIFORM_ALL,
 			dyn.m_uniformBuffers[0]));
 	const Frustum& fr = ctx.m_frustumComponent->getFrustum();
 	computeLinearizeDepthOptimal(

src/renderer/Volumetric.cpp

@@ -34,7 +34,10 @@ Error Volumetric::init(const ConfigSet& config)
 	// Create the resource group
 	ResourceGroupInitInfo rcInit;
 	rcInit.m_textures[0].m_texture = m_r->getMs().getDepthRt();
+	rcInit.m_textures[0].m_usage = TextureUsageBit::SAMPLED_FRAGMENT
+		| TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ;
 	rcInit.m_uniformBuffers[0].m_uploadedMemory = true;
+	rcInit.m_uniformBuffers[0].m_usage = BufferUsageBit::UNIFORM_FRAGMENT;
 
 	m_rcGroup = getGrManager().newInstance<ResourceGroup>(rcInit);
 
@@ -51,7 +54,7 @@ void Volumetric::run(RenderingContext& ctx)
 	TransientMemoryInfo dyn;
 	Vec4* uniforms = static_cast<Vec4*>(
 		getGrManager().allocateFrameTransientMemory(sizeof(Vec4) * 2,
-			BufferUsageBit::UNIFORM_ANY_SHADER,
+			BufferUsageBit::UNIFORM_ALL,
 			dyn.m_uniformBuffers[0]));
 
 	computeLinearizeDepthOptimal(

src/resource/Material.cpp

@@ -47,6 +47,9 @@ Error UpdateTexturesVisitor::
 {
 	m_init->m_textures[var.getTextureUnit()].m_texture =
 		var.getValue()->getGrTexture();
+	m_init->m_textures[var.getTextureUnit()].m_usage =
+		TextureUsageBit::SAMPLED_FRAGMENT
+		| TextureUsageBit::SAMPLED_TESSELLATION_EVALUATION;
 	return ErrorCode::NONE;
 }
 
@@ -440,6 +443,8 @@ Error Material::createProgramSourceToCache(
 void Material::fillResourceGroupInitInfo(ResourceGroupInitInfo& rcinit)
 {
 	rcinit.m_uniformBuffers[0].m_uploadedMemory = true;
+	rcinit.m_uniformBuffers[0].m_usage =
+		BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
 
 	UpdateTexturesVisitor visitor;
 	visitor.m_init = &rcinit;

src/resource/TextureResource.cpp

@@ -132,8 +132,8 @@ TextureResource::~TextureResource()
 Error TextureResource::load(const ResourceFilename& filename)
 {
 	TextureInitInfo init;
-	init.m_usage = TextureUsageBit::FRAGMENT_SHADER_SAMPLED
-		| TextureUsageBit::TESSELLATION_EVALUATION_SHADER_SAMPLED
+	init.m_usage = TextureUsageBit::SAMPLED_FRAGMENT
+		| TextureUsageBit::SAMPLED_TESSELLATION_EVALUATION
 		| TextureUsageBit::UPLOAD;
 	U faces = 0;
 

src/scene/LensFlareComponent.cpp

@@ -40,7 +40,10 @@ Error LensFlareComponent::init(const CString& textureFilename)
 	// Resource group
 	ResourceGroupInitInfo rcInit;
 	rcInit.m_textures[0].m_texture = m_tex->getGrTexture();
+	rcInit.m_textures[0].m_usage = TextureUsageBit::SAMPLED_FRAGMENT;
 	rcInit.m_uniformBuffers[0].m_uploadedMemory = true;
+	rcInit.m_uniformBuffers[0].m_usage =
+		BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
 	m_rcGroup = gr.newInstance<ResourceGroup>(rcInit);
 
 	return ErrorCode::NONE;

tests/gr/Gr.cpp

@@ -483,10 +483,10 @@ ANKI_TEST(Gr, Buffer)
 
 	{
 		BufferPtr a = gr->newInstance<Buffer>(
-			512, BufferUsageBit::UNIFORM_ANY_SHADER, BufferMapAccessBit::NONE);
+			512, BufferUsageBit::UNIFORM_ALL, BufferMapAccessBit::NONE);
 
 		BufferPtr b = gr->newInstance<Buffer>(64,
-			BufferUsageBit::STORAGE_ANY,
+			BufferUsageBit::STORAGE_ALL,
 			BufferMapAccessBit::WRITE | BufferMapAccessBit::READ);
 
 		void* ptr = b->map(0, 64, BufferMapAccessBit::WRITE);
@@ -512,11 +512,13 @@ ANKI_TEST(Gr, ResourceGroup)
 
 	{
 		BufferPtr b = gr->newInstance<Buffer>(sizeof(F32) * 4,
-			BufferUsageBit::UNIFORM_ANY_SHADER,
+			BufferUsageBit::UNIFORM_ALL,
 			BufferMapAccessBit::WRITE);
 
 		ResourceGroupInitInfo rcinit;
 		rcinit.m_uniformBuffers[0].m_buffer = b;
+		rcinit.m_uniformBuffers[0].m_usage =
+			BufferUsageBit::UNIFORM_ALL_GRAPHICS;
 		ResourceGroupPtr rc = gr->newInstance<ResourceGroup>(rcinit);
 	}
 
@@ -531,7 +533,7 @@ ANKI_TEST(Gr, DrawWithUniforms)
 	{
 		// A non-uploaded buffer
 		BufferPtr b = gr->newInstance<Buffer>(sizeof(Vec4) * 3,
-			BufferUsageBit::UNIFORM_ANY_SHADER,
+			BufferUsageBit::UNIFORM_ALL,
 			BufferMapAccessBit::WRITE);
 
 		Vec4* ptr = static_cast<Vec4*>(
@@ -545,7 +547,11 @@ ANKI_TEST(Gr, DrawWithUniforms)
 		// Resource group
 		ResourceGroupInitInfo rcinit;
 		rcinit.m_uniformBuffers[0].m_buffer = b;
+		rcinit.m_uniformBuffers[0].m_usage =
+			BufferUsageBit::UNIFORM_ALL_GRAPHICS;
 		rcinit.m_uniformBuffers[1].m_uploadedMemory = true;
+		rcinit.m_uniformBuffers[1].m_usage =
+			BufferUsageBit::UNIFORM_ALL_GRAPHICS;
 		ResourceGroupPtr rc = gr->newInstance<ResourceGroup>(rcinit);
 
 		// Ppline
@@ -568,7 +574,7 @@ ANKI_TEST(Gr, DrawWithUniforms)
 			Error err = ErrorCode::NONE;
 			Vec4* rotMat = static_cast<Vec4*>(
 				gr->allocateFrameTransientMemory(sizeof(Vec4),
-					BufferUsageBit::UNIFORM_ANY_SHADER,
+					BufferUsageBit::UNIFORM_ALL,
 					transientInfo.m_uniformBuffers[1],
 					&err));
 			ANKI_TEST_EXPECT_NO_ERR(err);
@@ -744,7 +750,7 @@ ANKI_TEST(Gr, Texture)
 		init.m_depth = 1;
 		init.m_format =
 			PixelFormat(ComponentFormat::R8G8B8, TransformFormat::UNORM);
-		init.m_usage = TextureUsageBit::FRAGMENT_SHADER_SAMPLED;
+		init.m_usage = TextureUsageBit::SAMPLED_FRAGMENT;
 		init.m_height = 4;
 		init.m_width = 4;
 		init.m_mipmapsCount = 2;
@@ -775,8 +781,8 @@ ANKI_TEST(Gr, DrawWithTexture)
 		init.m_format =
 			PixelFormat(ComponentFormat::R8G8B8A8, TransformFormat::UNORM);
 		init.m_usage =
-			TextureUsageBit::FRAGMENT_SHADER_SAMPLED | TextureUsageBit::UPLOAD;
-		init.m_initialUsage = TextureUsageBit::FRAGMENT_SHADER_SAMPLED;
+			TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::UPLOAD;
+		init.m_initialUsage = TextureUsageBit::SAMPLED_FRAGMENT;
 		init.m_height = 2;
 		init.m_width = 2;
 		init.m_mipmapsCount = 2;
@@ -796,7 +802,7 @@ ANKI_TEST(Gr, DrawWithTexture)
 		init.m_width = 4;
 		init.m_height = 4;
 		init.m_mipmapsCount = 3;
-		init.m_usage = TextureUsageBit::FRAGMENT_SHADER_SAMPLED
+		init.m_usage = TextureUsageBit::SAMPLED_FRAGMENT
 			| TextureUsageBit::UPLOAD | TextureUsageBit::GENERATE_MIPMAPS;
 		init.m_initialUsage = TextureUsageBit::NONE;
 
@@ -881,12 +887,12 @@ ANKI_TEST(Gr, DrawWithTexture)
 
 		// Set barriers
 		cmdb->setTextureBarrier(a,
-			TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+			TextureUsageBit::SAMPLED_FRAGMENT,
 			TextureUsageBit::UPLOAD,
 			TextureSurfaceInfo(0, 0, 0, 0));
 
 		cmdb->setTextureBarrier(a,
-			TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+			TextureUsageBit::SAMPLED_FRAGMENT,
 			TextureUsageBit::UPLOAD,
 			TextureSurfaceInfo(1, 0, 0, 0));
 
@@ -932,19 +938,19 @@ ANKI_TEST(Gr, DrawWithTexture)
 		// Set barriers
 		cmdb->setTextureBarrier(a,
 			TextureUsageBit::UPLOAD,
-			TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+			TextureUsageBit::SAMPLED_FRAGMENT,
 			TextureSurfaceInfo(0, 0, 0, 0));
 
 		cmdb->setTextureBarrier(a,
 			TextureUsageBit::UPLOAD,
-			TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+			TextureUsageBit::SAMPLED_FRAGMENT,
 			TextureSurfaceInfo(1, 0, 0, 0));
 
 		for(U i = 0; i < 3; ++i)
 		{
 			cmdb->setTextureBarrier(b,
 				TextureUsageBit::GENERATE_MIPMAPS,
-				TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+				TextureUsageBit::SAMPLED_FRAGMENT,
 				TextureSurfaceInfo(i, 0, 0, 0));
 		}
 
@@ -1031,14 +1037,14 @@ static void drawOffscreenDrawcalls(GrManager& gr,
 		1.0f);
 
 	Mat4* mvp = static_cast<Mat4*>(gr.allocateFrameTransientMemory(sizeof(*mvp),
-		BufferUsageBit::UNIFORM_ANY_SHADER,
+		BufferUsageBit::UNIFORM_ALL,
 		transientInfo.m_uniformBuffers[0],
 		nullptr));
 	*mvp = projMat * viewMat * modelMat;
 
 	Vec4* color =
 		static_cast<Vec4*>(gr.allocateFrameTransientMemory(sizeof(*color) * 2,
-			BufferUsageBit::UNIFORM_ANY_SHADER,
+			BufferUsageBit::UNIFORM_ALL,
 			transientInfo.m_uniformBuffers[1],
 			nullptr));
 	*color++ = Vec4(1.0, 0.0, 0.0, 0.0);
@@ -1055,14 +1061,14 @@ static void drawOffscreenDrawcalls(GrManager& gr,
 		1.0f);
 
 	mvp = static_cast<Mat4*>(gr.allocateFrameTransientMemory(sizeof(*mvp),
-		BufferUsageBit::UNIFORM_ANY_SHADER,
+		BufferUsageBit::UNIFORM_ALL,
 		transientInfo.m_uniformBuffers[0],
 		nullptr));
 	*mvp = projMat * viewMat * modelMat;
 
 	color =
 		static_cast<Vec4*>(gr.allocateFrameTransientMemory(sizeof(*color) * 2,
-			BufferUsageBit::UNIFORM_ANY_SHADER,
+			BufferUsageBit::UNIFORM_ALL,
 			transientInfo.m_uniformBuffers[1],
 			nullptr));
 	*color++ = Vec4(0.0, 0.0, 1.0, 0.0);
@@ -1085,7 +1091,7 @@ static void drawOffscreen(GrManager& gr, Bool useSecondLevel)
 	TextureInitInfo init;
 	init.m_depth = 1;
 	init.m_format = COL_FORMAT;
-	init.m_usage = TextureUsageBit::FRAGMENT_SHADER_SAMPLED
+	init.m_usage = TextureUsageBit::SAMPLED_FRAGMENT
 		| TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE;
 	init.m_height = TEX_SIZE;
 	init.m_width = TEX_SIZE;
@@ -1130,7 +1136,11 @@ static void drawOffscreen(GrManager& gr, Bool useSecondLevel)
 
 	ResourceGroupInitInfo rcinit;
 	rcinit.m_uniformBuffers[0].m_uploadedMemory = true;
+	rcinit.m_uniformBuffers[0].m_usage =
+		BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
 	rcinit.m_uniformBuffers[1].m_uploadedMemory = true;
+	rcinit.m_uniformBuffers[1].m_usage =
+		BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
 	rcinit.m_vertexBuffers[0].m_buffer = verts;
 	rcinit.m_indexBuffer.m_buffer = indices;
 	rcinit.m_indexSize = 2;
@@ -1222,15 +1232,15 @@ static void drawOffscreen(GrManager& gr, Bool useSecondLevel)
 
 		cmdb->setTextureBarrier(col0,
 			TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
-			TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+			TextureUsageBit::SAMPLED_FRAGMENT,
 			TextureSurfaceInfo(0, 0, 0, 0));
 		cmdb->setTextureBarrier(col1,
 			TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
-			TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+			TextureUsageBit::SAMPLED_FRAGMENT,
 			TextureSurfaceInfo(0, 0, 0, 0));
 		cmdb->setTextureBarrier(dp,
 			TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE,
-			TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+			TextureUsageBit::SAMPLED_FRAGMENT,
 			TextureSurfaceInfo(0, 0, 0, 0));
 
 		// Draw quad
@@ -1283,9 +1293,8 @@ ANKI_TEST(Gr, ImageLoadStore)
 		TextureInitInfo init;
 		init.m_width = init.m_height = 4;
 		init.m_mipmapsCount = 2;
-		init.m_usage = TextureUsageBit::CLEAR
-			| TextureUsageBit::ANY_SHADER_SAMPLED
-			| TextureUsageBit::COMPUTE_SHADER_IMAGE_WRITE;
+		init.m_usage = TextureUsageBit::CLEAR | TextureUsageBit::SAMPLED_ALL
+			| TextureUsageBit::IMAGE_COMPUTE_WRITE;
 		init.m_type = TextureType::_2D;
 		init.m_format =
 			PixelFormat(ComponentFormat::R8G8B8A8, TransformFormat::UNORM);
@@ -1312,6 +1321,7 @@ ANKI_TEST(Gr, ImageLoadStore)
 
 		rcinit = ResourceGroupInitInfo();
 		rcinit.m_images[0].m_texture = tex;
+		rcinit.m_images[0].m_usage = TextureUsageBit::IMAGE_COMPUTE_WRITE;
 		rcinit.m_images[0].m_level = 1;
 		ResourceGroupPtr rc1 = gr->newInstance<ResourceGroup>(rcinit);
 
@@ -1333,7 +1343,7 @@ ANKI_TEST(Gr, ImageLoadStore)
 
 		cmdb->setTextureBarrier(tex,
 			TextureUsageBit::CLEAR,
-			TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+			TextureUsageBit::SAMPLED_FRAGMENT,
 			TextureSurfaceInfo(0, 0, 0, 0));
 
 		cmdb->setTextureBarrier(tex,
@@ -1346,7 +1356,7 @@ ANKI_TEST(Gr, ImageLoadStore)
 
 		cmdb->setTextureBarrier(tex,
 			TextureUsageBit::CLEAR,
-			TextureUsageBit::COMPUTE_SHADER_IMAGE_WRITE,
+			TextureUsageBit::IMAGE_COMPUTE_WRITE,
 			TextureSurfaceInfo(1, 0, 0, 0));
 
 		cmdb->flush();
@@ -1363,12 +1373,16 @@ ANKI_TEST(Gr, ImageLoadStore)
 			CommandBufferPtr cmdb = gr->newInstance<CommandBuffer>(cinit);
 
 			// Write iamge
+			cmdb->setTextureBarrier(tex,
+				TextureUsageBit::NONE,
+				TextureUsageBit::IMAGE_COMPUTE_WRITE,
+				TextureSurfaceInfo(1, 0, 0, 0));
 			cmdb->bindPipeline(compPpline);
 			cmdb->bindResourceGroup(rc1, 0, nullptr);
 			cmdb->dispatchCompute(WIDTH / 2, HEIGHT / 2, 1);
 			cmdb->setTextureBarrier(tex,
-				TextureUsageBit::COMPUTE_SHADER_IMAGE_WRITE,
-				TextureUsageBit::FRAGMENT_SHADER_SAMPLED,
+				TextureUsageBit::IMAGE_COMPUTE_WRITE,
+				TextureUsageBit::SAMPLED_FRAGMENT,
 				TextureSurfaceInfo(1, 0, 0, 0));
 
 			// Present image