Refactor TextureUsageBit

src/anki/gr/CommandBuffer.h

@@ -109,7 +109,7 @@ class CommandBufferInitInfo : public GrBaseInitInfo
 {
 public:
 	FramebufferPtr m_framebuffer; ///< For second level command buffers.
-	Array<TextureUsageBit, MAX_COLOR_ATTACHMENTS> m_colorAttachmentUsages = {};
+	Array<TextureUsageBit, MAX_COLOR_ATTACHMENTS> m_colorAttachmentUsages{};
 	TextureUsageBit m_depthStencilAttachmentUsage = TextureUsageBit::NONE;
 
 	CommandBufferFlag m_flags = CommandBufferFlag::NONE;

src/anki/gr/Enums.h

@@ -379,43 +379,48 @@ inline Bool textureTypeIsCube(const TextureType t)
 }
 
 /// Texture usage hints. They are very important.
-enum class TextureUsageBit : U16
+enum class TextureUsageBit : U32
 {
 	NONE = 0,
 
-	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,
-
-	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,
-
-	FRAMEBUFFER_ATTACHMENT_READ = 1 << 8,
-	FRAMEBUFFER_ATTACHMENT_WRITE = 1 << 9,
-	FRAMEBUFFER_ATTACHMENT_READ_WRITE = FRAMEBUFFER_ATTACHMENT_READ | FRAMEBUFFER_ATTACHMENT_WRITE,
-
-	TRANSFER_DESTINATION = 1 << 10,
-	TRANSFER_ALL = TRANSFER_DESTINATION,
-
-	// Misc
-	GENERATE_MIPMAPS = 1 << 11,
-	CLEAR = 1 << 12, ///< Will be used in CommandBuffer::clearTextureView.
-	PRESENT = 1 << 13,
+	SAMPLED_GEOMETRY = 1 << 0,
+	SAMPLED_FRAGMENT = 1 << 1,
+	SAMPLED_COMPUTE = 1 << 2,
+	SAMPLED_RAY_GEN = 1 << 3,
+
+	IMAGE_GEOMETRY_READ = 1 << 4,
+	IMAGE_GEOMETRY_WRITE = 1 << 5,
+	IMAGE_FRAGMENT_READ = 1 << 6,
+	IMAGE_FRAGMENT_WRITE = 1 << 7,
+	IMAGE_COMPUTE_READ = 1 << 8,
+	IMAGE_COMPUTE_WRITE = 1 << 9,
+	IMAGE_RAY_GEN_READ = 1 << 10,
+	IMAGE_RAY_GEN_WRITE = 1 << 11,
+
+	FRAMEBUFFER_ATTACHMENT_READ = 1 << 12,
+	FRAMEBUFFER_ATTACHMENT_WRITE = 1 << 13,
+
+	TRANSFER_DESTINATION = 1 << 14,
+	GENERATE_MIPMAPS = 1 << 15,
+
+	PRESENT = 1 << 16,
 
 	// Derived
-	ALL_COMPUTE = SAMPLED_COMPUTE | IMAGE_COMPUTE_READ_WRITE,
-	ALL_GRAPHICS = SAMPLED_ALL_GRAPHICS | FRAMEBUFFER_ATTACHMENT_READ_WRITE,
-	ALL_READ = SAMPLED_ALL | IMAGE_COMPUTE_READ | FRAMEBUFFER_ATTACHMENT_READ | PRESENT | GENERATE_MIPMAPS,
-	ALL_WRITE =
-		IMAGE_COMPUTE_WRITE | FRAMEBUFFER_ATTACHMENT_WRITE | TRANSFER_DESTINATION | GENERATE_MIPMAPS | CLEAR | PRESENT,
+	ALL_SAMPLED = SAMPLED_GEOMETRY | SAMPLED_FRAGMENT | SAMPLED_COMPUTE | SAMPLED_RAY_GEN,
+	ALL_IMAGE = IMAGE_GEOMETRY_READ | IMAGE_GEOMETRY_WRITE | IMAGE_FRAGMENT_READ | IMAGE_FRAGMENT_WRITE
+				| IMAGE_COMPUTE_READ | IMAGE_COMPUTE_WRITE | IMAGE_RAY_GEN_READ | IMAGE_RAY_GEN_WRITE,
+	ALL_FRAMEBUFFER_ATTACHMENT = FRAMEBUFFER_ATTACHMENT_READ | FRAMEBUFFER_ATTACHMENT_WRITE,
+
+	ALL_GRAPHICS = SAMPLED_GEOMETRY | SAMPLED_FRAGMENT | IMAGE_GEOMETRY_READ | IMAGE_GEOMETRY_WRITE
+				   | IMAGE_FRAGMENT_READ | IMAGE_FRAGMENT_WRITE | FRAMEBUFFER_ATTACHMENT_READ
+				   | FRAMEBUFFER_ATTACHMENT_WRITE,
+	ALL_COMPUTE = SAMPLED_COMPUTE | IMAGE_COMPUTE_READ | IMAGE_COMPUTE_WRITE,
+	ALL_TRANSFER = TRANSFER_DESTINATION | GENERATE_MIPMAPS,
+
+	ALL_READ = ALL_SAMPLED | IMAGE_GEOMETRY_READ | IMAGE_FRAGMENT_READ | IMAGE_COMPUTE_READ | IMAGE_RAY_GEN_READ
+			   | FRAMEBUFFER_ATTACHMENT_READ | PRESENT | GENERATE_MIPMAPS,
+	ALL_WRITE = IMAGE_GEOMETRY_WRITE | IMAGE_FRAGMENT_WRITE | IMAGE_COMPUTE_WRITE | IMAGE_RAY_GEN_WRITE
+				| FRAMEBUFFER_ATTACHMENT_WRITE | TRANSFER_DESTINATION | GENERATE_MIPMAPS
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(TextureUsageBit, inline)
 

src/anki/gr/RenderGraph.cpp

@@ -1427,19 +1427,22 @@ StringAuto RenderGraph::textureUsageToStr(StackAllocator<U8>& alloc, TextureUsag
 			slist.pushBackSprintf("%s", #u); \
 		}
 
-	ANKI_TEX_USAGE(SAMPLED_VERTEX);
-	ANKI_TEX_USAGE(SAMPLED_TESSELLATION_CONTROL);
-	ANKI_TEX_USAGE(SAMPLED_TESSELLATION_EVALUATION);
 	ANKI_TEX_USAGE(SAMPLED_GEOMETRY);
 	ANKI_TEX_USAGE(SAMPLED_FRAGMENT);
 	ANKI_TEX_USAGE(SAMPLED_COMPUTE);
+	ANKI_TEX_USAGE(SAMPLED_RAY_GEN);
+	ANKI_TEX_USAGE(IMAGE_GEOMETRY_READ);
+	ANKI_TEX_USAGE(IMAGE_GEOMETRY_WRITE);
+	ANKI_TEX_USAGE(IMAGE_FRAGMENT_READ);
+	ANKI_TEX_USAGE(IMAGE_FRAGMENT_WRITE);
 	ANKI_TEX_USAGE(IMAGE_COMPUTE_READ);
 	ANKI_TEX_USAGE(IMAGE_COMPUTE_WRITE);
+	ANKI_TEX_USAGE(IMAGE_RAY_GEN_READ);
+	ANKI_TEX_USAGE(IMAGE_RAY_GEN_WRITE);
 	ANKI_TEX_USAGE(FRAMEBUFFER_ATTACHMENT_READ);
 	ANKI_TEX_USAGE(FRAMEBUFFER_ATTACHMENT_WRITE);
 	ANKI_TEX_USAGE(TRANSFER_DESTINATION);
 	ANKI_TEX_USAGE(GENERATE_MIPMAPS);
-	ANKI_TEX_USAGE(CLEAR);
 	ANKI_TEX_USAGE(PRESENT);
 
 	if(!usage)

src/anki/gr/RenderGraph.inl.h

@@ -101,8 +101,7 @@ inline void RenderPassDescriptionBase::validateDep(const RenderPassDependency& d
 		}
 		else
 		{
-			constexpr AccelerationStructureUsageBit usage = ~AccelerationStructureUsageBit::ALL_GRAPHICS;
-			ANKI_ASSERT(!(dep.m_as.m_usage & usage));
+			ANKI_ASSERT(!(dep.m_as.m_usage & ~AccelerationStructureUsageBit::ALL_GRAPHICS));
 		}
 	}
 }

