Add ray tracing to buffer usage, rework buffer usage and fix 2 validation errors

src/anki/core/StagingGpuMemoryManager.cpp

@@ -34,13 +34,13 @@ Error StagingGpuMemoryManager::init(GrManager* gr, const ConfigSet& cfg)
 	initBuffer(StagingGpuMemoryType::UNIFORM,
 		gr->getDeviceCapabilities().m_uniformBufferBindOffsetAlignment,
 		gr->getDeviceCapabilities().m_uniformBufferMaxRange,
-		BufferUsageBit::UNIFORM_ALL,
+		BufferUsageBit::ALL_UNIFORM,
 		*gr);
 
 	initBuffer(StagingGpuMemoryType::STORAGE,
 		gr->getDeviceCapabilities().m_storageBufferBindOffsetAlignment,
 		gr->getDeviceCapabilities().m_storageBufferMaxRange,
-		BufferUsageBit::STORAGE_ALL,
+		BufferUsageBit::ALL_STORAGE,
 		*gr);
 
 	initBuffer(StagingGpuMemoryType::VERTEX, 16, MAX_U32, BufferUsageBit::VERTEX | BufferUsageBit::INDEX, *gr);
@@ -48,7 +48,7 @@ Error StagingGpuMemoryManager::init(GrManager* gr, const ConfigSet& cfg)
 	initBuffer(StagingGpuMemoryType::TEXTURE,
 		gr->getDeviceCapabilities().m_textureBufferBindOffsetAlignment,
 		gr->getDeviceCapabilities().m_textureBufferMaxRange,
-		BufferUsageBit::TEXTURE_ALL,
+		BufferUsageBit::ALL_TEXTURE,
 		*gr);
 
 	return Error::NONE;

src/anki/gr/Enums.h

@@ -550,81 +550,76 @@ enum class AttachmentStoreOperation : U8
 };
 
 /// Buffer usage modes.