src/anki/gr/Texture.h

@@ -32,7 +32,7 @@ public:
 
 	U8 m_samples = 1;
 
-	U8 _m_padding[3] = {0, 0, 0};
+	U8 _m_padding[1] = {0};
 
 	TextureInitInfo() = default;
 

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

@@ -129,6 +129,9 @@ inline void CommandBufferImpl::setTextureBarrierRange(TexturePtr tex, TextureUsa
 	const TextureImpl& impl = static_cast<const TextureImpl&>(*tex);
 	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");
 
 	VkPipelineStageFlags srcStage;
 	VkAccessFlags srcAccess;

src/anki/gr/vulkan/Common.cpp

@@ -374,17 +374,17 @@ VkImageUsageFlags convertTextureUsage(const TextureUsageBit ak, const Format for
 {
 	VkImageUsageFlags out = 0;
 
-	if(!!(ak & TextureUsageBit::SAMPLED_ALL))
+	if(!!(ak & TextureUsageBit::ALL_SAMPLED))
 	{
 		out |= VK_IMAGE_USAGE_SAMPLED_BIT;
 	}
 
-	if(!!(ak & TextureUsageBit::IMAGE_ALL))
+	if(!!(ak & TextureUsageBit::ALL_IMAGE))
 	{
 		out |= VK_IMAGE_USAGE_STORAGE_BIT;
 	}
 
-	if(!!(ak & TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE))
+	if(!!(ak & (TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE)))
 	{
 		if(formatIsDepthStencil(format))
 		{
@@ -396,19 +396,14 @@ VkImageUsageFlags convertTextureUsage(const TextureUsageBit ak, const Format for
 		}
 	}
 
-	if(!!(ak & TextureUsageBit::GENERATE_MIPMAPS))
-	{
-		out |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
-	}
-
 	if(!!(ak & TextureUsageBit::TRANSFER_DESTINATION))
 	{
 		out |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
 	}
 
-	if(!!(ak & TextureUsageBit::CLEAR))
+	if(!!(ak & TextureUsageBit::GENERATE_MIPMAPS))
 	{
-		out |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+		out |= VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
 	}
 
 	ANKI_ASSERT(out);

src/anki/gr/vulkan/SwapchainFactory.cpp

@@ -181,8 +181,8 @@ Error MicroSwapchain::initInternal()
 			init.m_height = surfaceHeight;
 			init.m_format = Format::B8G8R8A8_UNORM;
 			ANKI_ASSERT(surfaceFormat == VK_FORMAT_B8G8R8A8_UNORM);
-			init.m_usage = TextureUsageBit::IMAGE_COMPUTE_WRITE | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE
-						   | TextureUsageBit::PRESENT;
+			init.m_usage = TextureUsageBit::IMAGE_COMPUTE_WRITE | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ
+						   | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE | TextureUsageBit::PRESENT;
 			init.m_type = TextureType::_2D;
 
 			TextureImpl* tex =

src/anki/gr/vulkan/TextureImpl.cpp

@@ -161,7 +161,7 @@ VkFormatFeatureFlags TextureImpl::calcFeatures(const TextureInitInfo& init)
 		flags |= VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT;
 	}
 
-	if(!!(init.m_usage & TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE))
+	if(!!(init.m_usage & TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT))
 	{
 		if(formatIsDepthStencil(init.m_format))
 		{
@@ -173,7 +173,7 @@ VkFormatFeatureFlags TextureImpl::calcFeatures(const TextureInitInfo& init)
 		}
 	}
 
-	if(!!(init.m_usage & TextureUsageBit::SAMPLED_ALL))
+	if(!!(init.m_usage & TextureUsageBit::ALL_SAMPLED))
 	{
 		flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
 	}
@@ -223,7 +223,7 @@ Error TextureImpl::initImage(const TextureInitInfo& init_)
 		// Try to find a fallback
 		if(init.m_format >= Format::R8G8B8_UNORM && init.m_format <= Format::R8G8B8_SRGB)
 		{
-			ANKI_ASSERT(!(init.m_usage & TextureUsageBit::IMAGE_ALL) && "Can't do that ATM");
+			ANKI_ASSERT(!(init.m_usage & TextureUsageBit::ALL_IMAGE) && "Can't do that ATM");
 			const U idx = U(init.m_format) - U(Format::R8G8B8_UNORM);
 			init.m_format = Format(U(Format::R8G8B8A8_UNORM) + idx);
 			ANKI_ASSERT(init.m_format >= Format::R8G8B8A8_UNORM && init.m_format <= Format::R8G8B8A8_SRGB);
@@ -233,7 +233,7 @@ Error TextureImpl::initImage(const TextureInitInfo& init_)
 		}
 		else if(init.m_format == Format::S8_UINT)
 		{
-			ANKI_ASSERT(!(init.m_usage & (TextureUsageBit::IMAGE_ALL | TextureUsageBit::TRANSFER_ALL))
+			ANKI_ASSERT(!(init.m_usage & (TextureUsageBit::ALL_IMAGE | TextureUsageBit::ALL_TRANSFER))
 						&& "Can't do that ATM");
 			init.m_format = Format::D24_UNORM_S8_UINT;
 			m_format = init.m_format;
@@ -242,7 +242,7 @@ Error TextureImpl::initImage(const TextureInitInfo& init_)
 		}
 		else if(init.m_format == Format::D24_UNORM_S8_UINT)
 		{
-			ANKI_ASSERT(!(init.m_usage & (TextureUsageBit::IMAGE_ALL | TextureUsageBit::TRANSFER_ALL))
+			ANKI_ASSERT(!(init.m_usage & (TextureUsageBit::ALL_IMAGE | TextureUsageBit::ALL_TRANSFER))
 						&& "Can't do that ATM");
 			init.m_format = Format::D32_SFLOAT_S8_UINT;
 			m_format = init.m_format;
@@ -378,228 +378,130 @@ Error TextureImpl::initImage(const TextureInitInfo& init_)
 	return Error::NONE;
 }
 
-void TextureImpl::computeBarrierInfo(TextureUsageBit before, TextureUsageBit after, U level,
-									 VkPipelineStageFlags& srcStages, VkAccessFlags& srcAccesses,
-									 VkPipelineStageFlags& dstStages, VkAccessFlags& dstAccesses) const
+void TextureImpl::computeBarrierInfo(TextureUsageBit usage, Bool src, U32 level, VkPipelineStageFlags& stages,
+									 VkAccessFlags& accesses) const
 {
 	ANKI_ASSERT(level < m_mipCount);
-	ANKI_ASSERT(usageValid(before) && usageValid(after));
-	srcStages = 0;
-	srcAccesses = 0;
-	dstStages = 0;
-	dstAccesses = 0;
-	const Bool lastLevel = level == m_mipCount - 1u;
+	ANKI_ASSERT(usageValid(usage));
+	stages = 0;
+	accesses = 0;
 	const Bool depthStencil = !!m_aspect;
 
-	//
-	// Before
-	//
-	if(!!(before & TextureUsageBit::SAMPLED_VERTEX))
+	if(!!(usage & (TextureUsageBit::SAMPLED_GEOMETRY | TextureUsageBit::IMAGE_GEOMETRY_READ)))
 	{
-		srcStages |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
-		srcAccesses |= VK_ACCESS_SHADER_READ_BIT;
+		stages |= 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;
+		accesses |= VK_ACCESS_SHADER_READ_BIT;
 	}
 
-	if(!!(before & TextureUsageBit::SAMPLED_TESSELLATION_CONTROL))
+	if(!!(usage & TextureUsageBit::IMAGE_GEOMETRY_WRITE))
 	{
-		srcStages |= VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT;
-		srcAccesses |= VK_ACCESS_SHADER_READ_BIT;
+		stages |= 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;
+		accesses |= VK_ACCESS_SHADER_WRITE_BIT;
 	}
 
-	if(!!(before & TextureUsageBit::SAMPLED_TESSELLATION_EVALUATION))
+	if(!!(usage & (TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::IMAGE_FRAGMENT_READ)))
 	{
-		srcStages |= VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT;
-		srcAccesses |= VK_ACCESS_SHADER_READ_BIT;
+		stages |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
+		accesses |= VK_ACCESS_SHADER_READ_BIT;
 	}
 
-	if(!!(before & TextureUsageBit::SAMPLED_GEOMETRY))
+	if(!!(usage & TextureUsageBit::IMAGE_FRAGMENT_WRITE))
 	{
-		srcStages |= VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
-		srcAccesses |= VK_ACCESS_SHADER_READ_BIT;
+		stages |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
+		accesses |= VK_ACCESS_SHADER_WRITE_BIT;
 	}
 
-	if(!!(before & TextureUsageBit::SAMPLED_FRAGMENT))
+	if(!!(usage & (TextureUsageBit::SAMPLED_COMPUTE | TextureUsageBit::IMAGE_COMPUTE_READ)))
 	{
-		srcStages |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
-		srcAccesses |= VK_ACCESS_SHADER_READ_BIT;
+		stages |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
+		accesses |= VK_ACCESS_SHADER_READ_BIT;
 	}
 
-	if(!!(before & TextureUsageBit::SAMPLED_COMPUTE) || !!(before & TextureUsageBit::IMAGE_COMPUTE_READ))
+	if(!!(usage & TextureUsageBit::IMAGE_COMPUTE_WRITE))
 	{
-		srcStages |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
-		srcAccesses |= VK_ACCESS_SHADER_READ_BIT;
+		stages |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
+		accesses |= VK_ACCESS_SHADER_WRITE_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(!!(usage & TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ))
 	{
 		if(depthStencil)
 		{
-			srcStages |= VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
-			srcAccesses |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
+			stages |= VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
+			accesses |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
 		}
 		else
 		{
-			srcStages |= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; // See Table 4 in the spec
-			srcAccesses |= VK_ACCESS_COLOR_ATTACHMENT_READ_BIT;
+			stages |= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+			accesses |= VK_ACCESS_COLOR_ATTACHMENT_READ_BIT;
 		}
 	}
 
-	if(!!(before & TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE))
+	if(!!(usage & TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE))
 	{
 		if(depthStencil)
 		{
-			srcStages |= VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
-			srcAccesses |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
+			stages |= VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
+			accesses |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
 		}
 		else
 		{
-			srcStages |= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-			srcAccesses |= VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+			stages |= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+			accesses |= VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
 		}
 	}
 
-	if(!!(before & TextureUsageBit::GENERATE_MIPMAPS))
+	if(!!(usage & TextureUsageBit::GENERATE_MIPMAPS))
 	{
-		srcStages |= VK_PIPELINE_STAGE_TRANSFER_BIT;
-
-		if(!lastLevel)
+		stages |= VK_PIPELINE_STAGE_TRANSFER_BIT;
+		if(src)
 		{
-			srcAccesses |= VK_ACCESS_TRANSFER_READ_BIT;
+			const Bool lastLevel = level == m_mipCount - 1;
+			if(lastLevel)
+			{
+				accesses |= VK_ACCESS_TRANSFER_WRITE_BIT;
+			}
+			else
+			{
+				accesses |= VK_ACCESS_TRANSFER_READ_BIT;
+			}
 		}
 		else
 		{
-			srcAccesses |= VK_ACCESS_TRANSFER_WRITE_BIT;
+			ANKI_ASSERT(level == 0
+						&& "The upper layers should not allow others levels to transition to gen mips state. This "
+						   "happens elsewhere");
+			accesses |= VK_ACCESS_TRANSFER_READ_BIT;
 		}
 	}
 
-	if(!!(before & TextureUsageBit::TRANSFER_DESTINATION))
+	if(!!(usage & TextureUsageBit::TRANSFER_DESTINATION))
 	{
-		srcStages |= VK_PIPELINE_STAGE_TRANSFER_BIT;
-		srcAccesses |= VK_ACCESS_TRANSFER_WRITE_BIT;
+		stages |= VK_PIPELINE_STAGE_TRANSFER_BIT;
+		accesses |= VK_ACCESS_TRANSFER_WRITE_BIT;
 	}
 
-	if(!!(before & TextureUsageBit::CLEAR))
+	if(!!(usage & TextureUsageBit::PRESENT))
 	{
-		srcStages |= VK_PIPELINE_STAGE_TRANSFER_BIT;
-		srcAccesses |= VK_ACCESS_TRANSFER_WRITE_BIT;
+		stages |= VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
+		accesses |= VK_ACCESS_MEMORY_READ_BIT;
 	}
+}
+
+void TextureImpl::computeBarrierInfo(TextureUsageBit before, TextureUsageBit after, U32 level,
+									 VkPipelineStageFlags& srcStages, VkAccessFlags& srcAccesses,
+									 VkPipelineStageFlags& dstStages, VkAccessFlags& dstAccesses) const
+{
+	computeBarrierInfo(before, true, level, srcStages, srcAccesses);
+	computeBarrierInfo(after, false, level, dstStages, dstAccesses);
 
 	if(srcStages == 0)
 	{
 		srcStages = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
 	}
 
-	//
-	// After
-	//
-	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::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(depthStencil)
-		{
-			dstStages |= VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
-			dstAccesses |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
-		}
-		else
-		{
-			dstStages |= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-			dstAccesses |= VK_ACCESS_COLOR_ATTACHMENT_READ_BIT;
-		}
-	}
-
-	if(!!(after & TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE))
-	{
-		if(depthStencil)
-		{
-			dstStages |= VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
-			dstAccesses |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
-		}
-		else
-		{
-			dstStages |= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-			dstAccesses |= VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
-		}
-	}
-
-	if(!!(after & TextureUsageBit::GENERATE_MIPMAPS))
-	{
-		dstStages |= VK_PIPELINE_STAGE_TRANSFER_BIT;
-
-		if(level == 0)
-		{
-			dstAccesses |= VK_ACCESS_TRANSFER_READ_BIT;
-		}
-		else
-		{
-			ANKI_ASSERT(0 && "This will happen in generateMipmaps");
-		}
-	}
-
-	if(!!(after & TextureUsageBit::TRANSFER_DESTINATION))
-	{
-		dstStages |= VK_PIPELINE_STAGE_TRANSFER_BIT;
-		dstAccesses |= VK_ACCESS_TRANSFER_WRITE_BIT;
-	}
-
-	if(!!(after & TextureUsageBit::CLEAR))
-	{
-		dstStages |= VK_PIPELINE_STAGE_TRANSFER_BIT;
-		dstAccesses |= VK_ACCESS_TRANSFER_WRITE_BIT;
-	}
-
-	if(!!(after & TextureUsageBit::PRESENT))
-	{
-		dstStages |= VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
-		dstAccesses |= VK_ACCESS_MEMORY_READ_BIT;
-	}
-
 	ANKI_ASSERT(dstStages);
 }
 
@@ -616,17 +518,17 @@ VkImageLayout TextureImpl::computeLayout(TextureUsageBit usage, U level) const
 	{
 		out = VK_IMAGE_LAYOUT_UNDEFINED;
 	}
-	else if(!(usage & ~TextureUsageBit::SAMPLED_ALL))
+	else if(!(usage & ~TextureUsageBit::ALL_SAMPLED))
 	{
 		// Only sampling
 		out = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 	}
-	else if(!(usage & ~TextureUsageBit::IMAGE_COMPUTE_READ_WRITE))
+	else if(!(usage & ~TextureUsageBit::ALL_IMAGE))
 	{
 		// Only image load/store
 		out = VK_IMAGE_LAYOUT_GENERAL;
 	}
-	else if(!(usage & ~TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE))
+	else if(!(usage & ~TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT))
 	{
 		// Only FB access
 		if(depthStencil)
@@ -638,17 +540,11 @@ VkImageLayout TextureImpl::computeLayout(TextureUsageBit usage, U level) const
 			out = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
 		}
 	}
-	else if(depthStencil && !(usage & ~(TextureUsageBit::SAMPLED_ALL | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ)))
+	else if(depthStencil && !(usage & ~(TextureUsageBit::ALL_SAMPLED | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ)))
 	{
 		// FB read & shader read
 		out = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
 	}
-	else if(depthStencil
-			&& !(usage & ~(TextureUsageBit::SAMPLED_ALL_GRAPHICS | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE)))
-	{
-		// Wild guess: One aspect is shader read and the other is read write
-		out = VK_IMAGE_LAYOUT_GENERAL;
-	}
 	else if(usage == TextureUsageBit::GENERATE_MIPMAPS)
 	{
 		if(!lastLevel)
@@ -660,10 +556,6 @@ VkImageLayout TextureImpl::computeLayout(TextureUsageBit usage, U level) const
 			out = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
 		}
 	}
-	else if(usage == TextureUsageBit::CLEAR)
-	{
-		out = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
-	}
 	else if(!depthStencil && usage == TextureUsageBit::TRANSFER_DESTINATION)
 	{
 		out = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
@@ -672,11 +564,6 @@ VkImageLayout TextureImpl::computeLayout(TextureUsageBit usage, U level) const
 	{
 		out = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
 	}
-	else
-	{
-		// Can't set it to something, chose general
-		out = VK_IMAGE_LAYOUT_GENERAL;
-	}
 
 	ANKI_ASSERT(out != VK_IMAGE_LAYOUT_MAX_ENUM);
 	return out;
@@ -684,38 +571,48 @@ VkImageLayout TextureImpl::computeLayout(TextureUsageBit usage, U level) const
 
 const MicroImageView& TextureImpl::getOrCreateView(const TextureSubresourceInfo& subresource) const
 {
-	LockGuard<Mutex> lock(m_viewsMapMtx);
-	auto it = m_viewsMap.find(subresource);
+	{
+		RLockGuard<RWMutex> lock(m_viewsMapMtx);
+		auto it = m_viewsMap.find(subresource);
+		if(it != m_viewsMap.getEnd())
+		{
+			return *it;
+		}
+	}
+
+	// Not found need to create it
+
+	WLockGuard<RWMutex> lock(m_viewsMapMtx);
 
+	// Search again
+	auto it = m_viewsMap.find(subresource);
 	if(it != m_viewsMap.getEnd())
 	{
-		// Found, do nothing
+		return *it;
 	}
-	else
-	{
-		VkImageView handle = VK_NULL_HANDLE;
-		TextureType viewTexType = TextureType::COUNT;
 
-		// Compute the VkImageViewCreateInfo
-		VkImageViewCreateInfo viewCi;
-		computeVkImageViewCreateInfo(subresource, viewCi, viewTexType);
-		ANKI_ASSERT(viewTexType != TextureType::COUNT);
+	// Not found in the 2nd search, create it
 
-		ANKI_VK_CHECKF(vkCreateImageView(getDevice(), &viewCi, nullptr, &handle));
-		getGrManagerImpl().trySetVulkanHandleName(getName(), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT,
-												  ptrToNumber(handle));
+	VkImageView handle = VK_NULL_HANDLE;
+	TextureType viewTexType = TextureType::COUNT;
 
-		it = m_viewsMap.emplace(getAllocator(), subresource);
-		it->m_handle = handle;
-		it->m_derivedTextureType = viewTexType;
+	// Compute the VkImageViewCreateInfo
+	VkImageViewCreateInfo viewCi;
+	computeVkImageViewCreateInfo(subresource, viewCi, viewTexType);
+	ANKI_ASSERT(viewTexType != TextureType::COUNT);
+
+	ANKI_VK_CHECKF(vkCreateImageView(getDevice(), &viewCi, nullptr, &handle));
+	getGrManagerImpl().trySetVulkanHandleName(getName(), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT,
+											  ptrToNumber(handle));
+
+	it = m_viewsMap.emplace(getAllocator(), subresource);
+	it->m_handle = handle;
+	it->m_derivedTextureType = viewTexType;
 
 #if 0
-		printf("Creating image view %p. Texture %p %s\n",
-			static_cast<void*>(handle),
-			static_cast<void*>(m_imageHandle),
-			getName() ? getName().cstr() : "Unnamed");
+	printf("Creating image view %p. Texture %p %s\n", static_cast<void*>(handle), static_cast<void*>(m_imageHandle),
+		   getName() ? getName().cstr() : "Unnamed");
 #endif
-	}
 
 	ANKI_ASSERT(&(*m_viewsMap.find(subresource)) == &(*it));
 	return *it;

src/anki/gr/vulkan/TextureImpl.h

@@ -147,7 +147,7 @@ public:
 	}
 
 	/// By knowing the previous and new texture usage calculate the relavant info for a ppline barrier.
-	void computeBarrierInfo(TextureUsageBit before, TextureUsageBit after, U level, VkPipelineStageFlags& srcStages,
+	void computeBarrierInfo(TextureUsageBit before, TextureUsageBit after, U32 level, VkPipelineStageFlags& srcStages,
 							VkAccessFlags& srcAccesses, VkPipelineStageFlags& dstStages,
 							VkAccessFlags& dstAccesses) const;
 
@@ -184,7 +184,7 @@ public:
 
 private:
 	mutable HashMap<TextureSubresourceInfo, MicroImageView> m_viewsMap;
-	mutable Mutex m_viewsMapMtx;
+	mutable RWMutex m_viewsMapMtx;
 
 	VkDeviceMemory m_dedicatedMem = VK_NULL_HANDLE;
 
@@ -211,6 +211,9 @@ private:
 	TextureType computeNewTexTypeOfSubresource(const TextureSubresourceInfo& subresource) const;
 
 	ANKI_USE_RESULT Error initInternal(VkImage externalImage, const TextureInitInfo& init);
+
+	void computeBarrierInfo(TextureUsageBit usage, Bool src, U32 level, VkPipelineStageFlags& stages,
+							VkAccessFlags& accesses) const;
 };
 /// @}
 

src/anki/renderer/GBuffer.cpp

@@ -167,7 +167,7 @@ void GBuffer::populateRenderGraph(RenderingContext& ctx)
 	}
 
 	TextureSubresourceInfo subresource(DepthStencilAspectBit::DEPTH);
-	pass.newDependency({m_depthRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE, subresource});
+	pass.newDependency({m_depthRt, TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT, subresource});
 }
 
 } // end namespace anki

src/anki/renderer/GBufferPost.cpp

@@ -64,8 +64,8 @@ void GBufferPost::populateRenderGraph(RenderingContext& ctx)
 
 	rpass.setFramebufferInfo(m_fbDescr, {m_r->getGBuffer().getColorRt(0), m_r->getGBuffer().getColorRt(1)}, {});
 
-	rpass.newDependency({m_r->getGBuffer().getColorRt(0), TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE});
-	rpass.newDependency({m_r->getGBuffer().getColorRt(1), TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE});
+	rpass.newDependency({m_r->getGBuffer().getColorRt(0), TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT});
+	rpass.newDependency({m_r->getGBuffer().getColorRt(1), TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT});
 	rpass.newDependency({m_r->getGBuffer().getDepthRt(), TextureUsageBit::SAMPLED_FRAGMENT,
 						 TextureSubresourceInfo(DepthStencilAspectBit::DEPTH)});
 }

src/anki/renderer/GlobalIllumination.cpp

@@ -92,7 +92,7 @@ void GlobalIllumination::bindVolumeTextures(const RenderingContext& ctx, RenderP
 		else
 		{
 			rgraphCtx.m_commandBuffer->bindTexture(set, binding, m_r->getDummyTextureView3d(),
-												   TextureUsageBit::SAMPLED_ALL, idx);
+												   TextureUsageBit::ALL_SAMPLED, idx);
 		}
 	}
 }
@@ -301,7 +301,7 @@ void GlobalIllumination::populateRenderGraph(RenderingContext& rctx)
 		}
 
 		TextureSubresourceInfo subresource(DepthStencilAspectBit::DEPTH);
-		pass.newDependency({giCtx->m_gbufferDepthRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE, subresource});
+		pass.newDependency({giCtx->m_gbufferDepthRt, TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT, subresource});
 	}
 
 	// Shadow pass. Optional
@@ -341,7 +341,7 @@ void GlobalIllumination::populateRenderGraph(RenderingContext& rctx)
 			giCtx, smTaskCount);
 
 		TextureSubresourceInfo subresource(DepthStencilAspectBit::DEPTH);
-		pass.newDependency({giCtx->m_shadowsRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE, subresource});
+		pass.newDependency({giCtx->m_shadowsRt, TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT, subresource});
 	}
 	else
 	{
@@ -509,7 +509,7 @@ void GlobalIllumination::prepareProbes(InternalContext& giCtx)
 			texInit.m_width = probe.m_cellCounts.x() * 6;
 			texInit.m_height = probe.m_cellCounts.y();
 			texInit.m_depth = probe.m_cellCounts.z();
-			texInit.m_usage = TextureUsageBit::ALL_COMPUTE | TextureUsageBit::SAMPLED_ALL;
+			texInit.m_usage = TextureUsageBit::ALL_COMPUTE | TextureUsageBit::ALL_SAMPLED;
 			texInit.m_initialUsage = TextureUsageBit::SAMPLED_FRAGMENT;
 
 			entry.m_volumeTex = m_r->createAndClearRenderTarget(texInit);

src/anki/renderer/ProbeReflections.cpp

@@ -121,8 +121,8 @@ Error ProbeReflections::initLightShading(const ConfigSet& config)
 	{
 		TextureInitInfo texinit = m_r->create2DRenderTargetInitInfo(
 			m_lightShading.m_tileSize, m_lightShading.m_tileSize, LIGHT_SHADING_COLOR_ATTACHMENT_PIXEL_FORMAT,
-			TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::SAMPLED_COMPUTE
-				| TextureUsageBit::IMAGE_COMPUTE_READ_WRITE | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE
+			TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::SAMPLED_COMPUTE | TextureUsageBit::IMAGE_COMPUTE_READ
+				| TextureUsageBit::IMAGE_COMPUTE_WRITE | TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT
 				| TextureUsageBit::GENERATE_MIPMAPS,
 			"CubeRefl refl");
 		texinit.m_mipmapCount = U8(m_lightShading.m_mipCount);
@@ -565,7 +565,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 		}
 
 		TextureSubresourceInfo subresource(DepthStencilAspectBit::DEPTH);
-		pass.newDependency({m_ctx.m_gbufferDepthRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE, subresource});
+		pass.newDependency({m_ctx.m_gbufferDepthRt, TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT, subresource});
 	}
 
 	// Shadow pass. Optional