+/// The graphics work consists of the following pipes: INDIRECT, GEOMETRY (all programmable and fixed function geometry
+/// stages) and finaly FRAGMENT.
+/// The compute from the consists of the following: INDIRECT and COMPUTE.
+/// The trace rays from the: INDIRECT and TRACE_RAYS
 enum class BufferUsageBit : U64
 {
 	NONE = 0,
 
-	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_READ = 1 << 6,
-	STORAGE_VERTEX_WRITE = 1 << 7,
-	STORAGE_VERTEX_READ_WRITE = STORAGE_VERTEX_READ | STORAGE_VERTEX_WRITE,
-	STORAGE_TESSELLATION_EVALUATION_READ = 1 << 8,
-	STORAGE_TESSELLATION_EVALUATION_WRITE = 1 << 9,
-	STORAGE_TESSELLATION_EVALUATION_READ_WRITE =
-		STORAGE_TESSELLATION_EVALUATION_READ | STORAGE_TESSELLATION_EVALUATION_WRITE,
-	STORAGE_TESSELLATION_CONTROL_READ = 1 << 10,
-	STORAGE_TESSELLATION_CONTROL_WRITE = 1 << 11,
-	STORAGE_TESSELLATION_CONTROL_READ_WRITE = STORAGE_TESSELLATION_CONTROL_READ | STORAGE_TESSELLATION_CONTROL_WRITE,
-	STORAGE_GEOMETRY_READ = 1 << 12,
-	STORAGE_GEOMETRY_WRITE = 1 << 13,
-	STORAGE_GEOMETRY_READ_WRITE = STORAGE_GEOMETRY_READ | STORAGE_GEOMETRY_WRITE,
-	STORAGE_FRAGMENT_READ = 1 << 14,
-	STORAGE_FRAGMENT_WRITE = 1 << 15,
-	STORAGE_FRAGMENT_READ_WRITE = STORAGE_FRAGMENT_READ | STORAGE_FRAGMENT_WRITE,
-	STORAGE_COMPUTE_READ = 1 << 16,
-	STORAGE_COMPUTE_WRITE = 1 << 17,
-	STORAGE_COMPUTE_READ_WRITE = STORAGE_COMPUTE_READ | STORAGE_COMPUTE_WRITE,
-	STORAGE_ALL_GRAPHICS = STORAGE_VERTEX_READ_WRITE | STORAGE_TESSELLATION_EVALUATION_READ_WRITE
-						   | STORAGE_TESSELLATION_CONTROL_READ_WRITE | STORAGE_GEOMETRY_READ_WRITE
-						   | STORAGE_FRAGMENT_READ_WRITE,
-	STORAGE_ALL = STORAGE_ALL_GRAPHICS | STORAGE_COMPUTE_READ_WRITE,
-	STORAGE_ALL_READ = STORAGE_VERTEX_READ | STORAGE_TESSELLATION_EVALUATION_READ | STORAGE_TESSELLATION_CONTROL_READ
-					   | STORAGE_GEOMETRY_READ | STORAGE_FRAGMENT_READ | STORAGE_COMPUTE_READ,
-	STORAGE_ALL_WRITE = STORAGE_VERTEX_WRITE | STORAGE_TESSELLATION_EVALUATION_WRITE
-						| STORAGE_TESSELLATION_CONTROL_WRITE | STORAGE_GEOMETRY_WRITE | STORAGE_FRAGMENT_WRITE
-						| STORAGE_COMPUTE_WRITE,
-
-	TEXTURE_VERTEX = 1 << 18,
-	TEXTURE_TESSELLATION_EVALUATION = 1 << 19,
-	TEXTURE_TESSELLATION_CONTROL = 1 << 20,
-	TEXTURE_GEOMETRY = 1 << 21,
-	TEXTURE_FRAGMENT = 1 << 22,
-	TEXTURE_COMPUTE = 1 << 23,
-	TEXTURE_ALL_GRAPHICS = TEXTURE_VERTEX | TEXTURE_TESSELLATION_EVALUATION | TEXTURE_TESSELLATION_CONTROL
-						   | TEXTURE_GEOMETRY | TEXTURE_FRAGMENT,
-	TEXTURE_ALL = TEXTURE_ALL_GRAPHICS | TEXTURE_COMPUTE,
-
-	INDEX = 1 << 24,
-	VERTEX = 1 << 25,
-
-	INDIRECT_COMPUTE = 1 << 26,
-	INDIRECT_GRAPHICS = 1 << 27,
-	INDIRECT_ALL = INDIRECT_COMPUTE | INDIRECT_GRAPHICS,
-
-	FILL = 1 << 28,
-	BUFFER_UPLOAD_SOURCE = 1 << 29,
-	BUFFER_UPLOAD_DESTINATION = 1 << 30, ///< Destination of buffer upload.
-	TEXTURE_UPLOAD_SOURCE = 1ull << 31ull, ///< Source for texture upload.
-	QUERY_RESULT = 1ull << 32ull, ///< Destination to store query results.
-	TRANSFER_ALL_READ = BUFFER_UPLOAD_SOURCE | TEXTURE_UPLOAD_SOURCE,
-	TRANSFER_ALL_WRITE = FILL | BUFFER_UPLOAD_DESTINATION | QUERY_RESULT,
-	TRANSFER_ALL = TRANSFER_ALL_READ | TRANSFER_ALL_WRITE,
+	UNIFORM_GEOMETRY = 1ull << 0ull,
+	UNIFORM_FRAGMENT = 1ull << 1ull,
+	UNIFORM_COMPUTE = 1ull << 2ull,
+	UNIFORM_TRACE_RAYS = 1ull << 3ull,
+
+	STORAGE_GEOMETRY_READ = 1ull << 4ull,
+	STORAGE_GEOMETRY_WRITE = 1ull << 5ull,
+	STORAGE_FRAGMENT_READ = 1ull << 6ull,
+	STORAGE_FRAGMENT_WRITE = 1ull << 7ull,
+	STORAGE_COMPUTE_READ = 1ull << 8ull,
+	STORAGE_COMPUTE_WRITE = 1ull << 9ull,
+	STORAGE_TRACE_RAYS_READ = 1ull << 10ull,
+	STORAGE_TRACE_RAYS_WRITE = 1ull << 11ull,
+
+	TEXTURE_GEOMETRY_READ = 1ull << 12ull,
+	TEXTURE_GEOMETRY_WRITE = 1ull << 13ull,
+	TEXTURE_FRAGMENT_READ = 1ull << 14ull,
+	TEXTURE_FRAGMENT_WRITE = 1ull << 15ull,
+	TEXTURE_COMPUTE_READ = 1ull << 16ull,
+	TEXTURE_COMPUTE_WRITE = 1ull << 17ull,
+	TEXTURE_TRACE_RAYS_READ = 1ull << 18ull,
+	TEXTURE_TRACE_RAYS_WRITE = 1ull << 19ull,
+
+	INDEX = 1ull << 20ull,
+	VERTEX = 1ull << 21ull,
+
+	INDIRECT_COMPUTE = 1ull << 22ll,
+	INDIRECT_DRAW = 1ull << 23ull,
+	INDIRECT_TRACE_RAYS = 1ull << 24ull,
+
+	TRANSFER_SOURCE = 1ull << 25ull,
+	TRANSFER_DESTINATION = 1ull << 26ull,
+
+	ACCELERATION_STRUCTURE_BUILD = 1ull << 27ull,
 
 	// Derived
-	ALL_GRAPHICS =
-		UNIFORM_ALL_GRAPHICS | STORAGE_ALL_GRAPHICS | TEXTURE_ALL_GRAPHICS | INDEX | VERTEX | INDIRECT_GRAPHICS,
-	ALL_COMPUTE = UNIFORM_COMPUTE | STORAGE_COMPUTE_READ_WRITE | TEXTURE_COMPUTE | INDIRECT_COMPUTE,
-	ALL_READ = UNIFORM_ALL | STORAGE_ALL_READ | TEXTURE_ALL | INDEX | VERTEX | INDIRECT_ALL | TRANSFER_ALL_READ,
-	ALL_WRITE = STORAGE_ALL_WRITE | TRANSFER_ALL_WRITE,
+	ALL_UNIFORM = UNIFORM_GEOMETRY | UNIFORM_FRAGMENT | UNIFORM_COMPUTE | UNIFORM_TRACE_RAYS,
+	ALL_STORAGE = STORAGE_GEOMETRY_READ | STORAGE_GEOMETRY_WRITE | STORAGE_FRAGMENT_READ | STORAGE_FRAGMENT_WRITE
+				  | STORAGE_COMPUTE_READ | STORAGE_COMPUTE_WRITE | STORAGE_TRACE_RAYS_READ | STORAGE_TRACE_RAYS_WRITE,
+	ALL_TEXTURE = TEXTURE_GEOMETRY_READ | TEXTURE_GEOMETRY_WRITE | TEXTURE_FRAGMENT_READ | TEXTURE_FRAGMENT_WRITE
+				  | TEXTURE_COMPUTE_READ | TEXTURE_COMPUTE_WRITE | TEXTURE_TRACE_RAYS_READ | TEXTURE_TRACE_RAYS_WRITE,
+	ALL_INDIRECT = INDIRECT_COMPUTE | INDIRECT_DRAW | INDIRECT_TRACE_RAYS,
+	ALL_TRANSFER = TRANSFER_SOURCE | TRANSFER_DESTINATION,
+
+	ALL_GEOMETRY = UNIFORM_GEOMETRY | STORAGE_GEOMETRY_READ | STORAGE_GEOMETRY_WRITE | TEXTURE_GEOMETRY_READ
+				   | TEXTURE_GEOMETRY_WRITE | INDEX | VERTEX,
+	ALL_FRAGMENT = UNIFORM_FRAGMENT | STORAGE_FRAGMENT_READ | STORAGE_FRAGMENT_WRITE | TEXTURE_FRAGMENT_READ
+				   | TEXTURE_FRAGMENT_WRITE,
+	ALL_GRAPHICS = ALL_GEOMETRY | ALL_FRAGMENT | INDIRECT_DRAW,
+	ALL_COMPUTE = UNIFORM_COMPUTE | STORAGE_COMPUTE_READ | STORAGE_COMPUTE_WRITE | TEXTURE_COMPUTE_READ
+				  | TEXTURE_COMPUTE_WRITE | INDIRECT_COMPUTE,
+	ALL_TRACE_RAYS = UNIFORM_TRACE_RAYS | STORAGE_TRACE_RAYS_READ | STORAGE_TRACE_RAYS_WRITE | TEXTURE_TRACE_RAYS_READ
+					 | TEXTURE_TRACE_RAYS_WRITE | INDIRECT_TRACE_RAYS,
+
+	ALL_RAY_TRACING = ALL_TRACE_RAYS | ACCELERATION_STRUCTURE_BUILD,
+	ALL_READ = ALL_UNIFORM | STORAGE_GEOMETRY_READ | STORAGE_FRAGMENT_READ | STORAGE_COMPUTE_READ
+			   | STORAGE_TRACE_RAYS_READ | TEXTURE_GEOMETRY_READ | TEXTURE_FRAGMENT_READ | TEXTURE_COMPUTE_READ
+			   | TEXTURE_TRACE_RAYS_READ | INDEX | VERTEX | INDIRECT_COMPUTE | INDIRECT_DRAW | INDIRECT_TRACE_RAYS
+			   | TRANSFER_SOURCE | ACCELERATION_STRUCTURE_BUILD,
+	ALL_WRITE = STORAGE_GEOMETRY_WRITE | STORAGE_FRAGMENT_WRITE | STORAGE_COMPUTE_WRITE | STORAGE_TRACE_RAYS_WRITE
+				| TEXTURE_GEOMETRY_WRITE | TEXTURE_FRAGMENT_WRITE | TEXTURE_COMPUTE_WRITE | TEXTURE_TRACE_RAYS_WRITE
+				| TRANSFER_DESTINATION,
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(BufferUsageBit, inline)
 

src/anki/gr/RenderGraph.cpp

@@ -1358,39 +1358,34 @@ StringAuto RenderGraph::bufferUsageToStr(StackAllocator<U8>& alloc, BufferUsageB
 			slist.pushBackSprintf("%s", #u); \
 		}
 
-	ANKI_BUFF_USAGE(UNIFORM_VERTEX);
-	ANKI_BUFF_USAGE(UNIFORM_TESSELLATION_EVALUATION);
-	ANKI_BUFF_USAGE(UNIFORM_TESSELLATION_CONTROL);
 	ANKI_BUFF_USAGE(UNIFORM_GEOMETRY);
 	ANKI_BUFF_USAGE(UNIFORM_FRAGMENT);
 	ANKI_BUFF_USAGE(UNIFORM_COMPUTE);
-	ANKI_BUFF_USAGE(STORAGE_VERTEX_READ);
-	ANKI_BUFF_USAGE(STORAGE_VERTEX_WRITE);
-	ANKI_BUFF_USAGE(STORAGE_TESSELLATION_EVALUATION_READ);
-	ANKI_BUFF_USAGE(STORAGE_TESSELLATION_EVALUATION_WRITE);
-	ANKI_BUFF_USAGE(STORAGE_TESSELLATION_CONTROL_READ);
-	ANKI_BUFF_USAGE(STORAGE_TESSELLATION_CONTROL_WRITE);
+	ANKI_BUFF_USAGE(UNIFORM_TRACE_RAYS);
 	ANKI_BUFF_USAGE(STORAGE_GEOMETRY_READ);
 	ANKI_BUFF_USAGE(STORAGE_GEOMETRY_WRITE);
 	ANKI_BUFF_USAGE(STORAGE_FRAGMENT_READ);
 	ANKI_BUFF_USAGE(STORAGE_FRAGMENT_WRITE);
 	ANKI_BUFF_USAGE(STORAGE_COMPUTE_READ);
 	ANKI_BUFF_USAGE(STORAGE_COMPUTE_WRITE);
-	ANKI_BUFF_USAGE(TEXTURE_VERTEX);
-	ANKI_BUFF_USAGE(TEXTURE_TESSELLATION_EVALUATION);
-	ANKI_BUFF_USAGE(TEXTURE_TESSELLATION_CONTROL);
-	ANKI_BUFF_USAGE(TEXTURE_GEOMETRY);
-	ANKI_BUFF_USAGE(TEXTURE_FRAGMENT);
-	ANKI_BUFF_USAGE(TEXTURE_COMPUTE);
+	ANKI_BUFF_USAGE(STORAGE_TRACE_RAYS_READ);
+	ANKI_BUFF_USAGE(STORAGE_TRACE_RAYS_WRITE);
+	ANKI_BUFF_USAGE(TEXTURE_GEOMETRY_READ);
+	ANKI_BUFF_USAGE(TEXTURE_GEOMETRY_WRITE);
+	ANKI_BUFF_USAGE(TEXTURE_FRAGMENT_READ);
+	ANKI_BUFF_USAGE(TEXTURE_FRAGMENT_WRITE);
+	ANKI_BUFF_USAGE(TEXTURE_COMPUTE_READ);
+	ANKI_BUFF_USAGE(TEXTURE_COMPUTE_WRITE);
+	ANKI_BUFF_USAGE(TEXTURE_TRACE_RAYS_READ);
+	ANKI_BUFF_USAGE(TEXTURE_TRACE_RAYS_WRITE);
 	ANKI_BUFF_USAGE(INDEX);
 	ANKI_BUFF_USAGE(VERTEX);
 	ANKI_BUFF_USAGE(INDIRECT_COMPUTE);
-	ANKI_BUFF_USAGE(INDIRECT_GRAPHICS);
-	ANKI_BUFF_USAGE(FILL);
-	ANKI_BUFF_USAGE(BUFFER_UPLOAD_SOURCE);
-	ANKI_BUFF_USAGE(BUFFER_UPLOAD_DESTINATION);
-	ANKI_BUFF_USAGE(TEXTURE_UPLOAD_SOURCE);
-	ANKI_BUFF_USAGE(QUERY_RESULT);
+	ANKI_BUFF_USAGE(INDIRECT_DRAW);
+	ANKI_BUFF_USAGE(INDIRECT_TRACE_RAYS);
+	ANKI_BUFF_USAGE(TRANSFER_SOURCE);
+	ANKI_BUFF_USAGE(TRANSFER_DESTINATION);
+	ANKI_BUFF_USAGE(ACCELERATION_STRUCTURE_BUILD);
 
 	if(!usage)
 	{

src/anki/gr/vulkan/BufferImpl.cpp

@@ -65,7 +65,7 @@ Error BufferImpl::init(const BufferInitInfo& inf)
 
 		VkMemoryPropertyFlags preferDeviceLocal;
 		VkMemoryPropertyFlags avoidDeviceLocal;
-		if((usage & (~BufferUsageBit::TRANSFER_ALL)) != BufferUsageBit::NONE)
+		if((usage & (~BufferUsageBit::ALL_TRANSFER)) != BufferUsageBit::NONE)
 		{
 			// Will be used for something other than transfer, try to put it in the device
 			preferDeviceLocal = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
@@ -208,57 +208,43 @@ VkPipelineStageFlags BufferImpl::computePplineStage(BufferUsageBit usage)
 {
 	VkPipelineStageFlags stageMask = 0;
 
-	if(!!(usage & (BufferUsageBit::UNIFORM_VERTEX | BufferUsageBit::STORAGE_VERTEX_READ_WRITE)))
+	if(!!(usage & BufferUsageBit::ALL_INDIRECT))
 	{
-		stageMask |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
-	}
-
-	if(!!(usage
-		   & (BufferUsageBit::UNIFORM_TESSELLATION_EVALUATION
-				 | BufferUsageBit::STORAGE_TESSELLATION_EVALUATION_READ_WRITE)))
-	{
-		stageMask |= VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT;
+		stageMask |= VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT;
 	}
 
-	if(!!(usage
-		   & (BufferUsageBit::UNIFORM_TESSELLATION_CONTROL | BufferUsageBit::STORAGE_TESSELLATION_CONTROL_READ_WRITE)))
+	if(!!(usage & (BufferUsageBit::INDEX | BufferUsageBit::VERTEX)))
 	{
-		stageMask |= VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT;
+		stageMask |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
 	}
 
-	if(!!(usage & (BufferUsageBit::UNIFORM_GEOMETRY | BufferUsageBit::STORAGE_GEOMETRY_READ_WRITE)))
+	if(!!(usage & BufferUsageBit::ALL_GEOMETRY))
 	{
-		stageMask |= VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
+		stageMask |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT
+					 | VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT | VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
 	}
 
-	if(!!(usage & (BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::STORAGE_FRAGMENT_READ_WRITE)))
+	if(!!(usage & BufferUsageBit::ALL_FRAGMENT))
 	{
 		stageMask |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
 	}
 
-	if(!!(usage & (BufferUsageBit::UNIFORM_COMPUTE | BufferUsageBit::STORAGE_COMPUTE_READ_WRITE)))
+	if(!!(usage & (BufferUsageBit::ALL_COMPUTE & ~BufferUsageBit::INDIRECT_COMPUTE)))
 	{
 		stageMask |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
 	}
 
-	if(!!(usage & (BufferUsageBit::INDEX | BufferUsageBit::VERTEX)))
-	{
-		stageMask |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT | VK_PIPELINE_STAGE_VERTEX_SHADER_BIT
-					 | VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT
-					 | VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT | VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
-	}
-
-	if(!!(usage & BufferUsageBit::INDIRECT_ALL))
+	if(!!(usage & BufferUsageBit::ACCELERATION_STRUCTURE_BUILD))
 	{
-		stageMask |= VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT;
+		stageMask |= VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR;
 	}
 
-	if(!!(usage & (BufferUsageBit::TRANSFER_ALL)))
+	if(!!(usage & (BufferUsageBit::ALL_TRACE_RAYS & ~BufferUsageBit::INDIRECT_TRACE_RAYS)))
 	{
-		stageMask |= VK_PIPELINE_STAGE_TRANSFER_BIT;
+		stageMask |= VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
 	}
 
-	if(!!(usage & (BufferUsageBit::QUERY_RESULT)))
+	if(!!(usage & BufferUsageBit::ALL_TRANSFER))
 	{
 		stageMask |= VK_PIPELINE_STAGE_TRANSFER_BIT;
 	}
@@ -276,17 +262,19 @@ VkAccessFlags BufferImpl::computeAccessMask(BufferUsageBit usage)
 {
 	VkAccessFlags mask = 0;
 
-	const BufferUsageBit SHADER_READ =
-		BufferUsageBit::STORAGE_VERTEX_READ | BufferUsageBit::STORAGE_TESSELLATION_CONTROL_READ
-		| BufferUsageBit::STORAGE_TESSELLATION_EVALUATION_READ | BufferUsageBit::STORAGE_GEOMETRY_READ
-		| BufferUsageBit::STORAGE_FRAGMENT_READ | BufferUsageBit::STORAGE_COMPUTE_READ;
+	constexpr BufferUsageBit SHADER_READ =
+		BufferUsageBit::STORAGE_GEOMETRY_READ | BufferUsageBit::STORAGE_FRAGMENT_READ
+		| BufferUsageBit::STORAGE_COMPUTE_READ | BufferUsageBit::STORAGE_TRACE_RAYS_READ
+		| BufferUsageBit::TEXTURE_GEOMETRY_READ | BufferUsageBit::TEXTURE_FRAGMENT_READ
+		| BufferUsageBit::TEXTURE_COMPUTE_READ | BufferUsageBit::TEXTURE_TRACE_RAYS_READ;
 
-	const BufferUsageBit SHADER_WRITE =
-		BufferUsageBit::STORAGE_VERTEX_WRITE | BufferUsageBit::STORAGE_TESSELLATION_CONTROL_WRITE
-		| BufferUsageBit::STORAGE_TESSELLATION_EVALUATION_WRITE | BufferUsageBit::STORAGE_GEOMETRY_WRITE
-		| BufferUsageBit::STORAGE_FRAGMENT_WRITE | BufferUsageBit::STORAGE_COMPUTE_WRITE;
+	constexpr BufferUsageBit SHADER_WRITE =
+		BufferUsageBit::STORAGE_GEOMETRY_WRITE | BufferUsageBit::STORAGE_FRAGMENT_WRITE
+		| BufferUsageBit::STORAGE_COMPUTE_WRITE | BufferUsageBit::STORAGE_TRACE_RAYS_WRITE
+		| BufferUsageBit::TEXTURE_GEOMETRY_WRITE | BufferUsageBit::TEXTURE_FRAGMENT_WRITE
+		| BufferUsageBit::TEXTURE_COMPUTE_WRITE | BufferUsageBit::TEXTURE_TRACE_RAYS_WRITE;
 
-	if(!!(usage & BufferUsageBit::UNIFORM_ALL))
+	if(!!(usage & BufferUsageBit::ALL_UNIFORM))
 	{
 		mask |= VK_ACCESS_UNIFORM_READ_BIT;
 	}
@@ -311,24 +299,24 @@ VkAccessFlags BufferImpl::computeAccessMask(BufferUsageBit usage)
 		mask |= VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
 	}
 
-	if(!!(usage & BufferUsageBit::INDIRECT_ALL))
+	if(!!(usage & BufferUsageBit::ALL_INDIRECT))
 	{
 		mask |= VK_ACCESS_INDIRECT_COMMAND_READ_BIT;
 	}
 
-	if(!!(usage & (BufferUsageBit::FILL | BufferUsageBit::BUFFER_UPLOAD_DESTINATION)))
+	if(!!(usage & BufferUsageBit::TRANSFER_DESTINATION))
 	{
 		mask |= VK_ACCESS_TRANSFER_WRITE_BIT;
 	}
 
-	if(!!(usage & (BufferUsageBit::BUFFER_UPLOAD_SOURCE | BufferUsageBit::TEXTURE_UPLOAD_SOURCE)))
+	if(!!(usage & BufferUsageBit::TRANSFER_SOURCE))
 	{
 		mask |= VK_ACCESS_TRANSFER_READ_BIT;
 	}
 
-	if(!!(usage & BufferUsageBit::QUERY_RESULT))
+	if(!!(usage & BufferUsageBit::ACCELERATION_STRUCTURE_BUILD))
 	{
-		mask |= VK_ACCESS_TRANSFER_WRITE_BIT;
+		mask |= VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR;
 	}
 
 	return mask;

src/anki/gr/vulkan/CommandBufferImpl.cpp

@@ -676,7 +676,7 @@ void CommandBufferImpl::copyBufferToTextureViewInternal(
 		const PtrSize shadowSize = (is3D) ? computeVolumeSize(width, height, depth, Format::R8G8B8A8_UNORM)
 										  : computeSurfaceSize(width, height, Format::R8G8B8A8_UNORM);
 		BufferPtr shadow = getManager().newBuffer(
-			BufferInitInfo(shadowSize, BufferUsageBit::TRANSFER_ALL, BufferMapAccessBit::NONE, "Workaround"));
+			BufferInitInfo(shadowSize, BufferUsageBit::ALL_TRANSFER, BufferMapAccessBit::NONE, "Workaround"));
 		const VkBuffer shadowHandle = static_cast<const BufferImpl&>(*shadow).getHandle();
 		m_microCmdb->pushObjectRef(shadow);
 

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

@@ -314,7 +314,7 @@ inline void CommandBufferImpl::drawArraysIndirect(
 	m_state.setPrimitiveTopology(topology);
 	drawcallCommon();
 	const BufferImpl& impl = static_cast<const BufferImpl&>(*buff);
-	ANKI_ASSERT(impl.usageValid(BufferUsageBit::INDIRECT_GRAPHICS));
+	ANKI_ASSERT(impl.usageValid(BufferUsageBit::INDIRECT_DRAW));
 	ANKI_ASSERT((offset % 4) == 0);
 	ANKI_ASSERT((offset + sizeof(DrawArraysIndirectInfo) * drawCount) <= impl.getSize());
 
@@ -328,7 +328,7 @@ inline void CommandBufferImpl::drawElementsIndirect(
 	m_state.setPrimitiveTopology(topology);
 	drawcallCommon();
 	const BufferImpl& impl = static_cast<const BufferImpl&>(*buff);
-	ANKI_ASSERT(impl.usageValid(BufferUsageBit::INDIRECT_ALL));
+	ANKI_ASSERT(impl.usageValid(BufferUsageBit::INDIRECT_DRAW));
 	ANKI_ASSERT((offset % 4) == 0);
 	ANKI_ASSERT((offset + sizeof(DrawElementsIndirectInfo) * drawCount) <= impl.getSize());
 
@@ -706,7 +706,7 @@ inline void CommandBufferImpl::fillBuffer(BufferPtr buff, PtrSize offset, PtrSiz
 	commandCommon();
 	ANKI_ASSERT(!insideRenderPass());
 	const BufferImpl& impl = static_cast<const BufferImpl&>(*buff);
-	ANKI_ASSERT(impl.usageValid(BufferUsageBit::FILL));
+	ANKI_ASSERT(impl.usageValid(BufferUsageBit::TRANSFER_DESTINATION));
 
 	ANKI_ASSERT(offset < impl.getSize());
 	ANKI_ASSERT((offset % 4) == 0 && "Should be multiple of 4");
@@ -728,7 +728,7 @@ inline void CommandBufferImpl::writeOcclusionQueryResultToBuffer(
 	ANKI_ASSERT(!insideRenderPass());
 
 	const BufferImpl& impl = static_cast<const BufferImpl&>(*buff);
-	ANKI_ASSERT(impl.usageValid(BufferUsageBit::QUERY_RESULT));
+	ANKI_ASSERT(impl.usageValid(BufferUsageBit::TRANSFER_DESTINATION));
 	ANKI_ASSERT((offset % 4) == 0);
 	ANKI_ASSERT((offset + sizeof(U32)) <= impl.getSize());
 
@@ -806,6 +806,11 @@ inline void CommandBufferImpl::bindShaderProgram(ShaderProgramPtr& prog)
 inline void CommandBufferImpl::copyBufferToBuffer(
 	BufferPtr& src, PtrSize srcOffset, BufferPtr& dst, PtrSize dstOffset, PtrSize range)
 {
+	ANKI_ASSERT(static_cast<const BufferImpl&>(*src).usageValid(BufferUsageBit::TRANSFER_SOURCE));
+	ANKI_ASSERT(static_cast<const BufferImpl&>(*dst).usageValid(BufferUsageBit::TRANSFER_DESTINATION));
+	ANKI_ASSERT(srcOffset + range <= src->getSize());
+	ANKI_ASSERT(dstOffset + range <= dst->getSize());
+
 	commandCommon();
 
 	VkBufferCopy region = {};

src/anki/gr/vulkan/Common.cpp

@@ -261,12 +261,12 @@ VkBufferUsageFlags convertBufferUsageBit(BufferUsageBit usageMask)
 {
 	VkBufferUsageFlags out = 0;
 
-	if(!!(usageMask & BufferUsageBit::UNIFORM_ALL))
+	if(!!(usageMask & BufferUsageBit::ALL_UNIFORM))
 	{
 		out |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
 	}
 
-	if(!!(usageMask & BufferUsageBit::STORAGE_ALL))
+	if(!!(usageMask & BufferUsageBit::ALL_STORAGE))
 	{
 		out |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
 	}
@@ -281,27 +281,36 @@ VkBufferUsageFlags convertBufferUsageBit(BufferUsageBit usageMask)
 		out |= VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
 	}
 
-	if(!!(usageMask & BufferUsageBit::INDIRECT_ALL))
+	if(!!(usageMask & BufferUsageBit::ALL_INDIRECT))
 	{
 		out |= VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
 	}
 
-	if(!!(usageMask
-		   & (BufferUsageBit::BUFFER_UPLOAD_DESTINATION | BufferUsageBit::FILL | BufferUsageBit::QUERY_RESULT)))
+	if(!!(usageMask & BufferUsageBit::TRANSFER_DESTINATION))
 	{
 		out |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
 	}
 
-	if(!!(usageMask & (BufferUsageBit::BUFFER_UPLOAD_SOURCE | BufferUsageBit::TEXTURE_UPLOAD_SOURCE)))
+	if(!!(usageMask & BufferUsageBit::TRANSFER_SOURCE))
 	{
 		out |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
 	}
 
-	if(!!(usageMask & BufferUsageBit::TEXTURE_ALL))
+	if(!!(usageMask & BufferUsageBit::ALL_TEXTURE) && !(usageMask & BufferUsageBit::ALL_WRITE))
 	{
 		out |= VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT;
 	}
 
+	if(!!(usageMask & BufferUsageBit::ALL_TEXTURE) && !(usageMask & BufferUsageBit::ALL_READ))
+	{
+		out |= VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT;
+	}
+
+	if(!!(usageMask & (BufferUsageBit::ALL_RAY_TRACING & ~BufferUsageBit::INDIRECT_TRACE_RAYS)))
+	{
+		out |= VK_BUFFER_USAGE_RAY_TRACING_BIT_KHR;
+	}
+
 	ANKI_ASSERT(out);
 
 	return out;

src/anki/gr/vulkan/DescriptorSet.cpp

@@ -872,7 +872,7 @@ void DescriptorSetState::flush(U64& hash,
 						break;
 					case DescriptorType::TEXTURE:
 						ANKI_ASSERT(anyBinding.m_type == DescriptorType::TEXTURE && "Have bound the wrong type");
-						toHash[toHashCount] = U64(anyBinding.m_tex.m_layout);
+						toHash[toHashCount++] = U64(anyBinding.m_tex.m_layout);
 						break;
 					case DescriptorType::SAMPLER:
 						ANKI_ASSERT(anyBinding.m_type == DescriptorType::SAMPLER && "Have bound the wrong type");

src/anki/renderer/Dbg.cpp

@@ -46,6 +46,7 @@ Error Dbg::lazyInit()
 	m_fbDescr.m_colorAttachmentCount = 1;
 	m_fbDescr.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::CLEAR;
 	m_fbDescr.m_depthStencilAttachment.m_loadOperation = AttachmentLoadOperation::LOAD;
+	m_fbDescr.m_depthStencilAttachment.m_stencilLoadOperation = AttachmentLoadOperation::DONT_CARE;
 	m_fbDescr.m_depthStencilAttachment.m_aspect = DepthStencilAspectBit::DEPTH;
 	m_fbDescr.bake();
 

src/anki/renderer/ForwardShading.cpp

@@ -82,7 +82,7 @@ void ForwardShading::setDependencies(const RenderingContext& ctx, GraphicsRender
 
 	if(ctx.m_renderQueue->m_lensFlares.getSize())
 	{
-		pass.newDependency({m_r->getLensFlare().getIndirectDrawBuffer(), BufferUsageBit::INDIRECT_GRAPHICS});
+		pass.newDependency({m_r->getLensFlare().getIndirectDrawBuffer(), BufferUsageBit::INDIRECT_DRAW});
 	}
 }
 

src/anki/renderer/LensFlare.cpp

@@ -66,7 +66,7 @@ Error LensFlare::initOcclusion(const ConfigSet& config)
 	GrManager& gr = getGrManager();
 
 	m_indirectBuff = gr.newBuffer(BufferInitInfo(m_maxFlares * sizeof(DrawArraysIndirectInfo),
-		BufferUsageBit::INDIRECT_GRAPHICS | BufferUsageBit::STORAGE_COMPUTE_WRITE,
+		BufferUsageBit::INDIRECT_DRAW | BufferUsageBit::STORAGE_COMPUTE_WRITE,
 		BufferMapAccessBit::NONE,
 		"LensFlares"));
 

src/anki/renderer/ProbeReflections.cpp

@@ -164,7 +164,7 @@ Error ProbeReflections::initIrradiance(const ConfigSet& config)
 	// Create buff
 	{
 		BufferInitInfo init;
-		init.m_usage = BufferUsageBit::STORAGE_ALL;
+		init.m_usage = BufferUsageBit::ALL_STORAGE;
 		init.m_size = 6 * sizeof(Vec4);
 		m_irradiance.m_diceValuesBuff = getGrManager().newBuffer(init);
 	}

src/anki/renderer/Renderer.cpp

@@ -126,7 +126,7 @@ Error Renderer::initInternal(const ConfigSet& config)
 	}
 
 	m_dummyBuff = getGrManager().newBuffer(BufferInitInfo(
-		1024, BufferUsageBit::UNIFORM_ALL | BufferUsageBit::STORAGE_ALL, BufferMapAccessBit::NONE, "Dummy"));
+		1024, BufferUsageBit::ALL_UNIFORM | BufferUsageBit::ALL_STORAGE, BufferMapAccessBit::NONE, "Dummy"));
 
 	ANKI_CHECK(m_resources->loadResource("shaders/ClearTextureCompute.ankiprog", m_clearTexComputeProg));
 

src/anki/renderer/Ssgi.cpp

@@ -156,6 +156,7 @@ void Ssgi::populateRenderGraph(RenderingContext& ctx)
 
 		rpass.newDependency({m_runCtx.m_intermediateRts[WRITE], TextureUsageBit::SAMPLED_COMPUTE});
 		rpass.newDependency({m_runCtx.m_intermediateRts[READ], TextureUsageBit::IMAGE_COMPUTE_WRITE});
+		rpass.newDependency({m_r->getGBuffer().getColorRt(2), TextureUsageBit::SAMPLED_COMPUTE});
 		rpass.newDependency({m_r->getGBuffer().getDepthRt(), TextureUsageBit::SAMPLED_COMPUTE});
 
 		rpass.setWork(
@@ -170,8 +171,8 @@ void Ssgi::populateRenderGraph(RenderingContext& ctx)
 
 		rpass.newDependency({m_runCtx.m_intermediateRts[READ], TextureUsageBit::SAMPLED_COMPUTE});
 		rpass.newDependency({m_runCtx.m_intermediateRts[WRITE], TextureUsageBit::IMAGE_COMPUTE_WRITE});
-		rpass.newDependency({m_r->getGBuffer().getDepthRt(), TextureUsageBit::SAMPLED_COMPUTE});
 		rpass.newDependency({m_r->getGBuffer().getColorRt(2), TextureUsageBit::SAMPLED_COMPUTE});
+		rpass.newDependency({m_r->getGBuffer().getDepthRt(), TextureUsageBit::SAMPLED_COMPUTE});
 
 		rpass.setWork(
 			[](RenderPassWorkContext& rgraphCtx) { static_cast<Ssgi*>(rgraphCtx.m_userData)->runHBlur(rgraphCtx); },

src/anki/renderer/Tonemapping.cpp

@@ -40,7 +40,7 @@ Error Tonemapping::initInternal(const ConfigSet& initializer)
 
 	// Create buffer
 	m_luminanceBuff = getGrManager().newBuffer(BufferInitInfo(sizeof(Vec4),
-		BufferUsageBit::STORAGE_ALL | BufferUsageBit::UNIFORM_ALL | BufferUsageBit::BUFFER_UPLOAD_DESTINATION,
+		BufferUsageBit::ALL_STORAGE | BufferUsageBit::ALL_UNIFORM | BufferUsageBit::TRANSFER_DESTINATION,
 		BufferMapAccessBit::NONE,
 		"AvgLum"));
 
@@ -67,8 +67,8 @@ void Tonemapping::importRenderTargets(RenderingContext& ctx)
 {
 	// Computation of the AVG luminance will run first in the frame and it will use the m_luminanceBuff as storage
 	// read/write. To skip the barrier import it as read/write as well.
-	m_runCtx.m_buffHandle =
-		ctx.m_renderGraphDescr.importBuffer(m_luminanceBuff, BufferUsageBit::STORAGE_COMPUTE_READ_WRITE);
+	m_runCtx.m_buffHandle = ctx.m_renderGraphDescr.importBuffer(
+		m_luminanceBuff, BufferUsageBit::STORAGE_COMPUTE_READ | BufferUsageBit::STORAGE_COMPUTE_WRITE);
 }
 
 void Tonemapping::populateRenderGraph(RenderingContext& ctx)
@@ -86,7 +86,8 @@ void Tonemapping::populateRenderGraph(RenderingContext& ctx)
 		this,
 		0);
 
-	pass.newDependency({m_runCtx.m_buffHandle, BufferUsageBit::STORAGE_COMPUTE_READ_WRITE});
+	pass.newDependency(
+		{m_runCtx.m_buffHandle, BufferUsageBit::STORAGE_COMPUTE_READ | BufferUsageBit::STORAGE_COMPUTE_WRITE});
 
 	TextureSubresourceInfo inputTexSubresource;
 	inputTexSubresource.m_firstMipmap = m_inputTexMip;

src/anki/resource/MeshResource.cpp

@@ -102,7 +102,7 @@ Error MeshResource::load(const ResourceFilename& filename, Bool async)
 	const PtrSize indexBuffSize = m_indexCount * ((m_indexType == IndexType::U32) ? 4 : 2);
 
 	m_indexBuff = getManager().getGrManager().newBuffer(BufferInitInfo(indexBuffSize,
-		BufferUsageBit::INDEX | BufferUsageBit::BUFFER_UPLOAD_DESTINATION | BufferUsageBit::FILL,
+		BufferUsageBit::INDEX | BufferUsageBit::TRANSFER_DESTINATION,
 		BufferMapAccessBit::NONE,
 		"MeshIdx"));
 
@@ -122,7 +122,7 @@ Error MeshResource::load(const ResourceFilename& filename, Bool async)
 	}
 
 	m_vertBuff = getManager().getGrManager().newBuffer(BufferInitInfo(totalVertexBuffSize,
-		BufferUsageBit::VERTEX | BufferUsageBit::BUFFER_UPLOAD_DESTINATION | BufferUsageBit::FILL,
+		BufferUsageBit::VERTEX | BufferUsageBit::TRANSFER_DESTINATION,
 		BufferMapAccessBit::NONE,
 		"MeshVert"));
 
@@ -156,8 +156,8 @@ Error MeshResource::load(const ResourceFilename& filename, Bool async)
 	cmdb->fillBuffer(m_vertBuff, 0, MAX_PTR_SIZE, 0);
 	cmdb->fillBuffer(m_indexBuff, 0, MAX_PTR_SIZE, 0);
 
-	cmdb->setBufferBarrier(m_vertBuff, BufferUsageBit::FILL, BufferUsageBit::VERTEX, 0, MAX_PTR_SIZE);
-	cmdb->setBufferBarrier(m_indexBuff, BufferUsageBit::FILL, BufferUsageBit::INDEX, 0, MAX_PTR_SIZE);
+	cmdb->setBufferBarrier(m_vertBuff, BufferUsageBit::TRANSFER_DESTINATION, BufferUsageBit::VERTEX, 0, MAX_PTR_SIZE);
+	cmdb->setBufferBarrier(m_indexBuff, BufferUsageBit::TRANSFER_DESTINATION, BufferUsageBit::INDEX, 0, MAX_PTR_SIZE);
 
 	cmdb->flush();
 
@@ -185,10 +185,8 @@ Error MeshResource::loadAsync(MeshLoader& loader) const
 	CommandBufferPtr cmdb = gr.newCommandBuffer(cmdbinit);
 
 	// Set barriers
-	cmdb->setBufferBarrier(
-		m_vertBuff, BufferUsageBit::VERTEX, BufferUsageBit::BUFFER_UPLOAD_DESTINATION, 0, MAX_PTR_SIZE);
-	cmdb->setBufferBarrier(
-		m_indexBuff, BufferUsageBit::INDEX, BufferUsageBit::BUFFER_UPLOAD_DESTINATION, 0, MAX_PTR_SIZE);
+	cmdb->setBufferBarrier(m_vertBuff, BufferUsageBit::VERTEX, BufferUsageBit::TRANSFER_DESTINATION, 0, MAX_PTR_SIZE);
+	cmdb->setBufferBarrier(m_indexBuff, BufferUsageBit::INDEX, BufferUsageBit::TRANSFER_DESTINATION, 0, MAX_PTR_SIZE);
 
 	// Write index buffer
 	{
@@ -224,10 +222,8 @@ Error MeshResource::loadAsync(MeshLoader& loader) const
 	}
 
 	// Set barriers
-	cmdb->setBufferBarrier(
-		m_vertBuff, BufferUsageBit::BUFFER_UPLOAD_DESTINATION, BufferUsageBit::VERTEX, 0, MAX_PTR_SIZE);
-	cmdb->setBufferBarrier(
-		m_indexBuff, BufferUsageBit::BUFFER_UPLOAD_DESTINATION, BufferUsageBit::INDEX, 0, MAX_PTR_SIZE);
+	cmdb->setBufferBarrier(m_vertBuff, BufferUsageBit::TRANSFER_DESTINATION, BufferUsageBit::VERTEX, 0, MAX_PTR_SIZE);
+	cmdb->setBufferBarrier(m_indexBuff, BufferUsageBit::TRANSFER_DESTINATION, BufferUsageBit::INDEX, 0, MAX_PTR_SIZE);
 
 	// Finalize
 	FencePtr fence;

src/anki/resource/TransferGpuAllocator.cpp

@@ -35,7 +35,7 @@ public:
 		TransferGpuAllocator::Memory* mm = m_alloc.newInstance<TransferGpuAllocator::Memory>();
 
 		mm->m_buffer = m_gr->newBuffer(
-			BufferInitInfo(size, BufferUsageBit::BUFFER_UPLOAD_SOURCE, BufferMapAccessBit::WRITE, "Transfer"));
+			BufferInitInfo(size, BufferUsageBit::TRANSFER_SOURCE, BufferMapAccessBit::WRITE, "Transfer"));
 		mm->m_mappedMemory = mm->m_buffer->map(0, size, BufferMapAccessBit::WRITE);
 
 		mem = mm;

src/anki/scene/GpuParticleEmitterNode.cpp

@@ -87,7 +87,7 @@ Error GpuParticleEmitterNode::init(const CString& filename)
 
 	// Create the particle buffer
 	buffInit.m_access = BufferMapAccessBit::WRITE;
-	buffInit.m_usage = BufferUsageBit::STORAGE_ALL;
+	buffInit.m_usage = BufferUsageBit::ALL_STORAGE;
 	buffInit.m_size = sizeof(GpuParticle) * inProps.m_maxNumOfParticles;
 	m_particlesBuff = getSceneGraph().getGrManager().newBuffer(buffInit);
 

src/anki/ui/Font.cpp

@@ -73,7 +73,7 @@ void Font::createTexture(const void* data, U32 width, U32 height)
 	// Create and populate the buffer
 	PtrSize buffSize = width * height * 4;
 	BufferPtr buff = m_manager->getGrManager().newBuffer(
-		BufferInitInfo(buffSize, BufferUsageBit::BUFFER_UPLOAD_SOURCE, BufferMapAccessBit::WRITE, "UI"));
+		BufferInitInfo(buffSize, BufferUsageBit::TRANSFER_SOURCE, BufferMapAccessBit::WRITE, "UI"));
 	void* mapped = buff->map(0, buffSize, BufferMapAccessBit::WRITE);
 	memcpy(mapped, data, buffSize);
 	buff->unmap();

tests/gr/Gr.cpp

@@ -738,10 +738,10 @@ ANKI_TEST(Gr, Buffer)
 {
 	COMMON_BEGIN()
 
-	BufferPtr a = gr->newBuffer(BufferInitInfo(512, BufferUsageBit::UNIFORM_ALL, BufferMapAccessBit::NONE));
+	BufferPtr a = gr->newBuffer(BufferInitInfo(512, BufferUsageBit::ALL_UNIFORM, BufferMapAccessBit::NONE));
 
 	BufferPtr b = gr->newBuffer(
-		BufferInitInfo(64, BufferUsageBit::STORAGE_ALL, BufferMapAccessBit::WRITE | BufferMapAccessBit::READ));
+		BufferInitInfo(64, BufferUsageBit::ALL_STORAGE, BufferMapAccessBit::WRITE | BufferMapAccessBit::READ));
 
 	void* ptr = b->map(0, 64, BufferMapAccessBit::WRITE);
 	ANKI_TEST_EXPECT_NEQ(ptr, nullptr);
@@ -764,7 +764,7 @@ ANKI_TEST(Gr, DrawWithUniforms)
 
 	// A non-uploaded buffer
 	BufferPtr b =
-		gr->newBuffer(BufferInitInfo(sizeof(Vec4) * 3, BufferUsageBit::UNIFORM_ALL, BufferMapAccessBit::WRITE));
+		gr->newBuffer(BufferInitInfo(sizeof(Vec4) * 3, BufferUsageBit::ALL_UNIFORM, BufferMapAccessBit::WRITE));
 
 	Vec4* ptr = static_cast<Vec4*>(b->map(0, sizeof(Vec4) * 3, BufferMapAccessBit::WRITE));
 	ANKI_TEST_EXPECT_NEQ(ptr, nullptr);
@@ -1874,7 +1874,7 @@ void main()
 
 	// Create the buffer to copy to the texture
 	BufferPtr uploadBuff = gr->newBuffer(BufferInitInfo(
-		texInit.m_width * texInit.m_height * 3, BufferUsageBit::TRANSFER_ALL, BufferMapAccessBit::WRITE));
+		texInit.m_width * texInit.m_height * 3, BufferUsageBit::ALL_TRANSFER, BufferMapAccessBit::WRITE));
 	U8* data = static_cast<U8*>(uploadBuff->map(0, uploadBuff->getSize(), BufferMapAccessBit::WRITE));
 	for(U32 i = 0; i < texInit.m_width * texInit.m_height; ++i)
 	{
@@ -1886,7 +1886,7 @@ void main()
 	uploadBuff->unmap();
 
 	BufferPtr uploadBuff2 = gr->newBuffer(BufferInitInfo(
-		(texInit.m_width >> 1) * (texInit.m_height >> 1) * 3, BufferUsageBit::TRANSFER_ALL, BufferMapAccessBit::WRITE));
+		(texInit.m_width >> 1) * (texInit.m_height >> 1) * 3, BufferUsageBit::ALL_TRANSFER, BufferMapAccessBit::WRITE));
 	data = static_cast<U8*>(uploadBuff2->map(0, uploadBuff2->getSize(), BufferMapAccessBit::WRITE));
 	for(U i = 0; i < (texInit.m_width >> 1) * (texInit.m_height >> 1); ++i)
 	{
@@ -2132,8 +2132,8 @@ void main()
 	ShaderProgramPtr prog = createProgram(VERT_SRC, FRAG_SRC, *gr);
 
 	// Create the result buffer
-	BufferPtr resultBuff = gr->newBuffer(
-		BufferInitInfo(sizeof(UVec4), BufferUsageBit::STORAGE_ALL | BufferUsageBit::FILL, BufferMapAccessBit::READ));
+	BufferPtr resultBuff = gr->newBuffer(BufferInitInfo(
+		sizeof(UVec4), BufferUsageBit::ALL_STORAGE | BufferUsageBit::TRANSFER_DESTINATION, BufferMapAccessBit::READ));
 
 	// Draw
 	CommandBufferInitInfo cinit;
@@ -2141,8 +2141,11 @@ void main()
 	CommandBufferPtr cmdb = gr->newCommandBuffer(cinit);
 
 	cmdb->fillBuffer(resultBuff, 0, resultBuff->getSize(), 0);
-	cmdb->setBufferBarrier(
-		resultBuff, BufferUsageBit::FILL, BufferUsageBit::STORAGE_FRAGMENT_WRITE, 0, resultBuff->getSize());
+	cmdb->setBufferBarrier(resultBuff,
+		BufferUsageBit::TRANSFER_DESTINATION,
+		BufferUsageBit::STORAGE_FRAGMENT_WRITE,
+		0,
+		resultBuff->getSize());
 
 	cmdb->setViewport(0, 0, WIDTH, HEIGHT);
 	cmdb->bindShaderProgram(prog);