@@ -611,7 +611,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 			this, taskCount);
 
 		TextureSubresourceInfo subresource(DepthStencilAspectBit::DEPTH);
-		pass.newDependency({m_ctx.m_shadowMapRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE, subresource});
+		pass.newDependency({m_ctx.m_shadowMapRt, TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT, subresource});
 	}
 	else
 	{
@@ -695,7 +695,8 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 		TextureSubresourceInfo subresource;
 		subresource.m_faceCount = 6;
 		subresource.m_firstLayer = probeToUpdateCacheEntryIdx;
-		pass.newDependency({m_ctx.m_lightShadingRt, TextureUsageBit::IMAGE_COMPUTE_READ_WRITE, subresource});
+		pass.newDependency({m_ctx.m_lightShadingRt,
+							TextureUsageBit::IMAGE_COMPUTE_READ | TextureUsageBit::IMAGE_COMPUTE_WRITE, subresource});
 
 		pass.newDependency({m_ctx.m_irradianceDiceValuesBuffHandle, BufferUsageBit::STORAGE_COMPUTE_READ});
 	}

src/anki/renderer/Renderer.cpp

@@ -104,9 +104,9 @@ Error Renderer::initInternal(const ConfigSet& config)
 	{
 		TextureInitInfo texinit;
 		texinit.m_width = texinit.m_height = 4;
-		texinit.m_usage = TextureUsageBit::SAMPLED_ALL;
+		texinit.m_usage = TextureUsageBit::ALL_SAMPLED;
 		texinit.m_format = Format::R8G8B8A8_UNORM;
-		texinit.m_initialUsage = TextureUsageBit::SAMPLED_ALL;
+		texinit.m_initialUsage = TextureUsageBit::ALL_SAMPLED;
 		TexturePtr tex = getGrManager().newTexture(texinit);
 
 		TextureViewInitInfo viewinit(tex);

src/anki/renderer/ShadowMapping.cpp

@@ -241,7 +241,7 @@ void ShadowMapping::populateRenderGraph(RenderingContext& ctx)
 				this, threadCountForScratchPass);
 
 			TextureSubresourceInfo subresource = TextureSubresourceInfo(DepthStencilAspectBit::DEPTH);
-			pass.newDependency({m_scratch.m_rt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE, subresource});
+			pass.newDependency({m_scratch.m_rt, TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT, subresource});
 		}
 
 		// Atlas pass

src/anki/renderer/Ssgi.cpp

@@ -103,7 +103,7 @@ Error Ssgi::initInternal(const ConfigSet& cfg)
 
 		TextureInitInfo initInfo = m_r->create2DRenderTargetInitInfo(
 			width, height, Format::B10G11R11_UFLOAT_PACK32,
-			TextureUsageBit::SAMPLED_ALL | TextureUsageBit::IMAGE_COMPUTE_WRITE, "SSGI");
+			TextureUsageBit::ALL_SAMPLED | TextureUsageBit::IMAGE_COMPUTE_WRITE, "SSGI");
 		initInfo.m_initialUsage = TextureUsageBit::SAMPLED_FRAGMENT;
 		m_recontruction.m_rt = m_r->createAndClearRenderTarget(initInfo);
 	}

src/anki/renderer/Ssr.cpp

@@ -43,7 +43,8 @@ Error Ssr::initInternal(const ConfigSet& cfg)
 	// Create RTs
 	TextureInitInfo texinit = m_r->create2DRenderTargetInitInfo(
 		width, height, Format::R16G16B16A16_SFLOAT,
-		TextureUsageBit::IMAGE_COMPUTE_READ_WRITE | TextureUsageBit::SAMPLED_FRAGMENT, "SSR");
+		TextureUsageBit::IMAGE_COMPUTE_READ | TextureUsageBit::IMAGE_COMPUTE_WRITE | TextureUsageBit::SAMPLED_FRAGMENT,
+		"SSR");
 	texinit.m_initialUsage = TextureUsageBit::SAMPLED_FRAGMENT;
 	m_rt = m_r->createAndClearRenderTarget(texinit);
 
@@ -79,7 +80,7 @@ void Ssr::populateRenderGraph(RenderingContext& ctx)
 	rpass.setWork([](RenderPassWorkContext& rgraphCtx) { static_cast<Ssr*>(rgraphCtx.m_userData)->run(rgraphCtx); },
 				  this, 0);
 
-	rpass.newDependency({m_runCtx.m_rt, TextureUsageBit::IMAGE_COMPUTE_READ_WRITE});
+	rpass.newDependency({m_runCtx.m_rt, TextureUsageBit::IMAGE_COMPUTE_READ | TextureUsageBit::IMAGE_COMPUTE_WRITE});
 	rpass.newDependency({m_r->getGBuffer().getColorRt(1), TextureUsageBit::SAMPLED_COMPUTE});
 	rpass.newDependency({m_r->getGBuffer().getColorRt(2), TextureUsageBit::SAMPLED_COMPUTE});
 
@@ -126,7 +127,7 @@ void Ssr::run(RenderPassWorkContext& rgraphCtx)
 	rgraphCtx.bindColorTexture(0, 6, m_r->getDownscaleBlur().getRt());
 
 	cmdb->bindSampler(0, 7, m_r->getSamplers().m_trilinearRepeat);
-	cmdb->bindTexture(0, 8, m_noiseTex->getGrTextureView(), TextureUsageBit::SAMPLED_ALL);
+	cmdb->bindTexture(0, 8, m_noiseTex->getGrTextureView(), TextureUsageBit::ALL_SAMPLED);
 
 	// Dispatch
 	dispatchPPCompute(cmdb, m_workgroupSize[0], m_workgroupSize[1], m_r->getWidth() / 2, m_r->getHeight());

src/anki/renderer/VolumetricLightingAccumulation.cpp

@@ -61,8 +61,8 @@ Error VolumetricLightingAccumulation::init(const ConfigSet& config)
 	// Create RTs
 	TextureInitInfo texinit =
 		m_r->create2DRenderTargetInitInfo(m_volumeSize[0], m_volumeSize[1], Format::R16G16B16A16_SFLOAT,
-										  TextureUsageBit::IMAGE_COMPUTE_READ_WRITE | TextureUsageBit::SAMPLED_FRAGMENT
-											  | TextureUsageBit::SAMPLED_COMPUTE,
+										  TextureUsageBit::IMAGE_COMPUTE_READ | TextureUsageBit::IMAGE_COMPUTE_WRITE
+											  | TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::SAMPLED_COMPUTE,
 										  "VolLight");
 	texinit.m_depth = m_volumeSize[2];
 	texinit.m_type = TextureType::_3D;

src/anki/resource/TextureResource.cpp

@@ -68,8 +68,8 @@ Error TextureResource::load(const ResourceFilename& filename, Bool async)
 	ImageLoader& loader = ctx->m_loader;
 
 	TextureInitInfo init("RsrcTex");
-	init.m_usage = TextureUsageBit::SAMPLED_ALL | TextureUsageBit::TRANSFER_DESTINATION;
-	init.m_initialUsage = TextureUsageBit::SAMPLED_ALL;
+	init.m_usage = TextureUsageBit::ALL_SAMPLED | TextureUsageBit::TRANSFER_DESTINATION;
+	init.m_initialUsage = TextureUsageBit::ALL_SAMPLED;
 	U32 faces = 0;
 
 	ResourceFilePtr file;
@@ -276,16 +276,16 @@ Error TextureResource::load(LoadingContext& ctx)
 			if(ctx.m_texType == TextureType::_3D)
 			{
 				TextureVolumeInfo vol(mip);
-				cmdb->setTextureVolumeBarrier(
-					ctx.m_tex, TextureUsageBit::TRANSFER_DESTINATION,
-					TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::SAMPLED_TESSELLATION_EVALUATION, vol);
+				cmdb->setTextureVolumeBarrier(ctx.m_tex, TextureUsageBit::TRANSFER_DESTINATION,
+											  TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::SAMPLED_GEOMETRY,
+											  vol);
 			}
 			else
 			{
 				TextureSurfaceInfo surf(mip, 0, face, layer);
-				cmdb->setTextureSurfaceBarrier(
-					ctx.m_tex, TextureUsageBit::TRANSFER_DESTINATION,
-					TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::SAMPLED_TESSELLATION_EVALUATION, surf);
+				cmdb->setTextureSurfaceBarrier(ctx.m_tex, TextureUsageBit::TRANSFER_DESTINATION,
+											   TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::SAMPLED_GEOMETRY,
+											   surf);
 			}
 		}
 

tests/gr/Gr.cpp

@@ -611,7 +611,7 @@ ANKI_TEST(Gr, ViewportAndScissorOffscreen)
 	TextureInitInfo init;
 	init.m_depth = 1;
 	init.m_format = COL_FORMAT;
-	init.m_usage = TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE;
+	init.m_usage = TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT;
 	init.m_height = RT_HEIGHT;
 	init.m_width = RT_WIDTH;
 	init.m_mipmapCount = 1;
@@ -1131,7 +1131,7 @@ static void drawOffscreen(GrManager& gr, Bool useSecondLevel)
 
 	TextureInitInfo init;
 	init.m_format = COL_FORMAT;
-	init.m_usage = TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE;
+	init.m_usage = TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT;
 	init.m_height = TEX_SIZE;
 	init.m_width = TEX_SIZE;
 	init.m_type = TextureType::_2D;
@@ -1193,11 +1193,11 @@ static void drawOffscreen(GrManager& gr, Bool useSecondLevel)
 									   TextureSurfaceInfo(0, 0, 0, 0));
 		cmdb->setTextureSurfaceBarrier(col1, TextureUsageBit::NONE, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
 									   TextureSurfaceInfo(0, 0, 0, 0));
-		cmdb->setTextureSurfaceBarrier(dp, TextureUsageBit::NONE, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE,
+		cmdb->setTextureSurfaceBarrier(dp, TextureUsageBit::NONE, TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT,
 									   TextureSurfaceInfo(0, 0, 0, 0));
 		cmdb->beginRenderPass(
 			fb, {{TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE}},
-			TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE);
+			TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT);
 
 		if(!useSecondLevel)
 		{
@@ -1223,7 +1223,7 @@ static void drawOffscreen(GrManager& gr, Bool useSecondLevel)
 									   TextureUsageBit::SAMPLED_FRAGMENT, TextureSurfaceInfo(0, 0, 0, 0));
 		cmdb->setTextureSurfaceBarrier(col1, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
 									   TextureUsageBit::SAMPLED_FRAGMENT, TextureSurfaceInfo(0, 0, 0, 0));
-		cmdb->setTextureSurfaceBarrier(dp, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE,
+		cmdb->setTextureSurfaceBarrier(dp, TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT,
 									   TextureUsageBit::SAMPLED_FRAGMENT, TextureSurfaceInfo(0, 0, 0, 0));
 
 		// Draw quad
@@ -1284,7 +1284,8 @@ ANKI_TEST(Gr, ImageLoadStore)
 	TextureInitInfo init;
 	init.m_width = init.m_height = 4;
 	init.m_mipmapCount = 2;
-	init.m_usage = TextureUsageBit::CLEAR | TextureUsageBit::SAMPLED_ALL | TextureUsageBit::IMAGE_COMPUTE_WRITE;
+	init.m_usage =
+		TextureUsageBit::TRANSFER_DESTINATION | TextureUsageBit::ALL_SAMPLED | TextureUsageBit::IMAGE_COMPUTE_WRITE;
 	init.m_type = TextureType::_2D;
 	init.m_format = Format::R8G8B8A8_UNORM;
 
@@ -1308,23 +1309,25 @@ ANKI_TEST(Gr, ImageLoadStore)
 	CommandBufferInitInfo cmdbinit;
 	CommandBufferPtr cmdb = gr->newCommandBuffer(cmdbinit);
 
-	cmdb->setTextureSurfaceBarrier(tex, TextureUsageBit::NONE, TextureUsageBit::CLEAR, TextureSurfaceInfo(0, 0, 0, 0));
+	cmdb->setTextureSurfaceBarrier(tex, TextureUsageBit::NONE, TextureUsageBit::TRANSFER_DESTINATION,
+								   TextureSurfaceInfo(0, 0, 0, 0));
 
 	ClearValue clear;
 	clear.m_colorf = {{0.0, 1.0, 0.0, 1.0}};
 	TextureViewInitInfo viewInit2(tex, TextureSurfaceInfo(0, 0, 0, 0));
 	cmdb->clearTextureView(gr->newTextureView(viewInit2), clear);
 
-	cmdb->setTextureSurfaceBarrier(tex, TextureUsageBit::CLEAR, TextureUsageBit::SAMPLED_FRAGMENT,
+	cmdb->setTextureSurfaceBarrier(tex, TextureUsageBit::TRANSFER_DESTINATION, TextureUsageBit::SAMPLED_FRAGMENT,
 								   TextureSurfaceInfo(0, 0, 0, 0));
 
-	cmdb->setTextureSurfaceBarrier(tex, TextureUsageBit::NONE, TextureUsageBit::CLEAR, TextureSurfaceInfo(1, 0, 0, 0));
+	cmdb->setTextureSurfaceBarrier(tex, TextureUsageBit::NONE, TextureUsageBit::TRANSFER_DESTINATION,
+								   TextureSurfaceInfo(1, 0, 0, 0));
 
 	clear.m_colorf = {{0.0, 0.0, 1.0, 1.0}};
 	TextureViewInitInfo viewInit3(tex, TextureSurfaceInfo(1, 0, 0, 0));
 	cmdb->clearTextureView(gr->newTextureView(viewInit3), clear);
 
-	cmdb->setTextureSurfaceBarrier(tex, TextureUsageBit::CLEAR, TextureUsageBit::IMAGE_COMPUTE_WRITE,
+	cmdb->setTextureSurfaceBarrier(tex, TextureUsageBit::TRANSFER_DESTINATION, TextureUsageBit::IMAGE_COMPUTE_WRITE,
 								   TextureSurfaceInfo(1, 0, 0, 0));
 
 	cmdb->flush();
@@ -1531,7 +1534,7 @@ ANKI_TEST(Gr, RenderGraph)
 	RenderTargetHandle smScratchRt = descr.newRenderTarget(newRTDescr("SM scratch"));
 	{
 		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("SM");
-		pass.newDependency({smScratchRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE});
+		pass.newDependency({smScratchRt, TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT});
 	}
 
 	// SM to exponential SM
@@ -1757,7 +1760,7 @@ void main()
 	texInit.m_width = texInit.m_height = 8;
 	texInit.m_format = Format::R8G8B8_UINT;
 	texInit.m_type = TextureType::_2D;
-	texInit.m_usage = TextureUsageBit::TRANSFER_DESTINATION | TextureUsageBit::SAMPLED_ALL;
+	texInit.m_usage = TextureUsageBit::TRANSFER_DESTINATION | TextureUsageBit::ALL_SAMPLED;
 	texInit.m_mipmapCount = 2;
 	TexturePtr tex = gr->newTexture(texInit);
 	TextureViewPtr texView = gr->newTextureView(TextureViewInitInfo(tex));
@@ -2148,7 +2151,7 @@ ANKI_TEST(Gr, Bindless)
 	texInit.m_width = 1;
 	texInit.m_height = 1;
 	texInit.m_format = Format::R32G32B32A32_UINT;
-	texInit.m_usage = TextureUsageBit::ALL_COMPUTE | TextureUsageBit::TRANSFER_ALL;
+	texInit.m_usage = TextureUsageBit::ALL_COMPUTE | TextureUsageBit::ALL_TRANSFER;
 	texInit.m_mipmapCount = 1;
 
 	TexturePtr texA = gr->newTexture(texInit);