Rename and refactor the BufferUsageBit and TextureUsageBit

AnKi/Core/GpuMemory/GpuReadbackMemoryPool.cpp

@@ -12,7 +12,7 @@ GpuReadbackMemoryPool::GpuReadbackMemoryPool()
 {
 	const Array classes = {64_B, 256_B, 1_MB, 5_MB};
 
-	const BufferUsageBit buffUsage = BufferUsageBit::kAllStorage;
+	const BufferUsageBit buffUsage = BufferUsageBit::kAllUav;
 	const BufferMapAccessBit mapAccess = BufferMapAccessBit::kRead;
 
 	m_pool.init(buffUsage, classes, classes.getBack(), "GpuReadback", false, mapAccess);

AnKi/Core/GpuMemory/GpuSceneBuffer.cpp

@@ -28,7 +28,7 @@ void GpuSceneBuffer::init()
 
 	const Array classes = {32_B, 64_B, 128_B, 256_B, poolSize};
 
-	BufferUsageBit buffUsage = BufferUsageBit::kAllStorage | BufferUsageBit::kTransferDestination;
+	BufferUsageBit buffUsage = BufferUsageBit::kAllUav | BufferUsageBit::kAllSrv | BufferUsageBit::kCopyDestination;
 
 	m_pool.init(buffUsage, classes, poolSize, "GpuScene", true);
 

AnKi/Core/GpuMemory/GpuVisibleTransientMemoryPool.h

@@ -61,8 +61,8 @@ private:
 		m_alignment = max(m_alignment, GrManager::getSingleton().getDeviceCapabilities().m_sbtRecordAlignment);
 		m_alignment = max(m_alignment, GrManager::getSingleton().getDeviceCapabilities().m_accelerationStructureBuildScratchOffsetAlignment);
 
-		BufferUsageBit buffUsage = BufferUsageBit::kAllUniform | BufferUsageBit::kAllStorage | BufferUsageBit::kIndirectDraw
-								   | BufferUsageBit::kIndirectCompute | BufferUsageBit::kVertex | BufferUsageBit::kAllTransfer;
+		BufferUsageBit buffUsage = BufferUsageBit::kAllConstant | BufferUsageBit::kAllUav | BufferUsageBit::kAllSrv | BufferUsageBit::kIndirectDraw
+								   | BufferUsageBit::kIndirectCompute | BufferUsageBit::kVertex | BufferUsageBit::kAllCopy;
 		if(GrManager::getSingleton().getDeviceCapabilities().m_rayTracingEnabled)
 		{
 			buffUsage |= (BufferUsageBit::kAccelerationStructureBuildScratch | BufferUsageBit::kAccelerationStructureBuild);

AnKi/Core/GpuMemory/RebarTransientMemoryPool.cpp

@@ -30,8 +30,8 @@ void RebarTransientMemoryPool::init()
 	BufferInitInfo buffInit("ReBar");
 	buffInit.m_mapAccess = BufferMapAccessBit::kWrite;
 	buffInit.m_size = g_rebarGpuMemorySizeCvar.get();
-	buffInit.m_usage = BufferUsageBit::kAllUniform | BufferUsageBit::kAllStorage | BufferUsageBit::kVertex | BufferUsageBit::kIndex
-					   | BufferUsageBit::kShaderBindingTable | BufferUsageBit::kAllIndirect | BufferUsageBit::kTransferSource;
+	buffInit.m_usage = BufferUsageBit::kAllConstant | BufferUsageBit::kAllUav | BufferUsageBit::kAllSrv | BufferUsageBit::kVertex
+					   | BufferUsageBit::kIndex | BufferUsageBit::kShaderBindingTable | BufferUsageBit::kAllIndirect | BufferUsageBit::kCopySource;
 	m_buffer = GrManager::getSingleton().newBuffer(buffInit);
 
 	m_bufferSize = buffInit.m_size;

AnKi/Core/GpuMemory/UnifiedGeometryBuffer.cpp

@@ -24,8 +24,7 @@ void UnifiedGeometryBuffer::init()
 
 	const Array classes = {1_KB, 8_KB, 32_KB, 128_KB, 512_KB, 4_MB, 8_MB, 16_MB, poolSize};
 
-	BufferUsageBit buffUsage = BufferUsageBit::kVertex | BufferUsageBit::kIndex | BufferUsageBit::kTransferDestination
-							   | (BufferUsageBit::kAllTexel & BufferUsageBit::kAllRead) | (BufferUsageBit::kAllStorage & BufferUsageBit::kAllRead);
+	BufferUsageBit buffUsage = BufferUsageBit::kVertex | BufferUsageBit::kIndex | BufferUsageBit::kCopyDestination | BufferUsageBit::kAllSrv;
 
 	if(GrManager::getSingleton().getDeviceCapabilities().m_rayTracingEnabled)
 	{

AnKi/Gr/CommandBuffer.h

@@ -62,7 +62,7 @@ public:
 
 	ClearValue m_clearValue;
 
-	TextureUsageBit m_usage = TextureUsageBit::kFramebufferWrite;
+	TextureUsageBit m_usage = TextureUsageBit::kRtvDsvWrite;
 
 	RenderTarget() = default;
 

AnKi/Gr/Common.h

@@ -480,49 +480,39 @@ enum class TextureUsageBit : U32
 {
 	kNone = 0,
 
-	kSampledGeometry = 1 << 0,
-	kSampledFragment = 1 << 1,
-	kSampledCompute = 1 << 2,
-	kSampledTraceRays = 1 << 3,
+	kSrvGeometry = 1 << 0,
+	kSrvFragment = 1 << 1,
+	kSrvCompute = 1 << 2,
+	kSrvTraceRays = 1 << 3,
 
-	kStorageGeometryRead = 1 << 4,
-	kStorageGeometryWrite = 1 << 5,
-	kStorageFragmentRead = 1 << 6,
-	kStorageFragmentWrite = 1 << 7,
-	kStorageComputeRead = 1 << 8,
-	kStorageComputeWrite = 1 << 9,
-	kStorageTraceRaysRead = 1 << 10,
-	kStorageTraceRaysWrite = 1 << 11,
+	kUavGeometry = 1 << 4,
+	kUavFragment = 1 << 5,
+	kUavCompute = 1 << 6,
+	kUavTraceRays = 1 << 7,
 
-	kFramebufferRead = 1 << 12,
-	kFramebufferWrite = 1 << 13,
-	kFramebufferShadingRate = 1 << 14,
+	kRtvDsvRead = 1 << 8,
+	kRtvDsvWrite = 1 << 9,
+	kShadingRate = 1 << 10,
 
-	kTransferDestination = 1 << 15,
+	kCopyDestination = 1 << 11,
 
-	kPresent = 1 << 17,
+	kPresent = 1 << 12,
 
 	// Derived
-	kAllSampled = kSampledGeometry | kSampledFragment | kSampledCompute | kSampledTraceRays,
-	kAllStorage = kStorageGeometryRead | kStorageGeometryWrite | kStorageFragmentRead | kStorageFragmentWrite | kStorageComputeRead
-				  | kStorageComputeWrite | kStorageTraceRaysRead | kStorageTraceRaysWrite,
-	kAllFramebuffer = kFramebufferRead | kFramebufferWrite,
-
-	kAllGeometry = kSampledGeometry | kStorageGeometryRead | kStorageGeometryWrite,
-	kAllFragment = kSampledFragment | kStorageFragmentRead | kStorageFragmentWrite,
-	kAllGraphics = kSampledGeometry | kSampledFragment | kStorageGeometryRead | kStorageGeometryWrite | kStorageFragmentRead | kStorageFragmentWrite
-				   | kFramebufferRead | kFramebufferWrite | kFramebufferShadingRate,
-	kAllCompute = kSampledCompute | kStorageComputeRead | kStorageComputeWrite,
-	kAllTransfer = kTransferDestination,
-
-	kAllRead = kAllSampled | kStorageGeometryRead | kStorageFragmentRead | kStorageComputeRead | kStorageTraceRaysRead | kFramebufferRead
-			   | kFramebufferShadingRate | kPresent,
-	kAllWrite =
-		kStorageGeometryWrite | kStorageFragmentWrite | kStorageComputeWrite | kStorageTraceRaysWrite | kFramebufferWrite | kTransferDestination,
+	kAllSrv = kSrvGeometry | kSrvFragment | kSrvCompute | kSrvTraceRays,
+	kAllUav = kUavGeometry | kUavFragment | kUavCompute | kUavTraceRays,
+	kAllRtvDsv = kRtvDsvRead | kRtvDsvWrite,
+
+	kAllGeometry = kSrvGeometry | kUavGeometry,
+	kAllFragment = kSrvFragment | kUavFragment,
+	kAllGraphics = kAllGeometry | kAllFragment | kRtvDsvRead | kRtvDsvWrite | kShadingRate,
+	kAllCompute = kSrvCompute | kUavCompute,
+	kAllTransfer = kCopyDestination,
+
+	kAllRead = kAllSrv | kAllUav | kRtvDsvRead | kShadingRate | kPresent,
+	kAllWrite = kAllUav | kRtvDsvWrite | kCopyDestination,
 	kAll = kAllRead | kAllWrite,
-	kAllShaderResource = kAllSampled | kAllStorage,
-	kAllSrv = (kAllSampled | kAllStorage) & kAllRead,
-	kAllUav = kAllStorage & kAllWrite,
+	kAllShaderResource = kAllSrv | kAllUav,
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(TextureUsageBit)
 
@@ -710,65 +700,53 @@ enum class BufferUsageBit : U64
 {
 	kNone = 0,
 
-	kUniformGeometry = 1ull << 0ull,
-	kUniformFragment = 1ull << 1ull,
-	kUniformCompute = 1ull << 2ull,
-	kUniformTraceRays = 1ull << 3ull,
-
-	kStorageGeometryRead = 1ull << 4ull,
-	kStorageGeometryWrite = 1ull << 5ull,
-	kStorageFragmentRead = 1ull << 6ull,
-	kStorageFragmentWrite = 1ull << 7ull,
-	kStorageComputeRead = 1ull << 8ull,
-	kStorageComputeWrite = 1ull << 9ull,
-	kStorageTraceRaysRead = 1ull << 10ull,
-	kStorageTraceRaysWrite = 1ull << 11ull,
-
-	kTexelGeometryRead = 1ull << 12ull,
-	kTexelGeometryWrite = 1ull << 13ull,
-	kTexelFragmentRead = 1ull << 14ull,
-	kTexelFragmentWrite = 1ull << 15ull,
-	kTexelComputeRead = 1ull << 16ull,
-	kTexelComputeWrite = 1ull << 17ull,
-	kTexelTraceRaysRead = 1ull << 18ull,
-	kTexelTraceRaysWrite = 1ull << 19ull,
-
-	kIndex = 1ull << 20ull,
-	kVertex = 1ull << 21ull,
-
-	kIndirectCompute = 1ull << 22ll,
-	kIndirectDraw = 1ull << 23ull,
-	kIndirectTraceRays = 1ull << 24ull,
-
-	kTransferSource = 1ull << 25ull,
-	kTransferDestination = 1ull << 26ull,
-
-	kAccelerationStructureBuild = 1ull << 27ull, ///< Will be used as a position or index buffer in a BLAS build.
-	kShaderBindingTable = 1ull << 28ull, ///< Will be used as SBT in a traceRays() command.
-	kAccelerationStructureBuildScratch = 1ull << 29ull, ///< Used in buildAccelerationStructureXXX commands.
+	kConstantGeometry = 1ull << 0ull,
+	kConstantFragment = 1ull << 1ull,
+	kConstantCompute = 1ull << 2ull,
+	kConstantTraceRays = 1ull << 3ull,
+
+	kSrvGeometry = 1ull << 4ull,
+	kSrvFragment = 1ull << 5ull,
+	kSrvCompute = 1ull << 6ull,
+	kSrvTraceRays = 1ull << 7ull,
+
+	kUavGeometry = 1ull << 8ull,
+	kUavFragment = 1ull << 9ull,
+	kUavCompute = 1ull << 10ull,
+	kUavTraceRays = 1ull << 11ull,
+
+	kIndex = 1ull << 12ull,
+	kVertex = 1ull << 13ull,
+
+	kIndirectCompute = 1ull << 14ll,
+	kIndirectDraw = 1ull << 15ull,
+	kIndirectTraceRays = 1ull << 16ull,
+
+	kCopySource = 1ull << 17ull,
+	kCopyDestination = 1ull << 18ull,
+
+	kAccelerationStructureBuild = 1ull << 19ull, ///< Will be used as a position or index buffer in a BLAS build.
+	kShaderBindingTable = 1ull << 20ull, ///< Will be used as SBT in a traceRays() command.
+	kAccelerationStructureBuildScratch = 1ull << 21ull, ///< Used in buildAccelerationStructureXXX commands.
 
 	// Derived
-	kAllUniform = kUniformGeometry | kUniformFragment | kUniformCompute | kUniformTraceRays,
-	kAllStorage = kStorageGeometryRead | kStorageGeometryWrite | kStorageFragmentRead | kStorageFragmentWrite | kStorageComputeRead
-				  | kStorageComputeWrite | kStorageTraceRaysRead | kStorageTraceRaysWrite,
-	kAllTexel = kTexelGeometryRead | kTexelGeometryWrite | kTexelFragmentRead | kTexelFragmentWrite | kTexelComputeRead | kTexelComputeWrite
-				| kTexelTraceRaysRead | kTexelTraceRaysWrite,
+	kAllConstant = kConstantGeometry | kConstantFragment | kConstantCompute | kConstantTraceRays,
+	kAllSrv = kSrvGeometry | kSrvFragment | kSrvCompute | kSrvTraceRays,
+	kAllUav = kUavGeometry | kUavFragment | kUavCompute | kUavTraceRays,
 	kAllIndirect = kIndirectCompute | kIndirectDraw | kIndirectTraceRays,
-	kAllTransfer = kTransferSource | kTransferDestination,
+	kAllCopy = kCopySource | kCopyDestination,
 
-	kAllGeometry = kUniformGeometry | kStorageGeometryRead | kStorageGeometryWrite | kTexelGeometryRead | kTexelGeometryWrite | kIndex | kVertex,
-	kAllFragment = kUniformFragment | kStorageFragmentRead | kStorageFragmentWrite | kTexelFragmentRead | kTexelFragmentWrite,
+	kAllGeometry = kConstantGeometry | kSrvGeometry | kUavGeometry | kIndex | kVertex,
+	kAllFragment = kConstantFragment | kSrvFragment | kUavFragment,
 	kAllGraphics = kAllGeometry | kAllFragment | kIndirectDraw,
-	kAllCompute = kUniformCompute | kStorageComputeRead | kStorageComputeWrite | kTexelComputeRead | kTexelComputeWrite | kIndirectCompute,
-	kAllTraceRays = kUniformTraceRays | kStorageTraceRaysRead | kStorageTraceRaysWrite | kTexelTraceRaysRead | kTexelTraceRaysWrite
-					| kIndirectTraceRays | kShaderBindingTable,
+	kAllCompute = kConstantCompute | kSrvCompute | kUavCompute | kIndirectCompute,
+	kAllTraceRays = kConstantTraceRays | kSrvTraceRays | kUavTraceRays | kIndirectTraceRays | kShaderBindingTable,
 
 	kAllRayTracing = kAllTraceRays | kAccelerationStructureBuild | kAccelerationStructureBuildScratch,
-	kAllRead = kAllUniform | kStorageGeometryRead | kStorageFragmentRead | kStorageComputeRead | kStorageTraceRaysRead | kTexelGeometryRead
-			   | kTexelFragmentRead | kTexelComputeRead | kTexelTraceRaysRead | kIndex | kVertex | kIndirectCompute | kIndirectDraw
-			   | kIndirectTraceRays | kTransferSource | kAccelerationStructureBuild | kShaderBindingTable,
-	kAllWrite = kStorageGeometryWrite | kStorageFragmentWrite | kStorageComputeWrite | kStorageTraceRaysWrite | kTexelGeometryWrite
-				| kTexelFragmentWrite | kTexelComputeWrite | kTexelTraceRaysWrite | kTransferDestination | kAccelerationStructureBuildScratch,
+	kAllRead = kAllConstant | kAllSrv | kAllUav | kIndex | kVertex | kAllIndirect | kCopySource | kAccelerationStructureBuild | kShaderBindingTable,
+	kAllWrite = kAllUav | kCopyDestination | kAccelerationStructureBuildScratch,
+
+	kAllShaderResource = kAllConstant | kAllSrv | kAllUav,
 
 	kAll = kAllRead | kAllWrite,
 };

AnKi/Gr/D3D/D3DBuffer.cpp

@@ -89,7 +89,7 @@ Error BufferImpl::init(const BufferInitInfo& inf)
 
 	// D3D12_HEAP_PROPERTIES
 	D3D12_HEAP_PROPERTIES heapProperties = {};
-	if(m_access == BufferMapAccessBit::kWrite && !!(m_usage & ~BufferUsageBit::kAllTransfer))
+	if(m_access == BufferMapAccessBit::kWrite && !!(m_usage & ~BufferUsageBit::kAllCopy))
 	{
 		// Not only transfer, choose ReBAR
 
@@ -128,7 +128,7 @@ Error BufferImpl::init(const BufferInitInfo& inf)
 
 	// D3D12_HEAP_FLAGS
 	D3D12_HEAP_FLAGS heapFlags = {};
-	if(!!(m_usage & BufferUsageBit::kAllStorage))
+	if(!!(m_usage & BufferUsageBit::kAllUav))
 	{
 		heapFlags |= D3D12_HEAP_FLAG_ALLOW_SHADER_ATOMICS;
 	}
@@ -146,11 +146,11 @@ Error BufferImpl::init(const BufferInitInfo& inf)
 	resourceDesc.SampleDesc.Quality = 0;
 	resourceDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
 	resourceDesc.Flags = {};
-	if(!!(m_usage & (BufferUsageBit::kAllStorage | BufferUsageBit::kAllTexel)))
+	if(!!(m_usage & BufferUsageBit::kAllUav))
 	{
 		resourceDesc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
 	}
-	if(!(m_usage & (BufferUsageBit::kAllStorage | BufferUsageBit::kAllUniform | BufferUsageBit::kAllTexel)))
+	if(!(m_usage & BufferUsageBit::kAllShaderResource))
 	{
 		resourceDesc.Flags |= D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE;
 	}
@@ -230,7 +230,7 @@ D3D12_BARRIER_SYNC BufferImpl::computeSync(BufferUsageBit usage) const
 		sync |= D3D12_BARRIER_SYNC_RAYTRACING;
 	}
 
-	if(!!(usage & BufferUsageBit::kAllTransfer))
+	if(!!(usage & BufferUsageBit::kAllCopy))
 	{
 		sync |= D3D12_BARRIER_SYNC_COPY;
 	}
@@ -253,7 +253,7 @@ D3D12_BARRIER_ACCESS BufferImpl::computeAccess(BufferUsageBit usage) const
 		out |= D3D12_BARRIER_ACCESS_VERTEX_BUFFER;
 	}
 
-	if(!!(usage & BufferUsageBit::kAllUniform))
+	if(!!(usage & BufferUsageBit::kAllConstant))
 	{
 		out |= D3D12_BARRIER_ACCESS_CONSTANT_BUFFER;
 	}
@@ -263,12 +263,12 @@ D3D12_BARRIER_ACCESS BufferImpl::computeAccess(BufferUsageBit usage) const
 		out |= D3D12_BARRIER_ACCESS_INDEX_BUFFER;
 	}
 
-	if(!!(usage & ((BufferUsageBit::kAllStorage | BufferUsageBit::kAllTexel) & BufferUsageBit::kAllWrite)))
+	if(!!(usage & BufferUsageBit::kAllUav))
 	{
 		out |= D3D12_BARRIER_ACCESS_UNORDERED_ACCESS;
 	}
 
-	if(!!(usage & ((BufferUsageBit::kAllStorage | BufferUsageBit::kAllTexel) & BufferUsageBit::kAllRead)))
+	if(!!(usage & BufferUsageBit::kAllSrv))
 	{
 		out |= D3D12_BARRIER_ACCESS_SHADER_RESOURCE;
 	}
@@ -278,12 +278,12 @@ D3D12_BARRIER_ACCESS BufferImpl::computeAccess(BufferUsageBit usage) const
 		out |= D3D12_BARRIER_ACCESS_INDIRECT_ARGUMENT;
 	}
 
-	if(!!(usage & BufferUsageBit::kTransferDestination))
+	if(!!(usage & BufferUsageBit::kCopyDestination))
 	{
 		out |= D3D12_BARRIER_ACCESS_COPY_DEST;
 	}
 
-	if(!!(usage & BufferUsageBit::kTransferSource))
+	if(!!(usage & BufferUsageBit::kCopySource))
 	{
 		out |= D3D12_BARRIER_ACCESS_COPY_SOURCE;
 	}

AnKi/Gr/D3D/D3DCommandBuffer.cpp

@@ -370,7 +370,7 @@ void CommandBuffer::beginRenderPass(ConstWeakArray<RenderTarget> colorRts, Rende
 
 		dsDesc = {};
 		dsDesc.cpuDescriptor =
-			tex.getOrCreateDsv(depthStencilRt->m_textureView.getSubresource(), !(depthStencilRt->m_usage & TextureUsageBit::kFramebufferWrite))
+			tex.getOrCreateDsv(depthStencilRt->m_textureView.getSubresource(), !(depthStencilRt->m_usage & TextureUsageBit::kRtvDsvWrite))
 				.getCpuOffset();
 
 		dsDesc.DepthBeginningAccess.Type = convertLoadOp(depthStencilRt->m_loadOperation);
@@ -386,7 +386,7 @@ void CommandBuffer::beginRenderPass(ConstWeakArray<RenderTarget> colorRts, Rende
 		rtWidth = tex.getWidth() >> depthStencilRt->m_textureView.getFirstMipmap();
 		rtHeight = tex.getHeight() >> depthStencilRt->m_textureView.getFirstMipmap();
 
-		if(!(depthStencilRt->m_usage & TextureUsageBit::kFramebufferWrite))
+		if(!(depthStencilRt->m_usage & TextureUsageBit::kRtvDsvWrite))
 		{
 			flags |= !!(depthStencilRt->m_textureView.getDepthStencilAspect() & DepthStencilAspectBit::kDepth)
 						 ? D3D12_RENDER_PASS_FLAG_BIND_READ_ONLY_DEPTH
@@ -634,11 +634,11 @@ void CommandBuffer::copyBufferToTexture(const BufferView& buff, const TextureVie
 void CommandBuffer::fillBuffer(const BufferView& buff, U32 value)
 {
 	ANKI_ASSERT((buff.getRange() % sizeof(U32)) == 0);
-	ANKI_ASSERT(!!(buff.getBuffer().getBufferUsage() & BufferUsageBit::kTransferDestination));
+	ANKI_ASSERT(!!(buff.getBuffer().getBufferUsage() & BufferUsageBit::kCopyDestination));
 
 	BufferInitInfo srcBufferInit("FillBufferTmp");
 	srcBufferInit.m_mapAccess = BufferMapAccessBit::kWrite;
-	srcBufferInit.m_usage = BufferUsageBit::kTransferSource;
+	srcBufferInit.m_usage = BufferUsageBit::kCopySource;
 	srcBufferInit.m_size = buff.getRange();
 
 	BufferPtr srcBuffer = GrManager::getSingleton().newBuffer(srcBufferInit);
@@ -663,8 +663,8 @@ void CommandBuffer::writeOcclusionQueriesResultToBuffer([[maybe_unused]] ConstWe
 void CommandBuffer::copyBufferToBuffer(Buffer* src, Buffer* dst, ConstWeakArray<CopyBufferToBufferInfo> copies)
 {
 	ANKI_ASSERT(src && dst);
-	ANKI_ASSERT(!!(src->getBufferUsage() & BufferUsageBit::kTransferSource));
-	ANKI_ASSERT(!!(dst->getBufferUsage() & BufferUsageBit::kTransferDestination));
+	ANKI_ASSERT(!!(src->getBufferUsage() & BufferUsageBit::kCopySource));
+	ANKI_ASSERT(!!(dst->getBufferUsage() & BufferUsageBit::kCopyDestination));
 
 	ANKI_D3D_SELF(CommandBufferImpl);
 

AnKi/Gr/D3D/D3DQueryFactory.cpp

@@ -42,7 +42,7 @@ Error QueryFactory::newQuery(QueryHandle& handle)
 
 		BufferInitInfo buffInit("QueryBuffer");
 		buffInit.m_mapAccess = BufferMapAccessBit::kRead;
-		buffInit.m_usage = BufferUsageBit::kTransferDestination;
+		buffInit.m_usage = BufferUsageBit::kCopyDestination;
 		buffInit.m_size = kMaxQueriesPerQueryChunk * m_resultStructSize;
 		chunk.m_resultsBuffer = GrManager::getSingleton().newBuffer(buffInit);
 

AnKi/Gr/D3D/D3DSwapchainFactory.cpp

@@ -81,7 +81,7 @@ Error MicroSwapchain::initInternal()
 		init.m_width = window.getWidth();
 		init.m_height = window.getHeight();
 		init.m_format = Format::kR8G8B8A8_Unorm;
-		init.m_usage = TextureUsageBit::kFramebufferRead | TextureUsageBit::kFramebufferWrite | TextureUsageBit::kPresent;
+		init.m_usage = TextureUsageBit::kRtvDsvRead | TextureUsageBit::kRtvDsvWrite | TextureUsageBit::kPresent;
 		init.m_type = TextureType::k2D;
 
 		TextureImpl* tex = newInstance<TextureImpl>(GrMemoryPool::getSingleton(), init.getName());

AnKi/Gr/D3D/D3DTexture.cpp

@@ -133,17 +133,17 @@ Error TextureImpl::initInternal(ID3D12Resource* external, const TextureInitInfo&
 		desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
 		desc.Flags = {};
 
-		if(!!(m_usage & TextureUsageBit::kAllFramebuffer) && m_aspect == DepthStencilAspectBit::kNone)
+		if(!!(m_usage & TextureUsageBit::kAllRtvDsv) && m_aspect == DepthStencilAspectBit::kNone)
 		{
 			desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
 		}
 
-		if(!!(m_usage & TextureUsageBit::kAllFramebuffer) && m_aspect != DepthStencilAspectBit::kNone)
+		if(!!(m_usage & TextureUsageBit::kAllRtvDsv) && m_aspect != DepthStencilAspectBit::kNone)
 		{
 			desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL;
 		}
 
-		if(!!(m_usage & TextureUsageBit::kAllStorage))
+		if(!!(m_usage & TextureUsageBit::kAllUav))
 		{
 			desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
 		}
@@ -157,7 +157,7 @@ Error TextureImpl::initInternal(ID3D12Resource* external, const TextureInitInfo&
 		heapProperties.Type = D3D12_HEAP_TYPE_DEFAULT;
 
 		D3D12_HEAP_FLAGS heapFlags = {};
-		if(!!(m_usage & TextureUsageBit::kAllStorage))
+		if(!!(m_usage & TextureUsageBit::kAllUav))
 		{
 			heapFlags |= D3D12_HEAP_FLAG_ALLOW_SHADER_ATOMICS;
 		}
@@ -172,7 +172,7 @@ Error TextureImpl::initInternal(ID3D12Resource* external, const TextureInitInfo&
 	}
 
 	// Create the default views
-	if(!!(m_usage & TextureUsageBit::kAllFramebuffer))
+	if(!!(m_usage & TextureUsageBit::kAllRtvDsv))
 	{
 		const TextureView tview(this, TextureSubresourceDesc::firstSurface());
 		initView(tview.getSubresource(), !!(m_aspect & DepthStencilAspectBit::kDepthStencil) ? ViewType::kDsv : ViewType::kRtv,
@@ -180,7 +180,7 @@ Error TextureImpl::initInternal(ID3D12Resource* external, const TextureInitInfo&
 		m_firstSurfaceRtvOrDsvSubresource = tview.getSubresource();
 	}
 
-	if(!!(m_usage & TextureUsageBit::kAllSampled))
+	if(!!(m_usage & TextureUsageBit::kAllSrv))
 	{
 		const TextureView tview(this, TextureSubresourceDesc::all());
 		initView(tview.getSubresource(), ViewType::kSrv, m_wholeTextureSrv);
@@ -196,7 +196,7 @@ void TextureImpl::initView(const TextureSubresourceDesc& subresource, ViewType t
 
 	if(type == ViewType::kRtv)
 	{
-		ANKI_ASSERT(!!(m_usage & TextureUsageBit::kAllFramebuffer));
+		ANKI_ASSERT(!!(m_usage & TextureUsageBit::kAllRtvDsv));
 		ANKI_ASSERT(TextureView(this, subresource).isGoodForRenderTarget() && m_aspect == DepthStencilAspectBit::kNone);
 
 		D3D12_RENDER_TARGET_VIEW_DESC desc = {};
@@ -220,7 +220,7 @@ void TextureImpl::initView(const TextureSubresourceDesc& subresource, ViewType t
 	}
 	else if(type == ViewType::kDsv || type == ViewType::kReadOnlyDsv)
 	{
-		ANKI_ASSERT(!!(m_usage & TextureUsageBit::kAllFramebuffer));
+		ANKI_ASSERT(!!(m_usage & TextureUsageBit::kAllRtvDsv));
 		ANKI_ASSERT(TextureView(this, subresource).isGoodForRenderTarget() && m_aspect != DepthStencilAspectBit::kNone);
 
 		D3D12_DEPTH_STENCIL_VIEW_DESC desc = {};
@@ -577,53 +577,53 @@ void TextureImpl::computeBarrierInfo(TextureUsageBit usage, D3D12_BARRIER_SYNC&
 	{
 		// DS is a little bit special, it has 3 states
 
-		if(!!(usage & TextureUsageBit::kFramebufferWrite))
+		if(!!(usage & TextureUsageBit::kRtvDsvWrite))
 		{
 			// Writing to DS, can't be anything else
 			stages |= D3D12_BARRIER_SYNC_DEPTH_STENCIL;
 			accesses |= D3D12_BARRIER_ACCESS_DEPTH_STENCIL_WRITE;
 		}
-		else if(!!(usage & TextureUsageBit::kFramebufferRead) && !!(usage & TextureUsageBit::kAllSampled))
+		else if(!!(usage & TextureUsageBit::kRtvDsvRead) && !!(usage & TextureUsageBit::kAllSrv))
 		{
 			// Reading in the renderpass and sampling at the same time
 
-			if(!!(usage & (TextureUsageBit::kSampledGeometry | TextureUsageBit::kSampledFragment)))
+			if(!!(usage & (TextureUsageBit::kSrvGeometry | TextureUsageBit::kSrvFragment)))
 			{
 				stages |= D3D12_BARRIER_SYNC_DRAW;
 			}
 
-			if(!!(usage & TextureUsageBit::kSampledCompute))
+			if(!!(usage & TextureUsageBit::kSrvCompute))
 			{
 				stages |= D3D12_BARRIER_SYNC_COMPUTE_SHADING;
 			}
 
-			if(!!(usage & TextureUsageBit::kSampledTraceRays) && rt)
+			if(!!(usage & TextureUsageBit::kSrvTraceRays) && rt)
 			{
 				stages |= D3D12_BARRIER_SYNC_RAYTRACING;
 			}
 
 			accesses |= D3D12_BARRIER_ACCESS_COMMON; // Include all
 		}
-		else if(!!(usage & TextureUsageBit::kAllSampled))
+		else if(!!(usage & TextureUsageBit::kAllSrv))
 		{
 			// Only sampled
 
-			if(!!(usage & TextureUsageBit::kSampledGeometry))
+			if(!!(usage & TextureUsageBit::kSrvGeometry))
 			{
 				stages |= D3D12_BARRIER_SYNC_VERTEX_SHADING;
 			}
 
-			if(!!(usage & TextureUsageBit::kSampledFragment))
+			if(!!(usage & TextureUsageBit::kSrvFragment))
 			{
 				stages |= D3D12_BARRIER_SYNC_PIXEL_SHADING;
 			}
 
-			if(!!(usage & TextureUsageBit::kSampledCompute))
+			if(!!(usage & TextureUsageBit::kSrvCompute))
 			{
 				stages |= D3D12_BARRIER_SYNC_COMPUTE_SHADING;
 			}
 
-			if(!!(usage & TextureUsageBit::kSampledTraceRays) && rt)
+			if(!!(usage & TextureUsageBit::kSrvTraceRays) && rt)
 			{
 				stages |= D3D12_BARRIER_SYNC_RAYTRACING;
 			}
@@ -633,80 +633,80 @@ void TextureImpl::computeBarrierInfo(TextureUsageBit usage, D3D12_BARRIER_SYNC&
 		else
 		{
 			// Only renderpass read
-			ANKI_ASSERT(!!(usage & TextureUsageBit::kFramebufferRead));
+			ANKI_ASSERT(!!(usage & TextureUsageBit::kRtvDsvRead));
 			stages |= D3D12_BARRIER_SYNC_DEPTH_STENCIL;
 			accesses |= D3D12_BARRIER_ACCESS_DEPTH_STENCIL_READ;
 		}
 	}
 	else
 	{
-		if(!!(usage & (TextureUsageBit::kSampledGeometry | TextureUsageBit::kStorageGeometryRead)))
+		if(!!(usage & TextureUsageBit::kSrvGeometry))
 		{
 			stages |= D3D12_BARRIER_SYNC_VERTEX_SHADING;
 			accesses |= D3D12_BARRIER_ACCESS_SHADER_RESOURCE;
 		}
 
-		if(!!(usage & TextureUsageBit::kStorageGeometryWrite))
+		if(!!(usage & TextureUsageBit::kUavGeometry))
 		{
 			stages |= D3D12_BARRIER_SYNC_VERTEX_SHADING;
 			accesses |= D3D12_BARRIER_ACCESS_UNORDERED_ACCESS;
 		}
 
-		if(!!(usage & (TextureUsageBit::kSampledFragment | TextureUsageBit::kStorageFragmentRead)))
+		if(!!(usage & TextureUsageBit::kSrvFragment))
 		{
 			stages |= D3D12_BARRIER_SYNC_PIXEL_SHADING;
 			accesses |= D3D12_BARRIER_ACCESS_SHADER_RESOURCE;
 		}
 
-		if(!!(usage & TextureUsageBit::kStorageFragmentWrite))
+		if(!!(usage & TextureUsageBit::kUavFragment))
 		{
 			stages |= D3D12_BARRIER_SYNC_PIXEL_SHADING;
 			accesses |= D3D12_BARRIER_ACCESS_UNORDERED_ACCESS;
 		}
 
-		if(!!(usage & (TextureUsageBit::kSampledCompute | TextureUsageBit::kStorageComputeRead)))
+		if(!!(usage & TextureUsageBit::kSrvCompute))
 		{
 			stages |= D3D12_BARRIER_SYNC_COMPUTE_SHADING;
 			accesses |= D3D12_BARRIER_ACCESS_SHADER_RESOURCE;
 		}
 
-		if(!!(usage & TextureUsageBit::kStorageComputeWrite))
+		if(!!(usage & TextureUsageBit::kUavCompute))
 		{
 			stages |= D3D12_BARRIER_SYNC_COMPUTE_SHADING;
 			accesses |= D3D12_BARRIER_ACCESS_UNORDERED_ACCESS;
 		}
 
-		if(!!(usage & (TextureUsageBit::kSampledTraceRays | TextureUsageBit::kStorageTraceRaysRead)) && rt)
+		if(!!(usage & TextureUsageBit::kSrvTraceRays) && rt)
 		{
 			stages |= D3D12_BARRIER_SYNC_RAYTRACING;
 			accesses |= D3D12_BARRIER_ACCESS_SHADER_RESOURCE;
 		}
 
-		if(!!(usage & TextureUsageBit::kStorageTraceRaysWrite) && rt)
+		if(!!(usage & TextureUsageBit::kUavTraceRays) && rt)
 		{
 			stages |= D3D12_BARRIER_SYNC_COMPUTE_SHADING;
 			accesses |= D3D12_BARRIER_ACCESS_UNORDERED_ACCESS;
 		}
 
-		if(!!(usage & TextureUsageBit::kFramebufferWrite))
+		if(!!(usage & TextureUsageBit::kRtvDsvWrite))
 		{
 			stages |= D3D12_BARRIER_SYNC_RENDER_TARGET;
 			accesses |= D3D12_BARRIER_ACCESS_RENDER_TARGET;
 		}
-		else if(!!(usage & TextureUsageBit::kFramebufferRead))
+		else if(!!(usage & TextureUsageBit::kRtvDsvRead))
 		{
 			// Read only
 			stages |= D3D12_BARRIER_SYNC_RENDER_TARGET;
 			accesses |= D3D12_BARRIER_ACCESS_RENDER_TARGET;
 		}
 
-		if(!!(usage & TextureUsageBit::kFramebufferShadingRate))
+		if(!!(usage & TextureUsageBit::kShadingRate))
 		{
 			stages |= D3D12_BARRIER_SYNC_PIXEL_SHADING;
 			accesses |= D3D12_BARRIER_ACCESS_SHADING_RATE_SOURCE;
 		}
 
-		if(!!(usage & TextureUsageBit::kTransferDestination))
+		if(!!(usage & TextureUsageBit::kCopyDestination))
 		{
 			stages |= D3D12_BARRIER_SYNC_COPY;
 			accesses |= D3D12_BARRIER_ACCESS_COPY_DEST;
@@ -733,17 +733,17 @@ D3D12_BARRIER_LAYOUT TextureImpl::computeLayout(TextureUsageBit usage) const
 	}
 	else if(depthStencil)
 	{
-		if((usage & TextureUsageBit::kAllSampled) == usage)
+		if((usage & TextureUsageBit::kAllSrv) == usage)
 		{
 			// Only sampled
 			out = D3D12_BARRIER_LAYOUT_SHADER_RESOURCE;
 		}
-		else if((usage & TextureUsageBit::kFramebufferRead) == usage)
+		else if((usage & TextureUsageBit::kRtvDsvRead) == usage)
 		{
 			// Only FB read
 			out = D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_READ;
 		}
-		else if((usage & (TextureUsageBit::kAllSampled | TextureUsageBit::kFramebufferRead)) == usage)
+		else if((usage & (TextureUsageBit::kAllSrv | TextureUsageBit::kRtvDsvRead)) == usage)
 		{
 			// Only depth tests and sampled
 			out = D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_READ;
@@ -751,16 +751,16 @@ D3D12_BARRIER_LAYOUT TextureImpl::computeLayout(TextureUsageBit usage) const
 		else
 		{
 			// Only attachment write, the rest (eg transfer) are not supported for now
-			ANKI_ASSERT(usage == TextureUsageBit::kAllFramebuffer || usage == TextureUsageBit::kFramebufferWrite);
+			ANKI_ASSERT(usage == TextureUsageBit::kAllRtvDsv || usage == TextureUsageBit::kRtvDsvWrite);
 			out = D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_WRITE;
 		}
 	}
-	else if((usage & TextureUsageBit::kAllFramebuffer) == usage)
+	else if((usage & TextureUsageBit::kAllRtvDsv) == usage)
 	{
 		// Color attachment
 		out = D3D12_BARRIER_LAYOUT_RENDER_TARGET;
 	}
-	else if((usage & TextureUsageBit::kFramebufferShadingRate) == usage)
+	else if((usage & TextureUsageBit::kShadingRate) == usage)
 	{
 		// SRI
 		out = D3D12_BARRIER_LAYOUT_SHADING_RATE_SOURCE;
@@ -775,7 +775,7 @@ D3D12_BARRIER_LAYOUT TextureImpl::computeLayout(TextureUsageBit usage) const
 		// SRV
 		out = D3D12_BARRIER_LAYOUT_SHADER_RESOURCE;
 	}
-	else if(usage == TextureUsageBit::kTransferDestination)
+	else if(usage == TextureUsageBit::kCopyDestination)
 	{
 		out = D3D12_BARRIER_LAYOUT_COPY_DEST;
 	}

AnKi/Gr/Texture.h

@@ -388,7 +388,7 @@ public:
 		return (m_subresource.m_depthStencilAspect == DepthStencilAspectBit::kDepth
 				|| m_subresource.m_depthStencilAspect == DepthStencilAspectBit::kStencil
 				|| m_subresource.m_depthStencilAspect == DepthStencilAspectBit::kNone)
-			   && !!(m_tex->getTextureUsage() & TextureUsageBit::kAllSampled);
+			   && !!(m_tex->getTextureUsage() & TextureUsageBit::kAllSrv);
 	}
 
 	/// Return true if the subresource can be used in CommandBuffer::copyBufferToTexture.
@@ -396,20 +396,20 @@ public:
 	{
 		validate();
 		return isSingleSurfaceOrVolume() && m_subresource.m_depthStencilAspect == DepthStencilAspectBit::kNone
-			   && !!(m_tex->getTextureUsage() & TextureUsageBit::kTransferDestination);
+			   && !!(m_tex->getTextureUsage() & TextureUsageBit::kCopyDestination);
 	}
 
 	[[nodiscard]] Bool isGoodForStorage() const
 	{
 		validate();
 		return isSingleSurfaceOrVolume() && m_subresource.m_depthStencilAspect == DepthStencilAspectBit::kNone
-			   && !!(m_tex->getTextureUsage() & TextureUsageBit::kAllStorage);
+			   && !!(m_tex->getTextureUsage() & TextureUsageBit::kAllUav);
 	}
 
 	[[nodiscard]] Bool isGoodForRenderTarget() const
 	{
 		validate();
-		return isSingleSurfaceOrVolume() && !!(m_tex->getTextureUsage() & TextureUsageBit::kAllFramebuffer);
+		return isSingleSurfaceOrVolume() && !!(m_tex->getTextureUsage() & TextureUsageBit::kAllRtvDsv);
 	}
 
 	/// Returns true if there is a surface or volume that overlaps. It doesn't check the aspect.

AnKi/Gr/Utils/SegregatedListsGpuMemoryPool.cpp

@@ -119,7 +119,7 @@ Error SegregatedListsGpuMemoryPool::allocateChunk(Chunk*& newChunk, PtrSize& chu
 
 		BufferInitInfo buffInit(m_bufferName);
 		buffInit.m_size = m_initialBufferSize;
-		buffInit.m_usage = m_bufferUsage | BufferUsageBit::kAllTransfer;
+		buffInit.m_usage = m_bufferUsage | BufferUsageBit::kAllCopy;
 		buffInit.m_mapAccess = m_mapAccess;
 		m_gpuBuffer = GrManager::getSingleton().newBuffer(buffInit);
 
@@ -147,7 +147,7 @@ Error SegregatedListsGpuMemoryPool::allocateChunk(Chunk*& newChunk, PtrSize& chu
 		// Create the new buffer
 		BufferInitInfo buffInit(m_bufferName);
 		buffInit.m_size = m_gpuBuffer->getSize() * 2;
-		buffInit.m_usage = m_bufferUsage | BufferUsageBit::kAllTransfer;
+		buffInit.m_usage = m_bufferUsage | BufferUsageBit::kAllCopy;
 		buffInit.m_mapAccess = m_mapAccess;
 		BufferPtr newBuffer = GrManager::getSingleton().newBuffer(buffInit);
 
@@ -159,15 +159,15 @@ Error SegregatedListsGpuMemoryPool::allocateChunk(Chunk*& newChunk, PtrSize& chu
 		Array<BufferBarrierInfo, 2> barriers;
 		barriers[0].m_bufferView = BufferView(m_gpuBuffer.get());
 		barriers[0].m_previousUsage = m_bufferUsage;
-		barriers[0].m_nextUsage = BufferUsageBit::kTransferSource;
+		barriers[0].m_nextUsage = BufferUsageBit::kCopySource;
 		barriers[1].m_bufferView = BufferView(newBuffer.get());
 		barriers[1].m_previousUsage = BufferUsageBit::kNone;
-		barriers[1].m_nextUsage = BufferUsageBit::kTransferDestination;
+		barriers[1].m_nextUsage = BufferUsageBit::kCopyDestination;
 		cmdb->setPipelineBarrier({}, barriers, {});
 
 		cmdb->copyBufferToBuffer(BufferView(m_gpuBuffer.get()), BufferView(newBuffer.get(), 0, m_gpuBuffer->getSize()));
 
-		barriers[1].m_previousUsage = BufferUsageBit::kTransferDestination;
+		barriers[1].m_previousUsage = BufferUsageBit::kCopyDestination;
 		barriers[1].m_nextUsage = m_bufferUsage;
 		cmdb->setPipelineBarrier({}, ConstWeakArray<BufferBarrierInfo>{&barriers[1], 1}, {});
 

AnKi/Gr/Vulkan/VkBuffer.cpp

@@ -127,7 +127,7 @@ Error BufferImpl::init(const BufferInitInfo& inf)
 {
 	ANKI_ASSERT(!isCreated());
 	const Bool exposeGpuAddress =
-		!!(getGrManagerImpl().getExtensions() & VulkanExtensions::kKHR_buffer_device_address) && !!(inf.m_usage & ~BufferUsageBit::kAllTransfer);
+		!!(getGrManagerImpl().getExtensions() & VulkanExtensions::kKHR_buffer_device_address) && !!(inf.m_usage & ~BufferUsageBit::kAllCopy);
 
 	PtrSize size = inf.m_size;
 	BufferMapAccessBit access = inf.m_mapAccess;
@@ -175,7 +175,7 @@ Error BufferImpl::init(const BufferInitInfo& inf)
 
 		if(isDiscreteGpu)
 		{
-			if((usage & (~BufferUsageBit::kAllTransfer)) != BufferUsageBit::kNone)
+			if((usage & (~BufferUsageBit::kAllCopy)) != BufferUsageBit::kNone)
 			{
 				// Will be used for something other than transfer, try to put it in the device
 				prefer |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
@@ -199,7 +199,7 @@ Error BufferImpl::init(const BufferInitInfo& inf)
 			{
 				ANKI_VK_LOGW("Using a fallback mode for write-only buffer");
 
-				if((usage & (~BufferUsageBit::kAllTransfer)) == BufferUsageBit::kNone)
+				if((usage & (~BufferUsageBit::kAllCopy)) == BufferUsageBit::kNone)
 				{
 					// Will be used only for transfers, don't want it in the device
 					avoid |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
@@ -343,7 +343,7 @@ VkPipelineStageFlags BufferImpl::computePplineStage(BufferUsageBit usage)
 		stageMask |= VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
 	}
 
-	if(!!(usage & BufferUsageBit::kAllTransfer))
+	if(!!(usage & BufferUsageBit::kAllCopy))
 	{
 		stageMask |= VK_PIPELINE_STAGE_TRANSFER_BIT;
 	}
@@ -361,17 +361,10 @@ VkAccessFlags BufferImpl::computeAccessMask(BufferUsageBit usage)
 {
 	VkAccessFlags mask = 0;
 
-	constexpr BufferUsageBit kShaderRead = BufferUsageBit::kStorageGeometryRead | BufferUsageBit::kStorageFragmentRead
-										   | BufferUsageBit::kStorageComputeRead | BufferUsageBit::kStorageTraceRaysRead
-										   | BufferUsageBit::kTexelGeometryRead | BufferUsageBit::kTexelFragmentRead
-										   | BufferUsageBit::kTexelComputeRead | BufferUsageBit::kTexelTraceRaysRead;
+	constexpr BufferUsageBit kShaderRead = BufferUsageBit::kAllShaderResource & BufferUsageBit::kAllRead;
+	constexpr BufferUsageBit kShaderWrite = BufferUsageBit::kAllShaderResource & BufferUsageBit::kAllWrite;
 
-	constexpr BufferUsageBit kShaderWrite = BufferUsageBit::kStorageGeometryWrite | BufferUsageBit::kStorageFragmentWrite
-											| BufferUsageBit::kStorageComputeWrite | BufferUsageBit::kStorageTraceRaysWrite
-											| BufferUsageBit::kTexelGeometryWrite | BufferUsageBit::kTexelFragmentWrite
-											| BufferUsageBit::kTexelComputeWrite | BufferUsageBit::kTexelTraceRaysWrite;
-
-	if(!!(usage & BufferUsageBit::kAllUniform))
+	if(!!(usage & BufferUsageBit::kAllConstant))
 	{
 		mask |= VK_ACCESS_UNIFORM_READ_BIT;
 	}
@@ -401,12 +394,12 @@ VkAccessFlags BufferImpl::computeAccessMask(BufferUsageBit usage)
 		mask |= VK_ACCESS_INDIRECT_COMMAND_READ_BIT;
 	}
 
-	if(!!(usage & BufferUsageBit::kTransferDestination))
+	if(!!(usage & BufferUsageBit::kCopyDestination))
 	{
 		mask |= VK_ACCESS_TRANSFER_WRITE_BIT;
 	}
 
-	if(!!(usage & BufferUsageBit::kTransferSource))
+	if(!!(usage & BufferUsageBit::kCopySource))
 	{
 		mask |= VK_ACCESS_TRANSFER_READ_BIT;
 	}
@@ -456,7 +449,6 @@ VkBufferView BufferImpl::getOrCreateBufferView(Format fmt, PtrSize offset, PtrSi
 	}
 
 	// Checks
-	ANKI_ASSERT(!!(m_usage & BufferUsageBit::kAllTexel));
 	ANKI_ASSERT(offset + range <= m_size);
 
 	ANKI_ASSERT(isAligned(getGrManagerImpl().getDeviceCapabilities().m_texelBufferBindOffsetAlignment, offset) && "Offset not aligned");

AnKi/Gr/Vulkan/VkCommandBuffer.cpp

@@ -206,7 +206,7 @@ void CommandBuffer::bindTexture(Register reg, const TextureView& texView)
 	if(reg.m_resourceType == HlslResourceType::kSrv)
 	{
 		ANKI_ASSERT(texView.isGoodForSampling());
-		const VkImageLayout lay = tex.computeLayout(TextureUsageBit::kAllSampled & tex.getTextureUsage());
+		const VkImageLayout lay = tex.computeLayout(TextureUsageBit::kAllSrv & tex.getTextureUsage());
 		self.m_descriptorState.bindSampledTexture(reg.m_space, reg.m_bindPoint, tex.getImageView(texView.getSubresource()), lay);
 	}
 	else
@@ -764,7 +764,7 @@ void CommandBuffer::copyBufferToTexture(const BufferView& buff, const TextureVie
 	self.commandCommon();
 
 	const TextureImpl& tex = static_cast<const TextureImpl&>(texView.getTexture());
-	ANKI_ASSERT(tex.usageValid(TextureUsageBit::kTransferDestination));
+	ANKI_ASSERT(tex.usageValid(TextureUsageBit::kCopyDestination));
 	ANKI_ASSERT(texView.isGoodForCopyBufferToTexture());
 	const VkImageLayout layout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
 	const VkImageSubresourceRange range = tex.computeVkImageSubresourceRange(texView.getSubresource());
@@ -809,7 +809,7 @@ void CommandBuffer::fillBuffer(const BufferView& buff, U32 value)
 	self.commandCommon();
 	ANKI_ASSERT(!self.m_insideRenderpass);
 	const BufferImpl& impl = static_cast<const BufferImpl&>(buff.getBuffer());
-	ANKI_ASSERT(impl.usageValid(BufferUsageBit::kTransferDestination));
+	ANKI_ASSERT(impl.usageValid(BufferUsageBit::kCopyDestination));
 
 	ANKI_ASSERT((buff.getOffset() % 4) == 0 && "Should be multiple of 4");
 	ANKI_ASSERT((buff.getRange() % 4) == 0 && "Should be multiple of 4");
@@ -830,7 +830,7 @@ void CommandBuffer::writeOcclusionQueriesResultToBuffer(ConstWeakArray<Occlusion
 	ANKI_ASSERT((buff.getOffset() % 4) == 0);
 
 	const BufferImpl& impl = static_cast<const BufferImpl&>(buff.getBuffer());
-	ANKI_ASSERT(impl.usageValid(BufferUsageBit::kTransferDestination));
+	ANKI_ASSERT(impl.usageValid(BufferUsageBit::kCopyDestination));
 
 	for(U32 i = 0; i < queries.getSize(); ++i)
 	{
@@ -848,8 +848,8 @@ void CommandBuffer::writeOcclusionQueriesResultToBuffer(ConstWeakArray<Occlusion
 void CommandBuffer::copyBufferToBuffer(Buffer* src, Buffer* dst, ConstWeakArray<CopyBufferToBufferInfo> copies)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
-	ANKI_ASSERT(static_cast<const BufferImpl&>(*src).usageValid(BufferUsageBit::kTransferSource));
-	ANKI_ASSERT(static_cast<const BufferImpl&>(*dst).usageValid(BufferUsageBit::kTransferDestination));
+	ANKI_ASSERT(static_cast<const BufferImpl&>(*src).usageValid(BufferUsageBit::kCopySource));
+	ANKI_ASSERT(static_cast<const BufferImpl&>(*dst).usageValid(BufferUsageBit::kCopyDestination));
 	ANKI_ASSERT(copies.getSize() > 0);
 
 	self.commandCommon();

AnKi/Gr/Vulkan/VkCommon.cpp

@@ -276,12 +276,12 @@ VkBufferUsageFlags convertBufferUsageBit(BufferUsageBit usageMask)
 
 	const Bool rt = GrManager::getSingleton().getDeviceCapabilities().m_rayTracingEnabled;
 
-	if(!!(usageMask & BufferUsageBit::kAllUniform))
+	if(!!(usageMask & BufferUsageBit::kAllConstant))
 	{
 		out |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
 	}
 
-	if(!!(usageMask & BufferUsageBit::kAllStorage))
+	if(!!(usageMask & (BufferUsageBit::kAllUav | BufferUsageBit::kAllSrv)))
 	{
 		out |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
 	}
@@ -301,22 +301,22 @@ VkBufferUsageFlags convertBufferUsageBit(BufferUsageBit usageMask)
 		out |= VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
 	}
 
-	if(!!(usageMask & BufferUsageBit::kTransferDestination))
+	if(!!(usageMask & BufferUsageBit::kCopyDestination))
 	{
 		out |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
 	}
 
-	if(!!(usageMask & BufferUsageBit::kTransferSource))
+	if(!!(usageMask & BufferUsageBit::kCopySource))
 	{
 		out |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
 	}
 
-	if(!!(usageMask & (BufferUsageBit::kAllTexel & BufferUsageBit::kAllRead)))
+	if(!!(usageMask & ((BufferUsageBit::kAllSrv | BufferUsageBit::kAllUav) & BufferUsageBit::kAllRead)))
 	{
 		out |= VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT;
 	}
 
-	if(!!(usageMask & (BufferUsageBit::kAllTexel & BufferUsageBit::kAllWrite)))
+	if(!!(usageMask & ((BufferUsageBit::kAllSrv | BufferUsageBit::kAllUav) & BufferUsageBit::kAllWrite)))
 	{
 		out |= VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT;
 	}
@@ -404,17 +404,17 @@ VkImageUsageFlags convertTextureUsage(const TextureUsageBit ak, const Format for
 {
 	VkImageUsageFlags out = 0;
 
-	if(!!(ak & TextureUsageBit::kAllSampled))
+	if(!!(ak & TextureUsageBit::kAllSrv))
 	{
 		out |= VK_IMAGE_USAGE_SAMPLED_BIT;
 	}
 
-	if(!!(ak & TextureUsageBit::kAllStorage))
+	if(!!(ak & TextureUsageBit::kAllUav))
 	{
 		out |= VK_IMAGE_USAGE_STORAGE_BIT;
 	}
 
-	if(!!(ak & (TextureUsageBit::kFramebufferRead | TextureUsageBit::kFramebufferWrite)))
+	if(!!(ak & (TextureUsageBit::kRtvDsvRead | TextureUsageBit::kRtvDsvWrite)))
 	{
 		if(getFormatInfo(format).isDepthStencil())
 		{
@@ -426,12 +426,12 @@ VkImageUsageFlags convertTextureUsage(const TextureUsageBit ak, const Format for
 		}
 	}
 
-	if(!!(ak & TextureUsageBit::kFramebufferShadingRate))
+	if(!!(ak & TextureUsageBit::kShadingRate))
 	{
 		out |= VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
 	}
 
-	if(!!(ak & TextureUsageBit::kTransferDestination))
+	if(!!(ak & TextureUsageBit::kCopyDestination))
 	{
 		out |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
 	}

AnKi/Gr/Vulkan/VkSwapchainFactory.cpp

@@ -224,8 +224,8 @@ Error MicroSwapchain::initInternal()
 			init.m_width = surfaceWidth;
 			init.m_height = surfaceHeight;
 			init.m_format = Format(surfaceFormat); // anki::Format is compatible with VkFormat
-			init.m_usage = TextureUsageBit::kStorageComputeWrite | TextureUsageBit::kStorageTraceRaysWrite | TextureUsageBit::kFramebufferRead
-						   | TextureUsageBit::kFramebufferWrite | TextureUsageBit::kPresent;
+			init.m_usage = TextureUsageBit::kUavCompute | TextureUsageBit::kUavTraceRays | TextureUsageBit::kRtvDsvRead
+						   | TextureUsageBit::kRtvDsvWrite | TextureUsageBit::kPresent;
 			init.m_type = TextureType::k2D;
 
 			TextureImpl* tex = newInstance<TextureImpl>(GrMemoryPool::getSingleton(), init.getName());

AnKi/Gr/Vulkan/VkTexture.cpp

@@ -120,7 +120,7 @@ Error TextureImpl::initInternal(VkImage externalImage, const TextureInitInfo& in
 		ANKI_ASSERT(!!(init.m_usage & TextureUsageBit::kPresent));
 	}
 
-	ANKI_ASSERT(getGrManagerImpl().getDeviceCapabilities().m_vrs || !(init.m_usage & TextureUsageBit::kFramebufferShadingRate));
+	ANKI_ASSERT(getGrManagerImpl().getDeviceCapabilities().m_vrs || !(init.m_usage & TextureUsageBit::kShadingRate));
 
 	// Set some stuff
 	m_width = init.m_width;
@@ -306,57 +306,57 @@ void TextureImpl::computeBarrierInfo(TextureUsageBit usage, VkPipelineStageFlags
 	const Bool depthStencil = !!m_aspect;
 	const Bool rt = getGrManagerImpl().getDeviceCapabilities().m_rayTracingEnabled;
 
-	if(!!(usage & (TextureUsageBit::kSampledGeometry | TextureUsageBit::kStorageGeometryRead)))
+	if(!!(usage & TextureUsageBit::kSrvGeometry))
 	{
 		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(!!(usage & TextureUsageBit::kStorageGeometryWrite))
+	if(!!(usage & TextureUsageBit::kUavGeometry))
 	{
 		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(!!(usage & (TextureUsageBit::kSampledFragment | TextureUsageBit::kStorageFragmentRead)))
+	if(!!(usage & TextureUsageBit::kSrvFragment))
 	{
 		stages |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
 		accesses |= VK_ACCESS_SHADER_READ_BIT;
 	}
 
-	if(!!(usage & TextureUsageBit::kStorageFragmentWrite))
+	if(!!(usage & TextureUsageBit::kUavFragment))
 	{
 		stages |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
 		accesses |= VK_ACCESS_SHADER_WRITE_BIT;
 	}
 
-	if(!!(usage & (TextureUsageBit::kSampledCompute | TextureUsageBit::kStorageComputeRead)))
+	if(!!(usage & TextureUsageBit::kSrvCompute))
 	{
 		stages |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
 		accesses |= VK_ACCESS_SHADER_READ_BIT;
 	}
 
-	if(!!(usage & TextureUsageBit::kStorageComputeWrite))
+	if(!!(usage & TextureUsageBit::kUavCompute))
 	{
 		stages |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
 		accesses |= VK_ACCESS_SHADER_WRITE_BIT;
 	}
 
-	if(!!(usage & (TextureUsageBit::kSampledTraceRays | TextureUsageBit::kStorageTraceRaysRead)) && rt)
+	if(!!(usage & TextureUsageBit::kSrvTraceRays) && rt)
 	{
 		stages |= VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
 		accesses |= VK_ACCESS_SHADER_READ_BIT;
 	}
 
-	if(!!(usage & TextureUsageBit::kStorageTraceRaysWrite) && rt)
+	if(!!(usage & TextureUsageBit::kUavTraceRays) && rt)
 	{
 		stages |= VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
 		accesses |= VK_ACCESS_SHADER_WRITE_BIT;
 	}
 
-	if(!!(usage & TextureUsageBit::kFramebufferRead))
+	if(!!(usage & TextureUsageBit::kRtvDsvRead))
 	{
 		if(depthStencil)
 		{
@@ -370,7 +370,7 @@ void TextureImpl::computeBarrierInfo(TextureUsageBit usage, VkPipelineStageFlags
 		}
 	}
 
-	if(!!(usage & TextureUsageBit::kFramebufferWrite))
+	if(!!(usage & TextureUsageBit::kRtvDsvWrite))
 	{
 		if(depthStencil)
 		{
@@ -384,13 +384,13 @@ void TextureImpl::computeBarrierInfo(TextureUsageBit usage, VkPipelineStageFlags
 		}
 	}
 
-	if(!!(usage & TextureUsageBit::kFramebufferShadingRate))
+	if(!!(usage & TextureUsageBit::kShadingRate))
 	{
 		stages |= VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
 		accesses |= VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR;
 	}
 
-	if(!!(usage & TextureUsageBit::kTransferDestination))
+	if(!!(usage & TextureUsageBit::kCopyDestination))
 	{
 		stages |= VK_PIPELINE_STAGE_TRANSFER_BIT;
 		accesses |= VK_ACCESS_TRANSFER_WRITE_BIT;
@@ -450,7 +450,7 @@ VkImageLayout TextureImpl::computeLayout(TextureUsageBit usage) const
 	}
 	else if(depthStencil)
 	{
-		if(!(usage & ~(TextureUsageBit::kAllSampled | TextureUsageBit::kFramebufferRead)))
+		if(!(usage & ~(TextureUsageBit::kAllSrv | TextureUsageBit::kRtvDsvRead)))
 		{
 			// Only depth tests and sampled
 			out = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
@@ -458,31 +458,31 @@ VkImageLayout TextureImpl::computeLayout(TextureUsageBit usage) const
 		else
 		{
 			// Only attachment write, the rest (eg transfer) are not supported for now
-			ANKI_ASSERT(usage == TextureUsageBit::kFramebufferWrite || usage == TextureUsageBit::kAllFramebuffer);
+			ANKI_ASSERT(usage == TextureUsageBit::kRtvDsvWrite || usage == TextureUsageBit::kAllRtvDsv);
 			out = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
 		}
 	}
-	else if(!(usage & ~TextureUsageBit::kAllFramebuffer))
+	else if(!(usage & ~TextureUsageBit::kAllRtvDsv))
 	{
 		// Color attachment
 		out = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
 	}
-	else if(!(usage & ~TextureUsageBit::kFramebufferShadingRate))
+	else if(!(usage & ~TextureUsageBit::kShadingRate))
 	{
 		// SRI
 		out = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR;
 	}
-	else if(!(usage & ~TextureUsageBit::kAllStorage))
+	else if(!(usage & ~TextureUsageBit::kAllUav))
 	{
 		// Only image load/store
 		out = VK_IMAGE_LAYOUT_GENERAL;
 	}
-	else if(!(usage & ~TextureUsageBit::kAllSampled))
+	else if(!(usage & ~TextureUsageBit::kAllSrv))
 	{
 		// Only sampled
 		out = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 	}
-	else if(usage == TextureUsageBit::kTransferDestination)
+	else if(usage == TextureUsageBit::kCopyDestination)
 	{
 		out = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
 	}

AnKi/Renderer/Bloom.cpp

@@ -88,8 +88,8 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 		{
 			NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("Bloom Main");
 
-			rpass.newTextureDependency(getRenderer().getDownscaleBlur().getRt(), TextureUsageBit::kSampledCompute, inputTexSubresource);
-			rpass.newTextureDependency(m_runCtx.m_exposureRt, TextureUsageBit::kStorageComputeWrite);
+			rpass.newTextureDependency(getRenderer().getDownscaleBlur().getRt(), TextureUsageBit::kSrvCompute, inputTexSubresource);
+			rpass.newTextureDependency(m_runCtx.m_exposureRt, TextureUsageBit::kUavCompute);
 
 			prpass = &rpass;
 		}
@@ -98,8 +98,8 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 			GraphicsRenderPass& rpass = rgraph.newGraphicsRenderPass("Bloom Main");
 			rpass.setRenderpassInfo({GraphicsRenderPassTargetDesc(m_runCtx.m_exposureRt)});
 
-			rpass.newTextureDependency(getRenderer().getDownscaleBlur().getRt(), TextureUsageBit::kSampledFragment, inputTexSubresource);
-			rpass.newTextureDependency(m_runCtx.m_exposureRt, TextureUsageBit::kFramebufferWrite);
+			rpass.newTextureDependency(getRenderer().getDownscaleBlur().getRt(), TextureUsageBit::kSrvFragment, inputTexSubresource);
+			rpass.newTextureDependency(m_runCtx.m_exposureRt, TextureUsageBit::kRtvDsvWrite);
 
 			prpass = &rpass;
 		}
@@ -146,8 +146,8 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 		{
 			NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("Bloom Upscale");
 
-			rpass.newTextureDependency(m_runCtx.m_exposureRt, TextureUsageBit::kSampledCompute);
-			rpass.newTextureDependency(m_runCtx.m_upscaleRt, TextureUsageBit::kStorageComputeWrite);
+			rpass.newTextureDependency(m_runCtx.m_exposureRt, TextureUsageBit::kSrvCompute);
+			rpass.newTextureDependency(m_runCtx.m_upscaleRt, TextureUsageBit::kUavCompute);
 
 			prpass = &rpass;
 		}
@@ -156,8 +156,8 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 			GraphicsRenderPass& rpass = rgraph.newGraphicsRenderPass("Bloom Upscale");
 			rpass.setRenderpassInfo({GraphicsRenderPassTargetDesc(m_runCtx.m_upscaleRt)});
 
-			rpass.newTextureDependency(m_runCtx.m_exposureRt, TextureUsageBit::kSampledFragment);
-			rpass.newTextureDependency(m_runCtx.m_upscaleRt, TextureUsageBit::kFramebufferWrite);
+			rpass.newTextureDependency(m_runCtx.m_exposureRt, TextureUsageBit::kSrvFragment);
+			rpass.newTextureDependency(m_runCtx.m_upscaleRt, TextureUsageBit::kRtvDsvWrite);
 
 			prpass = &rpass;
 		}

AnKi/Renderer/ClusterBinning.cpp

@@ -71,10 +71,10 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 		for(GpuSceneNonRenderableObjectType type : EnumIterable<GpuSceneNonRenderableObjectType>())
 		{
 			rpass.newBufferDependency(getRenderer().getPrimaryNonRenderableVisibility().getVisibleIndicesBufferHandle(type),
-									  BufferUsageBit::kStorageComputeRead);
+									  BufferUsageBit::kSrvCompute);
 		}
-		rpass.newBufferDependency(indirectArgsHandle, BufferUsageBit::kStorageComputeWrite);
-		rpass.newBufferDependency(m_runCtx.m_clustersHandle, BufferUsageBit::kTransferDestination);
+		rpass.newBufferDependency(indirectArgsHandle, BufferUsageBit::kUavCompute);
+		rpass.newBufferDependency(m_runCtx.m_clustersHandle, BufferUsageBit::kCopyDestination);
 
 		rpass.setWork([this, indirectArgsBuff](RenderPassWorkContext& rgraphCtx) {
 			CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
@@ -105,7 +105,7 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 		NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("Cluster binning");
 
 		rpass.newBufferDependency(indirectArgsHandle, BufferUsageBit::kIndirectCompute);
-		rpass.newBufferDependency(m_runCtx.m_clustersHandle, BufferUsageBit::kStorageComputeWrite);
+		rpass.newBufferDependency(m_runCtx.m_clustersHandle, BufferUsageBit::kUavCompute);
 
 		rpass.setWork([this, &ctx, indirectArgsBuff](RenderPassWorkContext& rgraphCtx) {
 			CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
@@ -218,7 +218,7 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 		rpass.newBufferDependency(indirectArgsHandle, BufferUsageBit::kIndirectCompute);
 		for(GpuSceneNonRenderableObjectType type : EnumIterable<GpuSceneNonRenderableObjectType>())
 		{
-			rpass.newBufferDependency(m_runCtx.m_packedObjectsHandles[type], BufferUsageBit::kStorageComputeWrite);
+			rpass.newBufferDependency(m_runCtx.m_packedObjectsHandles[type], BufferUsageBit::kUavCompute);
 		}
 
 		rpass.setWork([this, indirectArgsBuff](RenderPassWorkContext& rgraphCtx) {

AnKi/Renderer/Dbg.cpp

@@ -254,18 +254,18 @@ void Dbg::populateRenderGraph(RenderingContext& ctx)
 	depthRti.m_loadOperation = RenderTargetLoadOperation::kLoad;
 	pass.setRenderpassInfo({colorRti}, &depthRti);
 
-	pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite);
-	pass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSampledFragment | TextureUsageBit::kFramebufferRead);
+	pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kRtvDsvWrite);
+	pass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSrvFragment | TextureUsageBit::kRtvDsvRead);
 
 	BufferView indicesBuff;
 	BufferHandle dep;
 	getRenderer().getGBuffer().getVisibleAabbsBuffer(indicesBuff, dep);
-	pass.newBufferDependency(dep, BufferUsageBit::kStorageGeometryRead);
+	pass.newBufferDependency(dep, BufferUsageBit::kSrvGeometry);
 
 	if(GpuSceneArrays::RenderableBoundingVolumeForward::getSingleton().getElementCount())
 	{
 		getRenderer().getForwardShading().getVisibleAabbsBuffer(indicesBuff, dep);
-		pass.newBufferDependency(dep, BufferUsageBit::kStorageGeometryRead);
+		pass.newBufferDependency(dep, BufferUsageBit::kSrvGeometry);
 	}
 }
 

AnKi/Renderer/DepthDownscale.cpp

@@ -60,21 +60,10 @@ Error DepthDownscale::initInternal()
 	{
 		BufferInitInfo buffInit("Depth downscale counter buffer");
 		buffInit.m_size = sizeof(U32);
-		buffInit.m_usage = BufferUsageBit::kStorageComputeWrite | BufferUsageBit::kTransferDestination;
+		buffInit.m_usage = BufferUsageBit::kUavCompute | BufferUsageBit::kCopyDestination;
 		m_counterBuffer = GrManager::getSingleton().newBuffer(buffInit);
 
-		// Zero it
-		CommandBufferInitInfo cmdbInit;
-		cmdbInit.m_flags |= CommandBufferFlag::kSmallBatch;
-		CommandBufferPtr cmdb = GrManager::getSingleton().newCommandBuffer(cmdbInit);
-
-		cmdb->fillBuffer(BufferView(m_counterBuffer.get()), 0);
-
-		FencePtr fence;
-		cmdb->endRecording();
-		GrManager::getSingleton().submit(cmdb.get(), {}, &fence);
-
-		fence->clientWait(6.0_sec);
+		zeroBuffer(m_counterBuffer.get());
 	}
 
 	return Error::kNone;
@@ -104,9 +93,9 @@ void DepthDownscale::populateRenderGraph(RenderingContext& ctx)
 
 		NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass("Depth downscale");
 
-		pass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSampledCompute);
+		pass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSrvCompute);
 
-		pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kStorageComputeWrite);
+		pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kUavCompute);
 
 		pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 			CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
@@ -164,14 +153,14 @@ void DepthDownscale::populateRenderGraph(RenderingContext& ctx)
 
 			if(mip == 0)
 			{
-				pass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSampledFragment);
+				pass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSrvFragment);
 			}
 			else
 			{
-				pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kSampledFragment, TextureSubresourceDesc::surface(mip - 1, 0, 0));
+				pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kSrvFragment, TextureSubresourceDesc::surface(mip - 1, 0, 0));
 			}
 
-			pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite, TextureSubresourceDesc::surface(mip, 0, 0));
+			pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kRtvDsvWrite, TextureSubresourceDesc::surface(mip, 0, 0));
 
 			pass.setWork([this, mip](RenderPassWorkContext& rgraphCtx) {
 				CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;

AnKi/Renderer/DownscaleBlur.cpp

@@ -35,17 +35,17 @@ Error DownscaleBlur::initInternal()
 
 	// Create the miped texture
 	TextureInitInfo texinit = getRenderer().create2DRenderTargetDescription(rez.x(), rez.y(), getRenderer().getHdrFormat(), "DownscaleBlur");
-	texinit.m_usage = TextureUsageBit::kSampledFragment | TextureUsageBit::kSampledCompute;
+	texinit.m_usage = TextureUsageBit::kSrvFragment | TextureUsageBit::kSrvCompute;
 	if(preferCompute)
 	{
-		texinit.m_usage |= TextureUsageBit::kStorageComputeWrite;
+		texinit.m_usage |= TextureUsageBit::kUavCompute;
 	}
 	else
 	{
-		texinit.m_usage |= TextureUsageBit::kFramebufferWrite;
+		texinit.m_usage |= TextureUsageBit::kRtvDsvWrite;
 	}
 	texinit.m_mipmapCount = U8(m_passCount);
-	m_rtTex = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSampledCompute);
+	m_rtTex = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvCompute);
 
 	// Shader programs
 	ANKI_CHECK(loadShaderProgram("ShaderBinaries/DownscaleBlur.ankiprogbin", m_prog, m_grProg));
@@ -56,7 +56,7 @@ Error DownscaleBlur::initInternal()
 void DownscaleBlur::importRenderTargets(RenderingContext& ctx)
 {
 	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
-	m_runCtx.m_rt = rgraph.importRenderTarget(m_rtTex.get(), TextureUsageBit::kSampledCompute);
+	m_runCtx.m_rt = rgraph.importRenderTarget(m_rtTex.get(), TextureUsageBit::kSrvCompute);
 }
 
 void DownscaleBlur::populateRenderGraph(RenderingContext& ctx)
@@ -87,8 +87,8 @@ void DownscaleBlur::populateRenderGraph(RenderingContext& ctx)
 			ppass = &pass;
 		}
 
-		const TextureUsageBit readUsage = (g_preferComputeCVar.get()) ? TextureUsageBit::kSampledCompute : TextureUsageBit::kSampledFragment;
-		const TextureUsageBit writeUsage = (g_preferComputeCVar.get()) ? TextureUsageBit::kStorageComputeWrite : TextureUsageBit::kFramebufferWrite;
+		const TextureUsageBit readUsage = (g_preferComputeCVar.get()) ? TextureUsageBit::kSrvCompute : TextureUsageBit::kSrvFragment;
+		const TextureUsageBit writeUsage = (g_preferComputeCVar.get()) ? TextureUsageBit::kUavCompute : TextureUsageBit::kRtvDsvWrite;
 
 		if(i > 0)
 		{

AnKi/Renderer/FinalComposite.cpp

@@ -78,17 +78,17 @@ void FinalComposite::populateRenderGraph(RenderingContext& ctx)
 	});
 	pass.setRenderpassInfo({GraphicsRenderPassTargetDesc(ctx.m_outRenderTarget)});
 
-	pass.newTextureDependency(ctx.m_outRenderTarget, TextureUsageBit::kFramebufferWrite);
+	pass.newTextureDependency(ctx.m_outRenderTarget, TextureUsageBit::kRtvDsvWrite);
 
 	if(g_dbgCVar.get())
 	{
-		pass.newTextureDependency(getRenderer().getDbg().getRt(), TextureUsageBit::kSampledFragment);
+		pass.newTextureDependency(getRenderer().getDbg().getRt(), TextureUsageBit::kSrvFragment);
 	}
 
-	pass.newTextureDependency(getRenderer().getScale().getTonemappedRt(), TextureUsageBit::kSampledFragment);
-	pass.newTextureDependency(getRenderer().getBloom().getRt(), TextureUsageBit::kSampledFragment);
-	pass.newTextureDependency(getRenderer().getMotionVectors().getMotionVectorsRt(), TextureUsageBit::kSampledFragment);
-	pass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSampledFragment);
+	pass.newTextureDependency(getRenderer().getScale().getTonemappedRt(), TextureUsageBit::kSrvFragment);
+	pass.newTextureDependency(getRenderer().getBloom().getRt(), TextureUsageBit::kSrvFragment);
+	pass.newTextureDependency(getRenderer().getMotionVectors().getMotionVectorsRt(), TextureUsageBit::kSrvFragment);
+	pass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSrvFragment);
 
 	Array<RenderTargetHandle, kMaxDebugRenderTargets> dbgRts;
 	ShaderProgramPtr debugProgram;
@@ -99,7 +99,7 @@ void FinalComposite::populateRenderGraph(RenderingContext& ctx)
 		{
 			if(handle.isValid())
 			{
-				pass.newTextureDependency(handle, TextureUsageBit::kSampledFragment);
+				pass.newTextureDependency(handle, TextureUsageBit::kSrvFragment);
 			}
 		}
 	}

AnKi/Renderer/ForwardShading.cpp

@@ -99,9 +99,8 @@ void ForwardShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgr
 
 void ForwardShading::setDependencies(GraphicsRenderPass& pass)
 {
-	pass.newTextureDependency(getRenderer().getDepthDownscale().getRt(), TextureUsageBit::kSampledFragment,
-							  DepthDownscale::kQuarterInternalResolution);
-	pass.newTextureDependency(getRenderer().getVolumetricLightingAccumulation().getRt(), TextureUsageBit::kSampledFragment);
+	pass.newTextureDependency(getRenderer().getDepthDownscale().getRt(), TextureUsageBit::kSrvFragment, DepthDownscale::kQuarterInternalResolution);
+	pass.newTextureDependency(getRenderer().getVolumetricLightingAccumulation().getRt(), TextureUsageBit::kSrvFragment);
 
 	if(getRenderer().getLensFlare().getIndirectDrawBuffer().isValid())
 	{

AnKi/Renderer/GBuffer.cpp

@@ -45,12 +45,12 @@ Error GBuffer::initInternal()
 	static constexpr Array<const char*, 2> depthRtNames = {{"GBuffer depth #0", "GBuffer depth #1"}};
 	for(U32 i = 0; i < 2; ++i)
 	{
-		const TextureUsageBit usage = TextureUsageBit::kAllSampled | TextureUsageBit::kAllFramebuffer;
+		const TextureUsageBit usage = TextureUsageBit::kAllSrv | TextureUsageBit::kAllRtvDsv;
 		TextureInitInfo texinit =
 			getRenderer().create2DRenderTargetInitInfo(getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y(),
 													   getRenderer().getDepthNoStencilFormat(), usage, depthRtNames[i]);
 
-		m_depthRts[i] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
+		m_depthRts[i] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvFragment);
 	}
 
 	static constexpr Array<const char*, kGBufferColorRenderTargetCount> rtNames = {{"GBuffer rt0", "GBuffer rt1", "GBuffer rt2", "GBuffer rt3"}};
@@ -62,14 +62,14 @@ Error GBuffer::initInternal()
 	}
 
 	{
-		const TextureUsageBit usage = TextureUsageBit::kSampledCompute | TextureUsageBit::kStorageComputeWrite | TextureUsageBit::kSampledGeometry;
+		const TextureUsageBit usage = TextureUsageBit::kSrvCompute | TextureUsageBit::kUavCompute | TextureUsageBit::kSrvGeometry;
 
 		TextureInitInfo texinit =
 			getRenderer().create2DRenderTargetInitInfo(g_hzbWidthCVar.get(), g_hzbHeightCVar.get(), Format::kR32_Sfloat, usage, "GBuffer HZB");
 		texinit.m_mipmapCount = U8(computeMaxMipmapCount2d(texinit.m_width, texinit.m_height));
 		ClearValue clear;
 		clear.m_colorf = {1.0f, 1.0f, 1.0f, 1.0f};
-		m_hzbRt = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSampledCompute, clear);
+		m_hzbRt = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvCompute, clear);
 	}
 
 	ANKI_CHECK(loadShaderProgram("ShaderBinaries/VisualizeGBufferNormal.ankiprogbin", m_visNormalProg, m_visNormalGrProg));
@@ -93,9 +93,9 @@ void GBuffer::importRenderTargets(RenderingContext& ctx)
 	{
 		m_runCtx.m_crntFrameDepthRt = rgraph.importRenderTarget(m_depthRts[getRenderer().getFrameCount() & 1].get(), TextureUsageBit::kNone);
 		m_runCtx.m_prevFrameDepthRt =
-			rgraph.importRenderTarget(m_depthRts[(getRenderer().getFrameCount() + 1) & 1].get(), TextureUsageBit::kSampledFragment);
+			rgraph.importRenderTarget(m_depthRts[(getRenderer().getFrameCount() + 1) & 1].get(), TextureUsageBit::kSrvFragment);
 
-		m_runCtx.m_hzbRt = rgraph.importRenderTarget(m_hzbRt.get(), TextureUsageBit::kSampledCompute);
+		m_runCtx.m_hzbRt = rgraph.importRenderTarget(m_hzbRt.get(), TextureUsageBit::kSrvCompute);
 	}
 }
 
@@ -141,8 +141,7 @@ void GBuffer::populateRenderGraph(RenderingContext& ctx)
 	auto genGBuffer = [&](Bool firstPass) {
 		GraphicsRenderPass& pass = rgraph.newGraphicsRenderPass((firstPass) ? "GBuffer" : "GBuffer 2nd phase");
 
-		const TextureUsageBit rtUsage =
-			(firstPass) ? TextureUsageBit::kFramebufferWrite : (TextureUsageBit::kFramebufferRead | TextureUsageBit::kFramebufferWrite);
+		const TextureUsageBit rtUsage = (firstPass) ? TextureUsageBit::kRtvDsvWrite : (TextureUsageBit::kRtvDsvRead | TextureUsageBit::kRtvDsvWrite);
 		for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 		{
 			pass.newTextureDependency(m_runCtx.m_colorRts[i], rtUsage);
@@ -150,13 +149,12 @@ void GBuffer::populateRenderGraph(RenderingContext& ctx)
 
 		pass.newTextureDependency(m_runCtx.m_crntFrameDepthRt, rtUsage);
 
-		pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(),
-								 BufferUsageBit::kStorageGeometryRead | BufferUsageBit::kStorageFragmentRead);
+		pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kSrvGeometry | BufferUsageBit::kSrvFragment);
 
 		// Only add one depedency to the GPU visibility. No need to track all buffers
 		if(visOut.containsDrawcalls())
 		{
-			pass.newBufferDependency(visOut.m_dependency, BufferUsageBit::kIndirectDraw | BufferUsageBit::kStorageGeometryRead);
+			pass.newBufferDependency(visOut.m_dependency, BufferUsageBit::kIndirectDraw | BufferUsageBit::kSrvGeometry);
 		}
 		else
 		{
@@ -178,7 +176,7 @@ void GBuffer::populateRenderGraph(RenderingContext& ctx)
 		depthRti.m_subresource.m_depthStencilAspect = DepthStencilAspectBit::kDepth;
 		pass.setRenderpassInfo(WeakArray{colorRti}, &depthRti, 0, 0, kMaxU32, kMaxU32);
 
-		pass.setWork([this, &ctx, visOut](RenderPassWorkContext& rgraphCtx) {
+		pass.setWork([&ctx, visOut](RenderPassWorkContext& rgraphCtx) {
 			ANKI_TRACE_SCOPED_EVENT(GBuffer);
 
 			CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;

AnKi/Renderer/GBufferPost.cpp

@@ -80,13 +80,13 @@ void GBufferPost::populateRenderGraph(RenderingContext& ctx)
 	rt1.m_loadOperation = RenderTargetLoadOperation::kLoad;
 	rpass.setRenderpassInfo({rt0, rt1});
 
-	rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(0), TextureUsageBit::kAllFramebuffer);
-	rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(1), TextureUsageBit::kAllFramebuffer);
-	rpass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSampledFragment);
+	rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(0), TextureUsageBit::kAllRtvDsv);
+	rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(1), TextureUsageBit::kAllRtvDsv);
+	rpass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSrvFragment);
 
-	rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kStorageFragmentRead);
+	rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kSrvFragment);
 	rpass.newBufferDependency(getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kDecal),
-							  BufferUsageBit::kStorageFragmentRead);
+							  BufferUsageBit::kSrvFragment);
 }
 
 } // end namespace anki

AnKi/Renderer/IndirectDiffuseProbes.cpp

@@ -239,9 +239,9 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 
 				for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 				{
-					pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kFramebufferWrite, TextureSubresourceDesc::surface(0, f, 0));
+					pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kRtvDsvWrite, TextureSubresourceDesc::surface(0, f, 0));
 				}
-				pass.newTextureDependency(gbufferDepthRt, TextureUsageBit::kAllFramebuffer,
+				pass.newTextureDependency(gbufferDepthRt, TextureUsageBit::kAllRtvDsv,
 										  TextureSubresourceDesc::firstSurface(DepthStencilAspectBit::kDepth));
 
 				pass.newBufferDependency(visOut.m_dependency, BufferUsageBit::kIndirectDraw);
@@ -309,7 +309,7 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 				depthRti.m_clearValue.m_depthStencil.m_depth = 1.0f;
 				pass.setRenderpassInfo({}, &depthRti);
 
-				pass.newTextureDependency(shadowsRt, TextureUsageBit::kAllFramebuffer,
+				pass.newTextureDependency(shadowsRt, TextureUsageBit::kAllRtvDsv,
 										  TextureSubresourceDesc::firstSurface(DepthStencilAspectBit::kDepth));
 				pass.newBufferDependency(shadowVisOut.m_dependency, BufferUsageBit::kIndirectDraw);
 
@@ -358,25 +358,25 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 				colorRti.m_subresource.m_face = f;
 				pass.setRenderpassInfo({colorRti});
 
-				pass.newBufferDependency(lightVis.m_visiblesBufferHandle, BufferUsageBit::kStorageFragmentRead);
+				pass.newBufferDependency(lightVis.m_visiblesBufferHandle, BufferUsageBit::kSrvFragment);
 
-				pass.newTextureDependency(lightShadingRt, TextureUsageBit::kFramebufferWrite, TextureSubresourceDesc::surface(0, f, 0));
+				pass.newTextureDependency(lightShadingRt, TextureUsageBit::kRtvDsvWrite, TextureSubresourceDesc::surface(0, f, 0));
 
 				for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 				{
-					pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kSampledFragment, TextureSubresourceDesc::surface(0, f, 0));
+					pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kSrvFragment, TextureSubresourceDesc::surface(0, f, 0));
 				}
-				pass.newTextureDependency(gbufferDepthRt, TextureUsageBit::kSampledFragment,
+				pass.newTextureDependency(gbufferDepthRt, TextureUsageBit::kSrvFragment,
 										  TextureSubresourceDesc::firstSurface(DepthStencilAspectBit::kDepth));
 
 				if(shadowsRt.isValid())
 				{
-					pass.newTextureDependency(shadowsRt, TextureUsageBit::kSampledFragment);
+					pass.newTextureDependency(shadowsRt, TextureUsageBit::kSrvFragment);
 				}
 
 				if(getRenderer().getSky().isEnabled())
 				{
-					pass.newTextureDependency(getRenderer().getSky().getSkyLutRt(), TextureUsageBit::kSampledFragment);
+					pass.newTextureDependency(getRenderer().getSky().getSkyLutRt(), TextureUsageBit::kSrvFragment);
 				}
 
 				pass.setWork([this, visibleLightsBuffer = lightVis.m_visiblesBuffer, viewProjMat = frustum.getViewProjectionMatrix(), cellCenter,
@@ -433,11 +433,11 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 		{
 			NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass(generateTempPassName("GI: Irradiance cell:%u", cellIdx));
 
-			pass.newTextureDependency(lightShadingRt, TextureUsageBit::kSampledCompute);
-			pass.newTextureDependency(irradianceVolume, TextureUsageBit::kStorageComputeWrite);
+			pass.newTextureDependency(lightShadingRt, TextureUsageBit::kSrvCompute);
+			pass.newTextureDependency(irradianceVolume, TextureUsageBit::kUavCompute);
 			for(U32 i = 0; i < kGBufferColorRenderTargetCount - 1; ++i)
 			{
-				pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kSampledCompute);
+				pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kSrvCompute);
 			}
 
 			pass.setWork([this, lightShadingRt, gbufferColorRts, irradianceVolume, cellIdx, probeToRefresh](RenderPassWorkContext& rgraphCtx) {

AnKi/Renderer/LensFlare.cpp

@@ -60,9 +60,8 @@ void LensFlare::populateRenderGraph(RenderingContext& ctx)
 	// Create the pass
 	NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("Lens flare indirect");
 
-	rpass.newBufferDependency(m_runCtx.m_indirectBuffHandle, BufferUsageBit::kStorageComputeWrite);
-	rpass.newTextureDependency(getRenderer().getDepthDownscale().getRt(), TextureUsageBit::kSampledCompute,
-							   DepthDownscale::kEighthInternalResolution);
+	rpass.newBufferDependency(m_runCtx.m_indirectBuffHandle, BufferUsageBit::kUavCompute);
+	rpass.newTextureDependency(getRenderer().getDepthDownscale().getRt(), TextureUsageBit::kSrvCompute, DepthDownscale::kEighthInternalResolution);
 
 	rpass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
 		ANKI_TRACE_SCOPED_EVENT(LensFlare);

AnKi/Renderer/LightShading.cpp

@@ -276,24 +276,24 @@ void LightShading::populateRenderGraph(RenderingContext& ctx)
 						   (enableVrs) ? getRenderer().getVrsSriGeneration().getSriTexelDimension() : 0,
 						   (enableVrs) ? getRenderer().getVrsSriGeneration().getSriTexelDimension() : 0);
 
-	const TextureUsageBit readUsage = TextureUsageBit::kSampledFragment;
+	const TextureUsageBit readUsage = TextureUsageBit::kSrvFragment;
 
 	// All
 	if(enableVrs)
 	{
-		pass.newTextureDependency(sriRt, TextureUsageBit::kFramebufferShadingRate);
+		pass.newTextureDependency(sriRt, TextureUsageBit::kShadingRate);
 	}
 
 	// Light shading
-	pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite);
+	pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kRtvDsvWrite);
 	pass.newTextureDependency(getRenderer().getGBuffer().getColorRt(0), readUsage);
 	pass.newTextureDependency(getRenderer().getGBuffer().getColorRt(1), readUsage);
 	pass.newTextureDependency(getRenderer().getGBuffer().getColorRt(2), readUsage);
-	pass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSampledFragment | TextureUsageBit::kFramebufferRead);
+	pass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSrvFragment | TextureUsageBit::kRtvDsvRead);
 	pass.newTextureDependency(getRenderer().getShadowmapsResolve().getRt(), readUsage);
-	pass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kStorageFragmentRead);
+	pass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kSrvFragment);
 	pass.newBufferDependency(getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kLight),
-							 BufferUsageBit::kStorageFragmentRead);
+							 BufferUsageBit::kSrvFragment);
 	pass.newTextureDependency(getRenderer().getSsao().getRt(), readUsage);
 	pass.newTextureDependency(getRenderer().getSsr().getRt(), readUsage);
 

AnKi/Renderer/MainRenderer.cpp

@@ -124,8 +124,8 @@ Error MainRenderer::render(Texture* presentTex)
 			cmdb.draw(PrimitiveTopology::kTriangles, 3);
 		});
 
-		pass.newTextureDependency(presentRt, TextureUsageBit::kFramebufferWrite);
-		pass.newTextureDependency(ctx.m_outRenderTarget, TextureUsageBit::kSampledFragment);
+		pass.newTextureDependency(presentRt, TextureUsageBit::kRtvDsvWrite);
+		pass.newTextureDependency(ctx.m_outRenderTarget, TextureUsageBit::kSrvFragment);
 	}
 
 	// Create a dummy pass to transition the presentable image to present

AnKi/Renderer/MotionVectors.cpp

@@ -51,8 +51,8 @@ void MotionVectors::populateRenderGraph(RenderingContext& ctx)
 	{
 		NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass("MotionVectors");
 
-		readUsage = TextureUsageBit::kSampledCompute;
-		writeUsage = TextureUsageBit::kStorageComputeWrite;
+		readUsage = TextureUsageBit::kSrvCompute;
+		writeUsage = TextureUsageBit::kUavCompute;
 		ppass = &pass;
 	}
 	else
@@ -60,8 +60,8 @@ void MotionVectors::populateRenderGraph(RenderingContext& ctx)
 		GraphicsRenderPass& pass = rgraph.newGraphicsRenderPass("MotionVectors");
 		pass.setRenderpassInfo({GraphicsRenderPassTargetDesc(m_runCtx.m_motionVectorsRtHandle)});
 
-		readUsage = TextureUsageBit::kSampledFragment;
-		writeUsage = TextureUsageBit::kFramebufferWrite;
+		readUsage = TextureUsageBit::kSrvFragment;
+		writeUsage = TextureUsageBit::kRtvDsvWrite;
 		ppass = &pass;
 	}
 

AnKi/Renderer/ProbeReflections.cpp

@@ -120,7 +120,7 @@ Error ProbeReflections::initIrradiance()
 	// Create buff
 	{
 		BufferInitInfo init;
-		init.m_usage = BufferUsageBit::kAllStorage;
+		init.m_usage = BufferUsageBit::kAllUav | BufferUsageBit::kAllSrv;
 		init.m_size = 6 * sizeof(Vec4);
 		m_irradiance.m_diceValuesBuff = GrManager::getSingleton().newBuffer(init);
 	}
@@ -240,10 +240,10 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 
 			for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 			{
-				pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kFramebufferWrite, TextureSubresourceDesc::surface(0, f, 0));
+				pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kRtvDsvWrite, TextureSubresourceDesc::surface(0, f, 0));
 			}
 
-			pass.newTextureDependency(gbufferDepthRt, TextureUsageBit::kAllFramebuffer, DepthStencilAspectBit::kDepth);
+			pass.newTextureDependency(gbufferDepthRt, TextureUsageBit::kAllRtvDsv, DepthStencilAspectBit::kDepth);
 			pass.newBufferDependency(visOut.m_dependency, BufferUsageBit::kIndirectDraw);
 
 			pass.setWork(
@@ -308,7 +308,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 
 			pass.setRenderpassInfo({}, &depthRti);
 
-			pass.newTextureDependency(shadowMapRt, TextureUsageBit::kAllFramebuffer, DepthStencilAspectBit::kDepth);
+			pass.newTextureDependency(shadowMapRt, TextureUsageBit::kAllRtvDsv, DepthStencilAspectBit::kDepth);
 			pass.newBufferDependency(shadowVisOut.m_dependency, BufferUsageBit::kIndirectDraw);
 
 			pass.setWork([this, shadowVisOut, cascadeViewProjMat, cascadeViewMat](RenderPassWorkContext& rgraphCtx) {
@@ -354,23 +354,23 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 			colorRti.m_loadOperation = RenderTargetLoadOperation::kClear;
 			pass.setRenderpassInfo({colorRti});
 
-			pass.newBufferDependency(lightVis.m_visiblesBufferHandle, BufferUsageBit::kStorageFragmentRead);
-			pass.newTextureDependency(probeTexture, TextureUsageBit::kFramebufferWrite, TextureSubresourceDesc::surface(0, f, 0));
+			pass.newBufferDependency(lightVis.m_visiblesBufferHandle, BufferUsageBit::kSrvFragment);
+			pass.newTextureDependency(probeTexture, TextureUsageBit::kRtvDsvWrite, TextureSubresourceDesc::surface(0, f, 0));
 
 			for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 			{
-				pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kSampledFragment, TextureSubresourceDesc::surface(0, f, 0));
+				pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kSrvFragment, TextureSubresourceDesc::surface(0, f, 0));
 			}
-			pass.newTextureDependency(gbufferDepthRt, TextureUsageBit::kSampledFragment, DepthStencilAspectBit::kDepth);
+			pass.newTextureDependency(gbufferDepthRt, TextureUsageBit::kSrvFragment, DepthStencilAspectBit::kDepth);
 
 			if(shadowMapRt.isValid())
 			{
-				pass.newTextureDependency(shadowMapRt, TextureUsageBit::kSampledFragment);
+				pass.newTextureDependency(shadowMapRt, TextureUsageBit::kSrvFragment);
 			}
 
 			if(getRenderer().getSky().isEnabled())
 			{
-				pass.newTextureDependency(getRenderer().getSky().getSkyLutRt(), TextureUsageBit::kSampledFragment);
+				pass.newTextureDependency(getRenderer().getSky().getSkyLutRt(), TextureUsageBit::kSrvFragment);
 			}
 
 			pass.setWork([this, visResult = lightVis.m_visiblesBuffer, viewProjMat = frustum.getViewProjectionMatrix(),
@@ -413,9 +413,9 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 	{
 		NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass("Cube refl: Irradiance");
 
-		pass.newTextureDependency(probeTexture, TextureUsageBit::kSampledCompute);
+		pass.newTextureDependency(probeTexture, TextureUsageBit::kSrvCompute);
 
-		pass.newBufferDependency(irradianceDiceValuesBuffHandle, BufferUsageBit::kStorageComputeWrite);
+		pass.newBufferDependency(irradianceDiceValuesBuffHandle, BufferUsageBit::kUavCompute);
 
 		pass.setWork([this, probeTexture](RenderPassWorkContext& rgraphCtx) {
 			ANKI_TRACE_SCOPED_EVENT(ProbeReflections);
@@ -440,12 +440,12 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 
 		for(U i = 0; i < kGBufferColorRenderTargetCount - 1; ++i)
 		{
-			pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kSampledCompute);
+			pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kSrvCompute);
 		}
 
-		pass.newTextureDependency(probeTexture, TextureUsageBit::kStorageComputeRead | TextureUsageBit::kStorageComputeWrite);
+		pass.newTextureDependency(probeTexture, TextureUsageBit::kUavCompute);
 
-		pass.newBufferDependency(irradianceDiceValuesBuffHandle, BufferUsageBit::kStorageComputeRead);
+		pass.newBufferDependency(irradianceDiceValuesBuffHandle, BufferUsageBit::kSrvCompute);
 
 		pass.setWork([this, gbufferColorRts, probeTexture](RenderPassWorkContext& rgraphCtx) {
 			ANKI_TRACE_SCOPED_EVENT(ProbeReflections);

AnKi/Renderer/Renderer.cpp

@@ -185,16 +185,16 @@ Error Renderer::initInternal(UVec2 swapchainResolution)
 	{
 		TextureInitInfo texinit("RendererDummy");
 		texinit.m_width = texinit.m_height = 4;
-		texinit.m_usage = TextureUsageBit::kAllSampled | TextureUsageBit::kStorageComputeWrite;
+		texinit.m_usage = TextureUsageBit::kAllSrv | TextureUsageBit::kUavCompute;
 		texinit.m_format = Format::kR8G8B8A8_Unorm;
-		m_dummyTex2d = createAndClearRenderTarget(texinit, TextureUsageBit::kAllSampled);
+		m_dummyTex2d = createAndClearRenderTarget(texinit, TextureUsageBit::kAllSrv);
 
 		texinit.m_depth = 4;
 		texinit.m_type = TextureType::k3D;
-		m_dummyTex3d = createAndClearRenderTarget(texinit, TextureUsageBit::kAllSampled);
+		m_dummyTex3d = createAndClearRenderTarget(texinit, TextureUsageBit::kAllSrv);
 
 		m_dummyBuff = GrManager::getSingleton().newBuffer(
-			BufferInitInfo(1024, BufferUsageBit::kAllUniform | BufferUsageBit::kAllStorage, BufferMapAccessBit::kNone, "Dummy"));
+			BufferInitInfo(1024, BufferUsageBit::kAllConstant | BufferUsageBit::kAllUav, BufferMapAccessBit::kNone, "Dummy"));
 	}
 
 	// Init the stages
@@ -418,7 +418,7 @@ void Renderer::finalize(const RenderingContext& ctx, Fence* fence)
 
 TextureInitInfo Renderer::create2DRenderTargetInitInfo(U32 w, U32 h, Format format, TextureUsageBit usage, CString name)
 {
-	ANKI_ASSERT(!!(usage & TextureUsageBit::kFramebufferWrite) || !!(usage & TextureUsageBit::kStorageComputeWrite));
+	ANKI_ASSERT(!!(usage & TextureUsageBit::kRtvDsvWrite) || !!(usage & TextureUsageBit::kUavCompute));
 	TextureInitInfo init(name);
 
 	init.m_width = w;
@@ -453,16 +453,16 @@ RenderTargetDesc Renderer::create2DRenderTargetDescription(U32 w, U32 h, Format
 
 TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, TextureUsageBit initialUsage, const ClearValue& clearVal)
 {
-	ANKI_ASSERT(!!(inf.m_usage & TextureUsageBit::kFramebufferWrite) || !!(inf.m_usage & TextureUsageBit::kStorageComputeWrite));
+	ANKI_ASSERT(!!(inf.m_usage & TextureUsageBit::kRtvDsvWrite) || !!(inf.m_usage & TextureUsageBit::kUavCompute));
 
 	const U faceCount = textureTypeIsCube(inf.m_type) ? 6 : 1;
 
 	Bool useCompute = false;
-	if(!!(inf.m_usage & TextureUsageBit::kFramebufferWrite))
+	if(!!(inf.m_usage & TextureUsageBit::kRtvDsvWrite))
 	{
 		useCompute = false;
 	}
-	else if(!!(inf.m_usage & TextureUsageBit::kStorageComputeWrite))
+	else if(!!(inf.m_usage & TextureUsageBit::kUavCompute))
 	{
 		useCompute = true;
 	}
@@ -514,7 +514,7 @@ TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, Text
 						rt.m_textureView = TextureView(tex.get(), TextureSubresourceDesc::surface(mip, face, layer));
 					}
 
-					TextureBarrierInfo barrier = {rt.m_textureView, TextureUsageBit::kNone, TextureUsageBit::kFramebufferWrite};
+					TextureBarrierInfo barrier = {rt.m_textureView, TextureUsageBit::kNone, TextureUsageBit::kRtvDsvWrite};
 					cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
 					if(getFormatInfo(inf.m_format).isDepthStencil())
@@ -529,7 +529,7 @@ TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, Text
 
 					if(!!initialUsage)
 					{
-						barrier.m_previousUsage = TextureUsageBit::kFramebufferWrite;
+						barrier.m_previousUsage = TextureUsageBit::kRtvDsvWrite;
 						barrier.m_nextUsage = initialUsage;
 						cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 					}
@@ -567,7 +567,7 @@ TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, Text
 
 					cmdb->bindTexture(ANKI_REG(u0), view);
 
-					const TextureBarrierInfo barrier = {view, TextureUsageBit::kNone, TextureUsageBit::kStorageComputeWrite};
+					const TextureBarrierInfo barrier = {view, TextureUsageBit::kNone, TextureUsageBit::kUavCompute};
 					cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
 					UVec3 wgSize;
@@ -579,7 +579,7 @@ TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, Text
 
 					if(!!initialUsage)
 					{
-						const TextureBarrierInfo barrier = {view, TextureUsageBit::kStorageComputeWrite, initialUsage};
+						const TextureBarrierInfo barrier = {view, TextureUsageBit::kUavCompute, initialUsage};
 
 						cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 					}
@@ -693,7 +693,7 @@ void Renderer::gpuSceneCopy(RenderingContext& ctx)
 	if(GpuSceneMicroPatcher::getSingleton().patchingIsNeeded())
 	{
 		NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("GPU scene patching");
-		rpass.newBufferDependency(m_runCtx.m_gpuSceneHandle, BufferUsageBit::kStorageComputeWrite);
+		rpass.newBufferDependency(m_runCtx.m_gpuSceneHandle, BufferUsageBit::kUavCompute);
 
 		rpass.setWork([](RenderPassWorkContext& rgraphCtx) {
 			GpuSceneMicroPatcher::getSingleton().patchGpuScene(*rgraphCtx.m_commandBuffer);

AnKi/Renderer/RtShadows.cpp

@@ -98,8 +98,8 @@ Error RtShadows::initInternal()
 	{
 		TextureInitInfo texinit = getRenderer().create2DRenderTargetInitInfo(
 			getRenderer().getInternalResolution().x() / 2, getRenderer().getInternalResolution().y() / 2, Format::kR8_Unorm,
-			TextureUsageBit::kAllSampled | TextureUsageBit::kStorageTraceRaysWrite | TextureUsageBit::kStorageComputeWrite, "RtShadows History");
-		m_historyRt = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
+			TextureUsageBit::kAllSrv | TextureUsageBit::kUavTraceRays | TextureUsageBit::kUavCompute, "RtShadows History");
+		m_historyRt = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvFragment);
 	}
 
 	// Temp shadow RT
@@ -113,11 +113,11 @@ Error RtShadows::initInternal()
 	{
 		TextureInitInfo texinit = getRenderer().create2DRenderTargetInitInfo(
 			getRenderer().getInternalResolution().x() / 2, getRenderer().getInternalResolution().y() / 2, Format::kR32G32_Sfloat,
-			TextureUsageBit::kAllSampled | TextureUsageBit::kStorageTraceRaysWrite | TextureUsageBit::kStorageComputeWrite, "RtShadows Moments #1");
-		m_momentsRts[0] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
+			TextureUsageBit::kAllSrv | TextureUsageBit::kUavTraceRays | TextureUsageBit::kUavCompute, "RtShadows Moments #1");
+		m_momentsRts[0] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvFragment);
 
 		texinit.setName("RtShadows Moments #2");
-		m_momentsRts[1] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
+		m_momentsRts[1] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvFragment);
 	}
 
 	// Variance RT
@@ -138,10 +138,10 @@ Error RtShadows::initInternal()
 	{
 		TextureInitInfo texinit = getRenderer().create2DRenderTargetInitInfo(
 			getRenderer().getInternalResolution().x() / 2, getRenderer().getInternalResolution().y() / 2, Format::kR32_Sfloat,
-			TextureUsageBit::kAllSampled | TextureUsageBit::kStorageTraceRaysWrite | TextureUsageBit::kStorageComputeWrite, "RtShadows history len");
+			TextureUsageBit::kAllSrv | TextureUsageBit::kUavTraceRays | TextureUsageBit::kUavCompute, "RtShadows history len");
 		ClearValue clear;
 		clear.m_colorf[0] = 1.0f;
-		m_dummyHistoryLenTex = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment, clear);
+		m_dummyHistoryLenTex = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvFragment, clear);
 	}
 
 	// Misc
@@ -155,7 +155,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 	ANKI_TRACE_SCOPED_EVENT(RtShadows);
 
 #define ANKI_DEPTH_DEP \
-	getRenderer().getDepthDownscale().getRt(), TextureUsageBit::kSampledTraceRays | TextureUsageBit::kSampledCompute, \
+	getRenderer().getDepthDownscale().getRt(), TextureUsageBit::kSrvTraceRays | TextureUsageBit::kSrvCompute, \
 		DepthDownscale::kQuarterInternalResolution
 
 	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
@@ -166,9 +166,9 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 
 		if(!m_rtsImportedOnce) [[unlikely]]
 		{
-			m_runCtx.m_historyRt = rgraph.importRenderTarget(m_historyRt.get(), TextureUsageBit::kSampledFragment);
+			m_runCtx.m_historyRt = rgraph.importRenderTarget(m_historyRt.get(), TextureUsageBit::kSrvFragment);
 
-			m_runCtx.m_prevMomentsRt = rgraph.importRenderTarget(m_momentsRts[prevRtIdx].get(), TextureUsageBit::kSampledFragment);
+			m_runCtx.m_prevMomentsRt = rgraph.importRenderTarget(m_momentsRts[prevRtIdx].get(), TextureUsageBit::kSrvFragment);
 
 			m_rtsImportedOnce = true;
 		}
@@ -209,7 +209,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 	BufferView sbtBuildIndirectArgsBuffer;
 	{
 		sbtBuildIndirectArgsBuffer = GpuVisibleTransientMemoryPool::getSingleton().allocateStructuredBuffer<DispatchIndirectArgs>(1);
-		sbtBuildIndirectArgsHandle = rgraph.importBuffer(sbtBuildIndirectArgsBuffer, BufferUsageBit::kStorageComputeWrite);
+		sbtBuildIndirectArgsHandle = rgraph.importBuffer(sbtBuildIndirectArgsBuffer, BufferUsageBit::kUavCompute);
 
 		NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("RtShadows setup build SBT");
 
@@ -236,7 +236,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 		U8* sbtMem;
 		sbtBuffer = RebarTransientMemoryPool::getSingleton().allocateFrame(
 			(GpuSceneArrays::RenderableBoundingVolumeRt::getSingleton().getElementCount() + 2) * m_sbtRecordSize, sbtMem);
-		sbtHandle = rgraph.importBuffer(sbtBuffer, BufferUsageBit::kStorageComputeWrite);
+		sbtHandle = rgraph.importBuffer(sbtBuffer, BufferUsageBit::kUavCompute);
 
 		// Write the first 2 entries of the SBT
 		ConstWeakArray<U8> shaderGroupHandles = m_rtLibraryGrProg->getShaderGroupHandles();
@@ -251,7 +251,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 		BufferView visibleRenderableIndicesBuff;
 		getRenderer().getAccelerationStructureBuilder().getVisibilityInfo(visibilityHandle, visibleRenderableIndicesBuff);
 
-		rpass.newBufferDependency(visibilityHandle, BufferUsageBit::kStorageComputeRead);
+		rpass.newBufferDependency(visibilityHandle, BufferUsageBit::kSrvCompute);
 		rpass.newBufferDependency(sbtBuildIndirectArgsHandle, BufferUsageBit::kIndirectCompute);
 
 		rpass.setWork([this, sbtBuildIndirectArgsBuffer, sbtBuffer, visibleRenderableIndicesBuff](RenderPassWorkContext& rgraphCtx) {
@@ -282,18 +282,18 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 	{
 		NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("RtShadows");
 
-		rpass.newTextureDependency(m_runCtx.m_historyRt, TextureUsageBit::kSampledTraceRays);
-		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[0], TextureUsageBit::kStorageTraceRaysWrite);
+		rpass.newTextureDependency(m_runCtx.m_historyRt, TextureUsageBit::kSrvTraceRays);
+		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[0], TextureUsageBit::kUavTraceRays);
 		rpass.newAccelerationStructureDependency(getRenderer().getAccelerationStructureBuilder().getAccelerationStructureHandle(),
 												 AccelerationStructureUsageBit::kTraceRaysRead);
 		rpass.newTextureDependency(ANKI_DEPTH_DEP);
-		rpass.newTextureDependency(getRenderer().getMotionVectors().getMotionVectorsRt(), TextureUsageBit::kSampledTraceRays);
-		rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(2), TextureUsageBit::kSampledTraceRays);
+		rpass.newTextureDependency(getRenderer().getMotionVectors().getMotionVectorsRt(), TextureUsageBit::kSrvTraceRays);
+		rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(2), TextureUsageBit::kSrvTraceRays);
 
-		rpass.newTextureDependency(m_runCtx.m_prevMomentsRt, TextureUsageBit::kSampledTraceRays);
-		rpass.newTextureDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kStorageTraceRaysWrite);
+		rpass.newTextureDependency(m_runCtx.m_prevMomentsRt, TextureUsageBit::kSrvTraceRays);
+		rpass.newTextureDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kUavTraceRays);
 
-		rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kStorageTraceRaysRead);
+		rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kSrvTraceRays);
 
 		rpass.setWork([this, sbtBuffer, &ctx](RenderPassWorkContext& rgraphCtx) {
 			ANKI_TRACE_SCOPED_EVENT(RtShadows);
@@ -354,12 +354,12 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 			runDenoise(ctx, rgraphCtx, true);
 		});
 
-		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[0], TextureUsageBit::kSampledCompute);
+		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[0], TextureUsageBit::kSrvCompute);
 		rpass.newTextureDependency(ANKI_DEPTH_DEP);
-		rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(2), TextureUsageBit::kSampledCompute);
-		rpass.newTextureDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kSampledCompute);
+		rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(2), TextureUsageBit::kSrvCompute);
+		rpass.newTextureDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kSrvCompute);
 
-		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[1], TextureUsageBit::kStorageComputeWrite);
+		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[1], TextureUsageBit::kUavCompute);
 	}
 
 	// Denoise pass vertical
@@ -370,12 +370,12 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 			runDenoise(ctx, rgraphCtx, false);
 		});
 
-		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[1], TextureUsageBit::kSampledCompute);
+		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[1], TextureUsageBit::kSrvCompute);
 		rpass.newTextureDependency(ANKI_DEPTH_DEP);
-		rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(2), TextureUsageBit::kSampledCompute);
-		rpass.newTextureDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kSampledCompute);
+		rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(2), TextureUsageBit::kSrvCompute);
+		rpass.newTextureDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kSrvCompute);
 
-		rpass.newTextureDependency(m_runCtx.m_historyRt, TextureUsageBit::kStorageComputeWrite);
+		rpass.newTextureDependency(m_runCtx.m_historyRt, TextureUsageBit::kUavCompute);
 	}
 
 	// Variance calculation pass
@@ -383,13 +383,13 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 	{
 		NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("RtShadows SVGF Variance");
 
-		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[0], TextureUsageBit::kSampledCompute);
-		rpass.newTextureDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kSampledCompute);
+		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[0], TextureUsageBit::kSrvCompute);
+		rpass.newTextureDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kSrvCompute);
 		rpass.newTextureDependency(ANKI_DEPTH_DEP);
-		rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(2), TextureUsageBit::kSampledCompute);
+		rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(2), TextureUsageBit::kSrvCompute);
 
-		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[1], TextureUsageBit::kStorageComputeWrite);
-		rpass.newTextureDependency(m_runCtx.m_varianceRts[1], TextureUsageBit::kStorageComputeWrite);
+		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[1], TextureUsageBit::kUavCompute);
+		rpass.newTextureDependency(m_runCtx.m_varianceRts[1], TextureUsageBit::kUavCompute);
 
 		rpass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
 			ANKI_TRACE_SCOPED_EVENT(RtShadows);
@@ -425,19 +425,19 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 			NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("RtShadows SVGF Atrous");
 
 			rpass.newTextureDependency(ANKI_DEPTH_DEP);
-			rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(2), TextureUsageBit::kSampledCompute);
-			rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[readRtIdx], TextureUsageBit::kSampledCompute);
-			rpass.newTextureDependency(m_runCtx.m_varianceRts[readRtIdx], TextureUsageBit::kSampledCompute);
+			rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(2), TextureUsageBit::kSrvCompute);
+			rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[readRtIdx], TextureUsageBit::kSrvCompute);
+			rpass.newTextureDependency(m_runCtx.m_varianceRts[readRtIdx], TextureUsageBit::kSrvCompute);
 
 			if(!lastPass)
 			{
-				rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[!readRtIdx], TextureUsageBit::kStorageComputeWrite);
+				rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[!readRtIdx], TextureUsageBit::kUavCompute);
 
-				rpass.newTextureDependency(m_runCtx.m_varianceRts[!readRtIdx], TextureUsageBit::kStorageComputeWrite);
+				rpass.newTextureDependency(m_runCtx.m_varianceRts[!readRtIdx], TextureUsageBit::kUavCompute);
 			}
 			else
 			{
-				rpass.newTextureDependency(m_runCtx.m_historyRt, TextureUsageBit::kStorageComputeWrite);
+				rpass.newTextureDependency(m_runCtx.m_historyRt, TextureUsageBit::kUavCompute);
 			}
 
 			rpass.setWork([this, &ctx, passIdx = i](RenderPassWorkContext& rgraphCtx) {
@@ -484,11 +484,11 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 	{
 		NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("RtShadows Upscale");
 
-		rpass.newTextureDependency(m_runCtx.m_historyRt, TextureUsageBit::kSampledCompute);
-		rpass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSampledCompute);
+		rpass.newTextureDependency(m_runCtx.m_historyRt, TextureUsageBit::kSrvCompute);
+		rpass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSrvCompute);
 		rpass.newTextureDependency(ANKI_DEPTH_DEP);
 
-		rpass.newTextureDependency(m_runCtx.m_upscaledRt, TextureUsageBit::kStorageComputeWrite);
+		rpass.newTextureDependency(m_runCtx.m_upscaledRt, TextureUsageBit::kUavCompute);
 
 		rpass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 			ANKI_TRACE_SCOPED_EVENT(RtShadows);

AnKi/Renderer/Scale.cpp

@@ -167,8 +167,8 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		NonGraphicsRenderPass& pass = ctx.m_renderGraphDescr.newNonGraphicsRenderPass("DLSS");
 
 		// DLSS says input textures in sampled state and out as storage image
-		const TextureUsageBit readUsage = TextureUsageBit::kAllSampled & TextureUsageBit::kAllCompute;
-		const TextureUsageBit writeUsage = TextureUsageBit::kAllStorage & TextureUsageBit::kAllCompute;
+		const TextureUsageBit readUsage = TextureUsageBit::kAllSrv & TextureUsageBit::kAllCompute;
+		const TextureUsageBit writeUsage = TextureUsageBit::kAllUav & TextureUsageBit::kAllCompute;
 
 		pass.newTextureDependency(getRenderer().getLightShading().getRt(), readUsage);
 		pass.newTextureDependency(getRenderer().getMotionVectors().getMotionVectorsRt(), readUsage);
@@ -190,8 +190,8 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		if(preferCompute)
 		{
 			NonGraphicsRenderPass& pass = ctx.m_renderGraphDescr.newNonGraphicsRenderPass("Scale");
-			pass.newTextureDependency(inRt, TextureUsageBit::kSampledCompute);
-			pass.newTextureDependency(outRt, TextureUsageBit::kStorageComputeWrite);
+			pass.newTextureDependency(inRt, TextureUsageBit::kSrvCompute);
+			pass.newTextureDependency(outRt, TextureUsageBit::kUavCompute);
 
 			pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 				runFsrOrBilinearScaling(rgraphCtx);
@@ -201,8 +201,8 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		{
 			GraphicsRenderPass& pass = ctx.m_renderGraphDescr.newGraphicsRenderPass("Scale");
 			pass.setRenderpassInfo({GraphicsRenderPassTargetDesc(outRt)});
-			pass.newTextureDependency(inRt, TextureUsageBit::kSampledFragment);
-			pass.newTextureDependency(outRt, TextureUsageBit::kFramebufferWrite);
+			pass.newTextureDependency(inRt, TextureUsageBit::kSrvFragment);
+			pass.newTextureDependency(outRt, TextureUsageBit::kRtvDsvWrite);
 
 			pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 				runFsrOrBilinearScaling(rgraphCtx);
@@ -227,8 +227,8 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		if(preferCompute)
 		{
 			NonGraphicsRenderPass& pass = ctx.m_renderGraphDescr.newNonGraphicsRenderPass("Tonemap");
-			pass.newTextureDependency(inRt, TextureUsageBit::kSampledCompute);
-			pass.newTextureDependency(outRt, TextureUsageBit::kStorageComputeWrite);
+			pass.newTextureDependency(inRt, TextureUsageBit::kSrvCompute);
+			pass.newTextureDependency(outRt, TextureUsageBit::kUavCompute);
 
 			pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 				runTonemapping(rgraphCtx);
@@ -238,8 +238,8 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		{
 			GraphicsRenderPass& pass = ctx.m_renderGraphDescr.newGraphicsRenderPass("Sharpen");
 			pass.setRenderpassInfo({GraphicsRenderPassTargetDesc(outRt)});
-			pass.newTextureDependency(inRt, TextureUsageBit::kSampledFragment);
-			pass.newTextureDependency(outRt, TextureUsageBit::kFramebufferWrite);
+			pass.newTextureDependency(inRt, TextureUsageBit::kSrvFragment);
+			pass.newTextureDependency(outRt, TextureUsageBit::kRtvDsvWrite);
 
 			pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 				runTonemapping(rgraphCtx);
@@ -261,8 +261,8 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		if(preferCompute)
 		{
 			NonGraphicsRenderPass& pass = ctx.m_renderGraphDescr.newNonGraphicsRenderPass("Sharpen");
-			pass.newTextureDependency(inRt, TextureUsageBit::kSampledCompute);
-			pass.newTextureDependency(outRt, TextureUsageBit::kStorageComputeWrite);
+			pass.newTextureDependency(inRt, TextureUsageBit::kSrvCompute);
+			pass.newTextureDependency(outRt, TextureUsageBit::kUavCompute);
 
 			pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 				runRcasSharpening(rgraphCtx);
@@ -272,8 +272,8 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		{
 			GraphicsRenderPass& pass = ctx.m_renderGraphDescr.newGraphicsRenderPass("Sharpen");
 			pass.setRenderpassInfo({GraphicsRenderPassTargetDesc(outRt)});
-			pass.newTextureDependency(inRt, TextureUsageBit::kSampledFragment);
-			pass.newTextureDependency(outRt, TextureUsageBit::kFramebufferWrite);
+			pass.newTextureDependency(inRt, TextureUsageBit::kSrvFragment);
+			pass.newTextureDependency(outRt, TextureUsageBit::kRtvDsvWrite);
 
 			pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 				runRcasSharpening(rgraphCtx);

AnKi/Renderer/ShadowMapping.cpp

@@ -88,12 +88,12 @@ Error ShadowMapping::initInternal()
 					m_tileResolution * m_tileCountBothAxis);
 
 		// RT
-		const TextureUsageBit usage = TextureUsageBit::kSampledFragment | TextureUsageBit::kSampledCompute | TextureUsageBit::kAllFramebuffer;
+		const TextureUsageBit usage = TextureUsageBit::kSrvFragment | TextureUsageBit::kSrvCompute | TextureUsageBit::kAllRtvDsv;
 		TextureInitInfo texinit = getRenderer().create2DRenderTargetInitInfo(
 			m_tileResolution * m_tileCountBothAxis, m_tileResolution * m_tileCountBothAxis, Format::kD16_Unorm, usage, "ShadowAtlas");
 		ClearValue clearVal;
 		clearVal.m_colorf[0] = 1.0f;
-		m_atlasTex = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment, clearVal);
+		m_atlasTex = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvFragment, clearVal);
 	}
 
 	// Tiles
@@ -154,7 +154,7 @@ void ShadowMapping::populateRenderGraph(RenderingContext& ctx)
 	}
 	else
 	{
-		m_runCtx.m_rt = rgraph.importRenderTarget(m_atlasTex.get(), TextureUsageBit::kSampledFragment);
+		m_runCtx.m_rt = rgraph.importRenderTarget(m_atlasTex.get(), TextureUsageBit::kSrvFragment);
 		m_rtImportedOnce = true;
 	}
 
@@ -544,7 +544,7 @@ BufferView ShadowMapping::createVetVisibilityPass(CString passName, const LightC
 	NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass(passName);
 
 	// The shader doesn't actually write to the handle but have it as a write dependency for the drawer to correctly wait for this pass
-	pass.newBufferDependency(visOut.m_dependency, BufferUsageBit::kStorageComputeWrite);
+	pass.newBufferDependency(visOut.m_dependency, BufferUsageBit::kUavCompute);
 
 	pass.setWork([this, &lightc, hashBuff = visOut.m_visiblesHashBuffer, mdiBuff = visOut.m_legacy.m_mdiDrawCountsBuffer, clearTileIndirectArgs,
 				  dispatchMeshIndirectArgs = visOut.m_mesh.m_dispatchMeshIndirectArgsBuffer,
@@ -628,7 +628,7 @@ void ShadowMapping::createDrawShadowsPass(ConstWeakArray<ShadowSubpassInfo> subp
 	pass.setRenderpassInfo({}, &smRti, viewport[0], viewport[1], viewport[2], viewport[3]);
 
 	pass.newBufferDependency(visOut.m_dependency, BufferUsageBit::kIndirectDraw);
-	pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite);
+	pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kRtvDsvWrite);
 
 	pass.setWork([this, visOut, subpasses, loadFb](RenderPassWorkContext& rgraphCtx) {
 		ANKI_TRACE_SCOPED_EVENT(ShadowMapping);

AnKi/Renderer/ShadowmapsResolve.cpp

@@ -64,18 +64,18 @@ void ShadowmapsResolve::populateRenderGraph(RenderingContext& ctx)
 			run(rgraphCtx, ctx);
 		});
 
-		rpass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kStorageComputeWrite);
+		rpass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kUavCompute);
 		rpass.newTextureDependency((m_quarterRez) ? getRenderer().getDepthDownscale().getRt() : getRenderer().getGBuffer().getDepthRt(),
-								   TextureUsageBit::kSampledCompute);
-		rpass.newTextureDependency(getRenderer().getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledCompute);
+								   TextureUsageBit::kSrvCompute);
+		rpass.newTextureDependency(getRenderer().getShadowMapping().getShadowmapRt(), TextureUsageBit::kSrvCompute);
 
-		rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kStorageComputeRead);
+		rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kSrvCompute);
 		rpass.newBufferDependency(getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kLight),
-								  BufferUsageBit::kStorageComputeRead);
+								  BufferUsageBit::kSrvCompute);
 
 		if(getRenderer().getRtShadowsEnabled())
 		{
-			rpass.newTextureDependency(getRenderer().getRtShadows().getRt(), TextureUsageBit::kSampledCompute);
+			rpass.newTextureDependency(getRenderer().getRtShadows().getRt(), TextureUsageBit::kSrvCompute);
 		}
 	}
 	else
@@ -88,18 +88,18 @@ void ShadowmapsResolve::populateRenderGraph(RenderingContext& ctx)
 			run(rgraphCtx, ctx);
 		});
 
-		rpass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite);
+		rpass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kRtvDsvWrite);
 		rpass.newTextureDependency((m_quarterRez) ? getRenderer().getDepthDownscale().getRt() : getRenderer().getGBuffer().getDepthRt(),
-								   TextureUsageBit::kSampledFragment);
-		rpass.newTextureDependency(getRenderer().getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledFragment);
+								   TextureUsageBit::kSrvFragment);
+		rpass.newTextureDependency(getRenderer().getShadowMapping().getShadowmapRt(), TextureUsageBit::kSrvFragment);
 
-		rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kStorageFragmentRead);
+		rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kSrvFragment);
 		rpass.newBufferDependency(getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kLight),
-								  BufferUsageBit::kStorageFragmentRead);
+								  BufferUsageBit::kSrvFragment);
 
 		if(getRenderer().getRtShadowsEnabled())
 		{
-			rpass.newTextureDependency(getRenderer().getRtShadows().getRt(), TextureUsageBit::kSampledFragment);
+			rpass.newTextureDependency(getRenderer().getRtShadows().getRt(), TextureUsageBit::kSrvFragment);
 		}
 	}
 }

AnKi/Renderer/Sky.cpp

@@ -32,7 +32,7 @@ Error Sky::initInternal()
 	ANKI_CHECK(loadShaderProgram("ShaderBinaries/Sky.ankiprogbin", {}, m_prog, m_computeSunColorGrProg, "ComputeSunColor"));
 
 	const TextureUsageBit usage = TextureUsageBit::kAllCompute;
-	const TextureUsageBit initialUsage = TextureUsageBit::kSampledCompute;
+	const TextureUsageBit initialUsage = TextureUsageBit::kSrvCompute;
 	const Format formatB =
 		(GrManager::getSingleton().getDeviceCapabilities().m_unalignedBbpTextureFormats) ? Format::kR16G16B16_Unorm : Format::kR16G16B16A16_Unorm;
 
@@ -46,7 +46,7 @@ Error Sky::initInternal()
 		initialUsage);
 
 	m_skyLut = getRenderer().createAndClearRenderTarget(
-		getRenderer().create2DRenderTargetInitInfo(kSkyLutSize.x(), kSkyLutSize.y(), formatB, usage | TextureUsageBit::kSampledFragment, "SkyLut"),
+		getRenderer().create2DRenderTargetInitInfo(kSkyLutSize.x(), kSkyLutSize.y(), formatB, usage | TextureUsageBit::kSrvFragment, "SkyLut"),
 		initialUsage);
 
 	return Error::kNone;
@@ -78,14 +78,14 @@ void Sky::populateRenderGraph(RenderingContext& ctx)
 	RenderTargetHandle multipleScatteringLutRt;
 	if(renderTransAndMultiScatLuts)
 	{
-		transmittanceLutRt = rgraph.importRenderTarget(m_transmittanceLut.get(), TextureUsageBit::kSampledCompute);
-		multipleScatteringLutRt = rgraph.importRenderTarget(m_multipleScatteringLut.get(), TextureUsageBit::kSampledCompute);
+		transmittanceLutRt = rgraph.importRenderTarget(m_transmittanceLut.get(), TextureUsageBit::kSrvCompute);
+		multipleScatteringLutRt = rgraph.importRenderTarget(m_multipleScatteringLut.get(), TextureUsageBit::kSrvCompute);
 		m_transmittanceAndMultiScatterLutsGenerated = true;
 	}
 	else
 	{
-		transmittanceLutRt = rgraph.importRenderTarget(m_transmittanceLut.get(), TextureUsageBit::kSampledCompute);
-		multipleScatteringLutRt = rgraph.importRenderTarget(m_multipleScatteringLut.get(), TextureUsageBit::kSampledCompute);
+		transmittanceLutRt = rgraph.importRenderTarget(m_transmittanceLut.get(), TextureUsageBit::kSrvCompute);
+		multipleScatteringLutRt = rgraph.importRenderTarget(m_multipleScatteringLut.get(), TextureUsageBit::kSrvCompute);
 	}
 
 	if(m_skyLutImportedOnce) [[likely]]
@@ -94,7 +94,7 @@ void Sky::populateRenderGraph(RenderingContext& ctx)
 	}
 	else
 	{
-		m_runCtx.m_skyLutRt = rgraph.importRenderTarget(m_skyLut.get(), TextureUsageBit::kSampledCompute);
+		m_runCtx.m_skyLutRt = rgraph.importRenderTarget(m_skyLut.get(), TextureUsageBit::kSrvCompute);
 		m_skyLutImportedOnce = true;
 	}
 
@@ -103,7 +103,7 @@ void Sky::populateRenderGraph(RenderingContext& ctx)
 	{
 		NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("SkyTransmittanceLut");
 
-		rpass.newTextureDependency(transmittanceLutRt, TextureUsageBit::kStorageComputeWrite);
+		rpass.newTextureDependency(transmittanceLutRt, TextureUsageBit::kUavCompute);
 
 		rpass.setWork([this, transmittanceLutRt](RenderPassWorkContext& rgraphCtx) {
 			ANKI_TRACE_SCOPED_EVENT(SkyTransmittanceLut);
@@ -123,8 +123,8 @@ void Sky::populateRenderGraph(RenderingContext& ctx)
 	{
 		NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("SkyMultipleScatteringLut");
 
-		rpass.newTextureDependency(transmittanceLutRt, TextureUsageBit::kSampledCompute);
-		rpass.newTextureDependency(multipleScatteringLutRt, TextureUsageBit::kStorageComputeWrite);
+		rpass.newTextureDependency(transmittanceLutRt, TextureUsageBit::kSrvCompute);
+		rpass.newTextureDependency(multipleScatteringLutRt, TextureUsageBit::kUavCompute);
 
 		rpass.setWork([this, transmittanceLutRt, multipleScatteringLutRt](RenderPassWorkContext& rgraphCtx) {
 			ANKI_TRACE_SCOPED_EVENT(SkyMultipleScatteringLut);
@@ -146,9 +146,9 @@ void Sky::populateRenderGraph(RenderingContext& ctx)
 	{
 		NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("SkyLut");
 
-		rpass.newTextureDependency(transmittanceLutRt, TextureUsageBit::kSampledCompute);
-		rpass.newTextureDependency(multipleScatteringLutRt, TextureUsageBit::kSampledCompute);
-		rpass.newTextureDependency(m_runCtx.m_skyLutRt, TextureUsageBit::kStorageComputeWrite);
+		rpass.newTextureDependency(transmittanceLutRt, TextureUsageBit::kSrvCompute);
+		rpass.newTextureDependency(multipleScatteringLutRt, TextureUsageBit::kSrvCompute);
+		rpass.newTextureDependency(m_runCtx.m_skyLutRt, TextureUsageBit::kUavCompute);
 
 		rpass.setWork([this, transmittanceLutRt, multipleScatteringLutRt, &ctx](RenderPassWorkContext& rgraphCtx) {
 			ANKI_TRACE_SCOPED_EVENT(SkyLut);
@@ -171,7 +171,7 @@ void Sky::populateRenderGraph(RenderingContext& ctx)
 	{
 		NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("ComputeSunColor");
 
-		rpass.newTextureDependency(transmittanceLutRt, TextureUsageBit::kSampledCompute);
+		rpass.newTextureDependency(transmittanceLutRt, TextureUsageBit::kSrvCompute);
 
 		rpass.setWork([this, transmittanceLutRt, &ctx](RenderPassWorkContext& rgraphCtx) {
 			ANKI_TRACE_SCOPED_EVENT(ComputeSunColor);

AnKi/Renderer/Ssao.cpp

@@ -38,14 +38,14 @@ Error Ssao::initInternal()
 	const Bool preferCompute = g_preferComputeCVar.get();
 
 	{
-		TextureUsageBit usage = TextureUsageBit::kAllSampled;
-		usage |= (preferCompute) ? TextureUsageBit::kStorageComputeWrite : TextureUsageBit::kFramebufferWrite;
+		TextureUsageBit usage = TextureUsageBit::kAllSrv;
+		usage |= (preferCompute) ? TextureUsageBit::kUavCompute : TextureUsageBit::kRtvDsvWrite;
 		TextureInitInfo texInit =
 			getRenderer().create2DRenderTargetInitInfo(rez.x(), rez.y(), Format::kR8G8B8A8_Snorm, usage, "Bent normals + SSAO #1");
-		m_tex[0] = getRenderer().createAndClearRenderTarget(texInit, TextureUsageBit::kAllSampled);
+		m_tex[0] = getRenderer().createAndClearRenderTarget(texInit, TextureUsageBit::kAllSrv);
 
 		texInit.setName("Bent normals + SSAO #2");
-		m_tex[1] = getRenderer().createAndClearRenderTarget(texInit, TextureUsageBit::kAllSampled);
+		m_tex[1] = getRenderer().createAndClearRenderTarget(texInit, TextureUsageBit::kAllSrv);
 	}
 
 	m_bentNormalsAndSsaoRtDescr =
@@ -83,8 +83,8 @@ void Ssao::populateRenderGraph(RenderingContext& ctx)
 	}
 	else
 	{
-		finalRt = rgraph.importRenderTarget(m_tex[writeRtIdx].get(), TextureUsageBit::kAllSampled);
-		historyRt = rgraph.importRenderTarget(m_tex[readRtIdx].get(), TextureUsageBit::kAllSampled);
+		finalRt = rgraph.importRenderTarget(m_tex[writeRtIdx].get(), TextureUsageBit::kAllSrv);
+		historyRt = rgraph.importRenderTarget(m_tex[readRtIdx].get(), TextureUsageBit::kAllSrv);
 		m_texImportedOnce = true;
 	}
 
@@ -96,13 +96,13 @@ void Ssao::populateRenderGraph(RenderingContext& ctx)
 	TextureUsageBit writeUsage;
 	if(preferCompute)
 	{
-		readUsage = TextureUsageBit::kSampledCompute;
-		writeUsage = TextureUsageBit::kStorageComputeWrite;
+		readUsage = TextureUsageBit::kSrvCompute;
+		writeUsage = TextureUsageBit::kUavCompute;
 	}
 	else
 	{
-		readUsage = TextureUsageBit::kSampledFragment;
-		writeUsage = TextureUsageBit::kFramebufferWrite;
+		readUsage = TextureUsageBit::kSrvFragment;
+		writeUsage = TextureUsageBit::kRtvDsvWrite;
 	}
 
 	// Main pass

AnKi/Renderer/Ssr.cpp

@@ -51,14 +51,14 @@ Error Ssr::initInternal()
 
 	ANKI_R_LOGV("Initializing SSR. Resolution %ux%u", rez.x(), rez.y());
 
-	TextureUsageBit mipTexUsage = TextureUsageBit::kAllSampled;
+	TextureUsageBit mipTexUsage = TextureUsageBit::kAllSrv;
 	if(g_preferComputeCVar.get())
 	{
-		mipTexUsage |= TextureUsageBit::kStorageComputeWrite;
+		mipTexUsage |= TextureUsageBit::kUavCompute;
 	}
 	else
 	{
-		mipTexUsage |= TextureUsageBit::kFramebufferWrite;
+		mipTexUsage |= TextureUsageBit::kRtvDsvWrite;
 	}
 
 	m_ssrRtDescr = getRenderer().create2DRenderTargetDescription(rez.x(), rez.y(), Format::kR16G16B16A16_Sfloat, "SSR");
@@ -86,8 +86,8 @@ void Ssr::populateRenderGraph(RenderingContext& ctx)
 		NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass("SSR");
 		ppass = &pass;
 
-		readUsage = TextureUsageBit::kSampledCompute;
-		writeUsage = TextureUsageBit::kStorageComputeWrite;
+		readUsage = TextureUsageBit::kSrvCompute;
+		writeUsage = TextureUsageBit::kUavCompute;
 	}
 	else
 	{
@@ -98,8 +98,8 @@ void Ssr::populateRenderGraph(RenderingContext& ctx)
 
 		ppass = &pass;
 
-		readUsage = TextureUsageBit::kSampledFragment;
-		writeUsage = TextureUsageBit::kFramebufferWrite;
+		readUsage = TextureUsageBit::kSrvFragment;
+		writeUsage = TextureUsageBit::kRtvDsvWrite;
 	}
 
 	ppass->newTextureDependency(getRenderer().getDownscaleBlur().getRt(), readUsage);

AnKi/Renderer/TemporalAA.cpp

@@ -33,14 +33,14 @@ Error TemporalAA::initInternal()
 
 	for(U32 i = 0; i < 2; ++i)
 	{
-		TextureUsageBit usage = TextureUsageBit::kSampledFragment | TextureUsageBit::kSampledCompute;
-		usage |= (g_preferComputeCVar.get()) ? TextureUsageBit::kStorageComputeWrite : TextureUsageBit::kFramebufferWrite;
+		TextureUsageBit usage = TextureUsageBit::kSrvFragment | TextureUsageBit::kSrvCompute;
+		usage |= (g_preferComputeCVar.get()) ? TextureUsageBit::kUavCompute : TextureUsageBit::kRtvDsvWrite;
 
 		TextureInitInfo texinit =
 			getRenderer().create2DRenderTargetInitInfo(getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y(),
 													   getRenderer().getHdrFormat(), usage, String().sprintf("TemporalAA #%u", i).cstr());
 
-		m_rtTextures[i] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
+		m_rtTextures[i] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvFragment);
 	}
 
 	m_tonemappedRtDescr = getRenderer().create2DRenderTargetDescription(
@@ -68,7 +68,7 @@ void TemporalAA::populateRenderGraph(RenderingContext& ctx)
 	}
 	else
 	{
-		m_runCtx.m_historyRt = rgraph.importRenderTarget(m_rtTextures[historyRtIdx].get(), TextureUsageBit::kSampledFragment);
+		m_runCtx.m_historyRt = rgraph.importRenderTarget(m_rtTextures[historyRtIdx].get(), TextureUsageBit::kSrvFragment);
 		m_rtTexturesImportedOnce = true;
 	}
 
@@ -82,10 +82,10 @@ void TemporalAA::populateRenderGraph(RenderingContext& ctx)
 	{
 		NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass("TemporalAA");
 
-		pass.newTextureDependency(m_runCtx.m_renderRt, TextureUsageBit::kStorageComputeWrite);
-		pass.newTextureDependency(m_runCtx.m_tonemappedRt, TextureUsageBit::kStorageComputeWrite);
+		pass.newTextureDependency(m_runCtx.m_renderRt, TextureUsageBit::kUavCompute);
+		pass.newTextureDependency(m_runCtx.m_tonemappedRt, TextureUsageBit::kUavCompute);
 
-		readUsage = TextureUsageBit::kSampledCompute;
+		readUsage = TextureUsageBit::kSrvCompute;
 
 		prpass = &pass;
 	}
@@ -94,10 +94,10 @@ void TemporalAA::populateRenderGraph(RenderingContext& ctx)
 		GraphicsRenderPass& pass = rgraph.newGraphicsRenderPass("TemporalAA");
 		pass.setRenderpassInfo({GraphicsRenderPassTargetDesc(m_runCtx.m_renderRt), GraphicsRenderPassTargetDesc(m_runCtx.m_tonemappedRt)});
 
-		pass.newTextureDependency(m_runCtx.m_renderRt, TextureUsageBit::kFramebufferWrite);
-		pass.newTextureDependency(m_runCtx.m_tonemappedRt, TextureUsageBit::kFramebufferWrite);
+		pass.newTextureDependency(m_runCtx.m_renderRt, TextureUsageBit::kRtvDsvWrite);
+		pass.newTextureDependency(m_runCtx.m_tonemappedRt, TextureUsageBit::kRtvDsvWrite);
 
-		readUsage = TextureUsageBit::kSampledFragment;
+		readUsage = TextureUsageBit::kSrvFragment;
 
 		prpass = &pass;
 	}

AnKi/Renderer/Tonemapping.cpp

@@ -34,11 +34,11 @@ Error Tonemapping::initInternal()
 
 	// Create exposure texture.
 	// WARNING: Use it only as IMAGE and nothing else. It will not be tracked by the rendergraph. No tracking means no automatic image transitions
-	const TextureUsageBit usage = TextureUsageBit::kAllStorage;
+	const TextureUsageBit usage = TextureUsageBit::kAllUav;
 	const TextureInitInfo texinit = getRenderer().create2DRenderTargetInitInfo(1, 1, Format::kR16G16_Sfloat, usage, "ExposureAndAvgLum1x1");
 	ClearValue clearValue;
 	clearValue.m_colorf = {0.5f, 0.5f, 0.5f, 0.5f};
-	m_exposureAndAvgLuminance1x1 = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kStorageComputeRead, clearValue);
+	m_exposureAndAvgLuminance1x1 = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kUavCompute, clearValue);
 
 	return Error::kNone;
 }
@@ -46,8 +46,7 @@ Error Tonemapping::initInternal()
 void Tonemapping::importRenderTargets(RenderingContext& ctx)
 {
 	// Just import it. It will not be used in resource tracking
-	m_runCtx.m_exposureLuminanceHandle =
-		ctx.m_renderGraphDescr.importRenderTarget(m_exposureAndAvgLuminance1x1.get(), TextureUsageBit::kStorageComputeRead);
+	m_runCtx.m_exposureLuminanceHandle = ctx.m_renderGraphDescr.importRenderTarget(m_exposureAndAvgLuminance1x1.get(), TextureUsageBit::kUavCompute);
 }
 
 void Tonemapping::populateRenderGraph(RenderingContext& ctx)
@@ -69,7 +68,7 @@ void Tonemapping::populateRenderGraph(RenderingContext& ctx)
 		cmdb.dispatchCompute(1, 1, 1);
 	});
 
-	pass.newTextureDependency(getRenderer().getDownscaleBlur().getRt(), TextureUsageBit::kSampledCompute,
+	pass.newTextureDependency(getRenderer().getDownscaleBlur().getRt(), TextureUsageBit::kSrvCompute,
 							  TextureSubresourceDesc::surface(m_inputTexMip, 0, 0));
 }
 

AnKi/Renderer/Utils/GpuVisibility.cpp

@@ -547,7 +547,7 @@ void GpuVisibility::populateRenderGraphInternal(Bool distanceBased, BaseGpuVisib
 	const BufferHandle zeroMemDep = rgraph.importBuffer(stage1Mem.m_counters, BufferUsageBit::kNone);
 	{
 		NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass(generateTempPassName("GPU vis zero: %s", in.m_passesName.cstr()));
-		pass.newBufferDependency(zeroMemDep, BufferUsageBit::kTransferDestination);
+		pass.newBufferDependency(zeroMemDep, BufferUsageBit::kCopyDestination);
 
 		pass.setWork([stage1Mem, stage2Mem, stage3Mem, this](RenderPassWorkContext& rpass) {
 			CommandBuffer& cmdb = *rpass.m_commandBuffer;
@@ -590,13 +590,13 @@ void GpuVisibility::populateRenderGraphInternal(Bool distanceBased, BaseGpuVisib
 	{
 		NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass(generateTempPassName("GPU vis 1st stage: %s", in.m_passesName.cstr()));
 
-		pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kStorageComputeRead);
-		pass.newBufferDependency(out.m_dependency, BufferUsageBit::kStorageComputeWrite);
-		pass.newBufferDependency(zeroMemDep, BufferUsageBit::kStorageComputeWrite);
+		pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kSrvCompute);
+		pass.newBufferDependency(out.m_dependency, BufferUsageBit::kUavCompute);
+		pass.newBufferDependency(zeroMemDep, BufferUsageBit::kUavCompute);
 
 		if(frustumTestData && frustumTestData->m_hzbRt.isValid())
 		{
-			pass.newTextureDependency(frustumTestData->m_hzbRt, TextureUsageBit::kSampledCompute);
+			pass.newTextureDependency(frustumTestData->m_hzbRt, TextureUsageBit::kSrvCompute);
 		}
 
 		pass.setWork([this, frustumTestData, distTestData, lodReferencePoint = in.m_lodReferencePoint, lodDistances = in.m_lodDistances,
@@ -715,11 +715,11 @@ void GpuVisibility::populateRenderGraphInternal(Bool distanceBased, BaseGpuVisib
 	{
 		NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass(generateTempPassName("GPU vis 2nd stage: %s", in.m_passesName.cstr()));
 
-		pass.newBufferDependency(out.m_dependency, BufferUsageBit::kIndirectCompute | BufferUsageBit::kStorageComputeWrite);
+		pass.newBufferDependency(out.m_dependency, BufferUsageBit::kIndirectCompute | BufferUsageBit::kUavCompute);
 
 		if(frustumTestData && frustumTestData->m_hzbRt.isValid())
 		{
-			pass.newTextureDependency(frustumTestData->m_hzbRt, TextureUsageBit::kSampledCompute);
+			pass.newTextureDependency(frustumTestData->m_hzbRt, TextureUsageBit::kSrvCompute);
 		}
 
 		pass.setWork([this, stage1Mem, stage2Mem, bLegacyRendering, bMeshletRendering, bHwMeshletRendering, out, frustumTestData,
@@ -845,9 +845,9 @@ void GpuVisibility::populateRenderGraphStage3(FrustumGpuVisibilityInput& in, Gpu
 	// Create the pass
 	NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass(generateTempPassName("GPU vis 3rd stage: %s", in.m_passesName.cstr()));
 
-	pass.newBufferDependency(out.m_dependency, BufferUsageBit::kIndirectCompute | BufferUsageBit::kStorageComputeWrite);
-	pass.newBufferDependency(m_persistentMemory.m_dep, BufferUsageBit::kIndirectCompute | BufferUsageBit::kStorageComputeWrite);
-	pass.newTextureDependency(*in.m_hzbRt, TextureUsageBit::kSampledCompute);
+	pass.newBufferDependency(out.m_dependency, BufferUsageBit::kIndirectCompute | BufferUsageBit::kUavCompute);
+	pass.newBufferDependency(m_persistentMemory.m_dep, BufferUsageBit::kIndirectCompute | BufferUsageBit::kUavCompute);
+	pass.newTextureDependency(*in.m_hzbRt, TextureUsageBit::kSrvCompute);
 
 	pass.setWork([this, hzbRt = *in.m_hzbRt, bHwMeshletRendering, stage1And2Mem = out.m_stage1And2Mem, stage3Mem = out.m_stage3Mem,
 				  in](RenderPassWorkContext& rpass) {
@@ -969,7 +969,7 @@ void GpuVisibilityNonRenderables::populateRenderGraph(GpuVisibilityNonRenderable
 		BufferInitInfo buffInit("GpuVisibilityNonRenderablesCounters");
 		buffInit.m_size = (m_counterBuffer.isCreated()) ? m_counterBuffer->getSize() * 2
 														: kCountersPerDispatch * counterBufferElementSize * kInitialCounterArraySize;
-		buffInit.m_usage = BufferUsageBit::kStorageComputeWrite | BufferUsageBit::kStorageComputeRead | BufferUsageBit::kTransferDestination;
+		buffInit.m_usage = BufferUsageBit::kUavCompute | BufferUsageBit::kSrvCompute | BufferUsageBit::kCopyDestination;
 		m_counterBuffer = GrManager::getSingleton().newBuffer(buffInit);
 
 		m_counterBufferZeroingHandle = rgraph.importBuffer(BufferView(m_counterBuffer.get()), buffInit.m_usage);
@@ -977,7 +977,7 @@ void GpuVisibilityNonRenderables::populateRenderGraph(GpuVisibilityNonRenderable
 		NonGraphicsRenderPass& pass =
 			rgraph.newNonGraphicsRenderPass(generateTempPassName("Non-renderables vis: Clear counter buff: %s", in.m_passesName.cstr()));
 
-		pass.newBufferDependency(m_counterBufferZeroingHandle, BufferUsageBit::kTransferDestination);
+		pass.newBufferDependency(m_counterBufferZeroingHandle, BufferUsageBit::kCopyDestination);
 
 		pass.setWork([counterBuffer = m_counterBuffer](RenderPassWorkContext& rgraph) {
 			rgraph.m_commandBuffer->fillBuffer(BufferView(counterBuffer.get()), 0);
@@ -997,17 +997,17 @@ void GpuVisibilityNonRenderables::populateRenderGraph(GpuVisibilityNonRenderable
 	// Create the renderpass
 	NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass(generateTempPassName("Non-renderables vis: %s", in.m_passesName.cstr()));
 
-	pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kStorageComputeRead);
-	pass.newBufferDependency(out.m_visiblesBufferHandle, BufferUsageBit::kStorageComputeWrite);
+	pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kSrvCompute);
+	pass.newBufferDependency(out.m_visiblesBufferHandle, BufferUsageBit::kUavCompute);
 
 	if(in.m_hzbRt)
 	{
-		pass.newTextureDependency(*in.m_hzbRt, TextureUsageBit::kSampledCompute);
+		pass.newTextureDependency(*in.m_hzbRt, TextureUsageBit::kSrvCompute);
 	}
 
 	if(m_counterBufferZeroingHandle.isValid()) [[unlikely]]
 	{
-		pass.newBufferDependency(m_counterBufferZeroingHandle, BufferUsageBit::kStorageComputeRead | BufferUsageBit::kStorageComputeWrite);
+		pass.newBufferDependency(m_counterBufferZeroingHandle, BufferUsageBit::kSrvCompute | BufferUsageBit::kUavCompute);
 	}
 
 	pass.setWork([this, objType = in.m_objectType, feedbackBuffer = in.m_cpuFeedbackBuffer, viewProjectionMat = in.m_viewProjectionMat,
@@ -1071,7 +1071,7 @@ Error GpuVisibilityAccelerationStructures::init()
 
 	BufferInitInfo inf("GpuVisibilityAccelerationStructuresCounters");
 	inf.m_size = sizeof(U32) * 2;
-	inf.m_usage = BufferUsageBit::kStorageComputeWrite | BufferUsageBit::kStorageComputeRead | BufferUsageBit::kTransferDestination;
+	inf.m_usage = BufferUsageBit::kUavCompute | BufferUsageBit::kSrvCompute | BufferUsageBit::kCopyDestination;
 	m_counterBuffer = GrManager::getSingleton().newBuffer(inf);
 
 	zeroBuffer(m_counterBuffer.get());
@@ -1094,7 +1094,7 @@ void GpuVisibilityAccelerationStructures::pupulateRenderGraph(GpuVisibilityAccel
 	const U32 aabbCount = GpuSceneArrays::RenderableBoundingVolumeRt::getSingleton().getElementCount();
 
 	out.m_instancesBuffer = allocateStructuredBuffer<AccelerationStructureInstance>(aabbCount);
-	out.m_someBufferHandle = rgraph.importBuffer(out.m_instancesBuffer, BufferUsageBit::kStorageComputeWrite);
+	out.m_someBufferHandle = rgraph.importBuffer(out.m_instancesBuffer, BufferUsageBit::kUavCompute);
 
 	out.m_renderableIndicesBuffer = allocateStructuredBuffer<U32>(aabbCount + 1);
 
@@ -1104,8 +1104,8 @@ void GpuVisibilityAccelerationStructures::pupulateRenderGraph(GpuVisibilityAccel
 	{
 		NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass(generateTempPassName("Accel vis: %s", in.m_passesName.cstr()));
 
-		pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kStorageComputeRead);
-		pass.newBufferDependency(out.m_someBufferHandle, BufferUsageBit::kStorageComputeWrite);
+		pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kSrvCompute);
+		pass.newBufferDependency(out.m_someBufferHandle, BufferUsageBit::kUavCompute);
 
 		pass.setWork([this, viewProjMat = in.m_viewProjectionMatrix, lodDistances = in.m_lodDistances, pointOfTest = in.m_pointOfTest,
 					  testRadius = in.m_testRadius, instancesBuff = out.m_instancesBuffer, indicesBuff = out.m_renderableIndicesBuffer,
@@ -1152,7 +1152,7 @@ void GpuVisibilityAccelerationStructures::pupulateRenderGraph(GpuVisibilityAccel
 		NonGraphicsRenderPass& pass =
 			rgraph.newNonGraphicsRenderPass(generateTempPassName("Accel vis zero remaining instances: %s", in.m_passesName.cstr()));
 
-		pass.newBufferDependency(out.m_someBufferHandle, BufferUsageBit::kStorageComputeWrite);
+		pass.newBufferDependency(out.m_someBufferHandle, BufferUsageBit::kUavCompute);
 
 		pass.setWork([this, zeroInstancesDispatchArgsBuff, instancesBuff = out.m_instancesBuffer,
 					  indicesBuff = out.m_renderableIndicesBuffer](RenderPassWorkContext& rgraph) {

AnKi/Renderer/Utils/HzbGenerator.cpp

@@ -53,7 +53,7 @@ Error HzbGenerator::init()
 	m_counterBufferElementSize = max<U32>(sizeof(U32), GrManager::getSingleton().getDeviceCapabilities().m_storageBufferBindOffsetAlignment);
 	BufferInitInfo buffInit("HzbCounterBuffer");
 	buffInit.m_size = m_counterBufferElementSize * kCounterBufferElementCount;
-	buffInit.m_usage = BufferUsageBit::kStorageComputeWrite | BufferUsageBit::kTransferDestination;
+	buffInit.m_usage = BufferUsageBit::kUavCompute | BufferUsageBit::kCopyDestination;
 	m_counterBuffer = GrManager::getSingleton().newBuffer(buffInit);
 
 	// Zero counter buffer
@@ -93,8 +93,8 @@ void HzbGenerator::populateRenderGraphInternal(ConstWeakArray<DispatchInput> dis
 	for(U32 i = 0; i < dispatchCount; ++i)
 	{
 		const TextureSubresourceDesc firstMipSubresource = TextureSubresourceDesc::firstSurface(DepthStencilAspectBit::kDepth);
-		pass.newTextureDependency(dispatchInputs[i].m_srcDepthRt, TextureUsageBit::kSampledCompute, firstMipSubresource);
-		pass.newTextureDependency(dispatchInputs[i].m_dstHzbRt, TextureUsageBit::kStorageComputeWrite);
+		pass.newTextureDependency(dispatchInputs[i].m_srcDepthRt, TextureUsageBit::kSrvCompute, firstMipSubresource);
+		pass.newTextureDependency(dispatchInputs[i].m_dstHzbRt, TextureUsageBit::kUavCompute);
 
 		dispatchInputsCopy[i] = dispatchInputs[i];
 	}
@@ -190,8 +190,8 @@ void HzbGenerator::populateRenderGraphDirectionalLight(const HzbDirectionalLight
 
 		NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass("HZB max tile depth");
 
-		pass.newTextureDependency(in.m_depthBufferRt, TextureUsageBit::kSampledCompute, DepthStencilAspectBit::kDepth);
-		pass.newTextureDependency(maxDepthRt, TextureUsageBit::kStorageComputeWrite);
+		pass.newTextureDependency(in.m_depthBufferRt, TextureUsageBit::kSrvCompute, DepthStencilAspectBit::kDepth);
+		pass.newTextureDependency(maxDepthRt, TextureUsageBit::kUavCompute);
 
 		pass.setWork([this, depthBufferRt = in.m_depthBufferRt, maxDepthRt, maxDepthRtSize](RenderPassWorkContext& rgraphCtx) {
 			CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
@@ -256,8 +256,8 @@ void HzbGenerator::populateRenderGraphDirectionalLight(const HzbDirectionalLight
 		depthRt.m_loadOperation = RenderTargetLoadOperation::kClear;
 		pass.setRenderpassInfo({}, &depthRt);
 
-		pass.newTextureDependency(maxDepthRt, TextureUsageBit::kSampledFragment);
-		pass.newTextureDependency(depthRts[i], TextureUsageBit::kFramebufferWrite, DepthStencilAspectBit::kDepth);
+		pass.newTextureDependency(maxDepthRt, TextureUsageBit::kSrvFragment);
+		pass.newTextureDependency(depthRts[i], TextureUsageBit::kRtvDsvWrite, DepthStencilAspectBit::kDepth);
 
 		pass.setWork([this, maxDepthRt, invViewProjMat = in.m_cameraInverseViewProjectionMatrix,
 					  lightViewProjMat = cascade.m_projectionMatrix * Mat4(cascade.m_viewMatrix, Vec4(0.0f, 0.0f, 0.0f, 1.0f)),

AnKi/Renderer/Utils/MipmapGenerator.cpp

@@ -28,9 +28,8 @@ void MipmapGenerator::populateRenderGraph(const MipmapGeneratorTargetArguments&
 				GraphicsRenderPass& rpass =
 					rgraph.newGraphicsRenderPass(generateTempPassName("%s: mip #%u face #%u layer #%u", passesName.cstr(), readMip, face, layer));
 
-				rpass.newTextureDependency(target.m_handle, TextureUsageBit::kSampledFragment, TextureSubresourceDesc::surface(readMip, face, layer));
-				rpass.newTextureDependency(target.m_handle, TextureUsageBit::kFramebufferWrite,
-										   TextureSubresourceDesc::surface(readMip + 1, face, layer));
+				rpass.newTextureDependency(target.m_handle, TextureUsageBit::kSrvFragment, TextureSubresourceDesc::surface(readMip, face, layer));
+				rpass.newTextureDependency(target.m_handle, TextureUsageBit::kRtvDsvWrite, TextureSubresourceDesc::surface(readMip + 1, face, layer));
 
 				GraphicsRenderPassTargetDesc rtInfo;
 				rtInfo.m_handle = target.m_handle;

AnKi/Renderer/VolumetricFog.cpp

@@ -49,8 +49,8 @@ void VolumetricFog::populateRenderGraph(RenderingContext& ctx)
 
 	NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass("Vol fog");
 
-	pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kStorageComputeWrite);
-	pass.newTextureDependency(getRenderer().getVolumetricLightingAccumulation().getRt(), TextureUsageBit::kSampledCompute);
+	pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kUavCompute);
+	pass.newTextureDependency(getRenderer().getVolumetricLightingAccumulation().getRt(), TextureUsageBit::kSrvCompute);
 
 	pass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
 		ANKI_TRACE_SCOPED_EVENT(VolumetricFog);

AnKi/Renderer/VolumetricLightingAccumulation.cpp

@@ -47,14 +47,13 @@ Error VolumetricLightingAccumulation::init()
 	ANKI_CHECK(loadShaderProgram("ShaderBinaries/VolumetricLightingAccumulation.ankiprogbin", {{"ENABLE_SHADOWS", 1}}, m_prog, m_grProg));
 
 	// Create RTs
-	TextureInitInfo texinit = getRenderer().create2DRenderTargetInitInfo(m_volumeSize[0], m_volumeSize[1], Format::kR16G16B16A16_Sfloat,
-																		 TextureUsageBit::kStorageComputeRead | TextureUsageBit::kStorageComputeWrite
-																			 | TextureUsageBit::kSampledFragment | TextureUsageBit::kSampledCompute,
-																		 "VolLight");
+	TextureInitInfo texinit = getRenderer().create2DRenderTargetInitInfo(
+		m_volumeSize[0], m_volumeSize[1], Format::kR16G16B16A16_Sfloat,
+		TextureUsageBit::kUavCompute | TextureUsageBit::kSrvFragment | TextureUsageBit::kSrvCompute, "VolLight");
 	texinit.m_depth = m_volumeSize[2];
 	texinit.m_type = TextureType::k3D;
-	m_rtTextures[0] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
-	m_rtTextures[1] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
+	m_rtTextures[0] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvFragment);
+	m_rtTextures[1] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvFragment);
 
 	return Error::kNone;
 }
@@ -66,27 +65,27 @@ void VolumetricLightingAccumulation::populateRenderGraph(RenderingContext& ctx)
 
 	const U readRtIdx = getRenderer().getFrameCount() & 1;
 
-	m_runCtx.m_rts[0] = rgraph.importRenderTarget(m_rtTextures[readRtIdx].get(), TextureUsageBit::kSampledFragment);
+	m_runCtx.m_rts[0] = rgraph.importRenderTarget(m_rtTextures[readRtIdx].get(), TextureUsageBit::kSrvFragment);
 	m_runCtx.m_rts[1] = rgraph.importRenderTarget(m_rtTextures[!readRtIdx].get(), TextureUsageBit::kNone);
 
 	NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass("Vol light");
 
-	pass.newTextureDependency(m_runCtx.m_rts[0], TextureUsageBit::kSampledCompute);
-	pass.newTextureDependency(m_runCtx.m_rts[1], TextureUsageBit::kStorageComputeWrite);
-	pass.newTextureDependency(getRenderer().getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledCompute);
+	pass.newTextureDependency(m_runCtx.m_rts[0], TextureUsageBit::kSrvCompute);
+	pass.newTextureDependency(m_runCtx.m_rts[1], TextureUsageBit::kUavCompute);
+	pass.newTextureDependency(getRenderer().getShadowMapping().getShadowmapRt(), TextureUsageBit::kSrvCompute);
 
-	pass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kStorageComputeRead);
+	pass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kSrvCompute);
 	pass.newBufferDependency(getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kLight),
-							 BufferUsageBit::kStorageComputeRead);
+							 BufferUsageBit::kSrvCompute);
 	pass.newBufferDependency(
 		getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kGlobalIlluminationProbe),
-		BufferUsageBit::kStorageComputeRead);
+		BufferUsageBit::kSrvCompute);
 	pass.newBufferDependency(getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kFogDensityVolume),
-							 BufferUsageBit::kStorageComputeRead);
+							 BufferUsageBit::kSrvCompute);
 
 	if(getRenderer().getIndirectDiffuseProbes().hasCurrentlyRefreshedVolumeRt())
 	{
-		pass.newTextureDependency(getRenderer().getIndirectDiffuseProbes().getCurrentlyRefreshedVolumeRt(), TextureUsageBit::kSampledCompute);
+		pass.newTextureDependency(getRenderer().getIndirectDiffuseProbes().getCurrentlyRefreshedVolumeRt(), TextureUsageBit::kSrvCompute);
 	}
 
 	pass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {

AnKi/Renderer/VrsSriGeneration.cpp

@@ -38,13 +38,13 @@ Error VrsSriGeneration::initInternal()
 	ANKI_R_LOGV("Intializing VRS SRI generation. SRI resolution %ux%u", rez.x(), rez.y());
 
 	// Create textures
-	const TextureUsageBit texUsage = TextureUsageBit::kFramebufferShadingRate | TextureUsageBit::kStorageComputeWrite | TextureUsageBit::kAllSampled;
+	const TextureUsageBit texUsage = TextureUsageBit::kShadingRate | TextureUsageBit::kUavCompute | TextureUsageBit::kAllSrv;
 	TextureInitInfo sriInitInfo = getRenderer().create2DRenderTargetInitInfo(rez.x(), rez.y(), Format::kR8_Uint, texUsage, "VrsSri");
-	m_sriTex = getRenderer().createAndClearRenderTarget(sriInitInfo, TextureUsageBit::kFramebufferShadingRate);
+	m_sriTex = getRenderer().createAndClearRenderTarget(sriInitInfo, TextureUsageBit::kShadingRate);
 
 	const UVec2 rezDownscaled = (getRenderer().getInternalResolution() / 2 + m_sriTexelDimension - 1) / m_sriTexelDimension;
 	sriInitInfo = getRenderer().create2DRenderTargetInitInfo(rezDownscaled.x(), rezDownscaled.y(), Format::kR8_Uint, texUsage, "VrsSriDownscaled");
-	m_downscaledSriTex = getRenderer().createAndClearRenderTarget(sriInitInfo, TextureUsageBit::kFramebufferShadingRate);
+	m_downscaledSriTex = getRenderer().createAndClearRenderTarget(sriInitInfo, TextureUsageBit::kShadingRate);
 
 	// Load programs
 	ANKI_CHECK(ResourceManager::getSingleton().loadResource("ShaderBinaries/VrsSriGenerationCompute.ankiprogbin", m_prog));
@@ -109,8 +109,8 @@ void VrsSriGeneration::importRenderTargets(RenderingContext& ctx)
 	}
 	else
 	{
-		m_runCtx.m_rt = ctx.m_renderGraphDescr.importRenderTarget(m_sriTex.get(), TextureUsageBit::kFramebufferShadingRate);
-		m_runCtx.m_downscaledRt = ctx.m_renderGraphDescr.importRenderTarget(m_downscaledSriTex.get(), TextureUsageBit::kFramebufferShadingRate);
+		m_runCtx.m_rt = ctx.m_renderGraphDescr.importRenderTarget(m_sriTex.get(), TextureUsageBit::kShadingRate);
+		m_runCtx.m_downscaledRt = ctx.m_renderGraphDescr.importRenderTarget(m_downscaledSriTex.get(), TextureUsageBit::kShadingRate);
 		m_sriTexImportedOnce = true;
 	}
 }
@@ -131,8 +131,8 @@ void VrsSriGeneration::populateRenderGraph(RenderingContext& ctx)
 	{
 		NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass("VRS SRI generation");
 
-		pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kStorageComputeWrite);
-		pass.newTextureDependency(getRenderer().getLightShading().getRt(), TextureUsageBit::kSampledCompute);
+		pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kUavCompute);
+		pass.newTextureDependency(getRenderer().getLightShading().getRt(), TextureUsageBit::kSrvCompute);
 
 		pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 			ANKI_TRACE_SCOPED_EVENT(VrsSriGeneration);
@@ -156,8 +156,8 @@ void VrsSriGeneration::populateRenderGraph(RenderingContext& ctx)
 	{
 		NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass("VRS SRI downscale");
 
-		pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kSampledCompute);
-		pass.newTextureDependency(m_runCtx.m_downscaledRt, TextureUsageBit::kStorageComputeWrite);
+		pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kSrvCompute);
+		pass.newTextureDependency(m_runCtx.m_downscaledRt, TextureUsageBit::kUavCompute);
 
 		pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 			ANKI_TRACE_SCOPED_EVENT(VrsSriGeneration);

AnKi/Resource/ImageResource.cpp

@@ -62,7 +62,7 @@ Error ImageResource::load(const ResourceFilename& filename, Bool async)
 	getFilepathFilename(filename, filenameExt);
 
 	TextureInitInfo init(filenameExt);
-	init.m_usage = TextureUsageBit::kAllSampled | TextureUsageBit::kTransferDestination;
+	init.m_usage = TextureUsageBit::kAllSrv | TextureUsageBit::kCopyDestination;
 	U32 faces = 0;
 
 	ResourceFilePtr file;
@@ -204,7 +204,7 @@ Error ImageResource::load(const ResourceFilename& filename, Bool async)
 		cmdbinit.m_flags = CommandBufferFlag::kGeneralWork | CommandBufferFlag::kSmallBatch;
 		CommandBufferPtr cmdb = GrManager::getSingleton().newCommandBuffer(cmdbinit);
 
-		const TextureBarrierInfo barrier = {view, TextureUsageBit::kNone, TextureUsageBit::kAllSampled};
+		const TextureBarrierInfo barrier = {view, TextureUsageBit::kNone, TextureUsageBit::kAllSrv};
 		cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
 		FencePtr outFence;
@@ -256,8 +256,8 @@ Error ImageResource::load(LoadingContext& ctx)
 			U32 mip, layer, face;
 			unflatten3dArrayIndex(ctx.m_layerCount, ctx.m_faces, ctx.m_loader.getMipmapCount(), i, layer, face, mip);
 
-			barriers[barrierCount++] = {TextureView(ctx.m_tex.get(), TextureSubresourceDesc::surface(mip, face, layer)), TextureUsageBit::kAllSampled,
-										TextureUsageBit::kTransferDestination};
+			barriers[barrierCount++] = {TextureView(ctx.m_tex.get(), TextureSubresourceDesc::surface(mip, face, layer)), TextureUsageBit::kAllSrv,
+										TextureUsageBit::kCopyDestination};
 		}
 		cmdb->setPipelineBarrier({&barriers[0], barrierCount}, {}, {});
 
@@ -312,7 +312,7 @@ Error ImageResource::load(LoadingContext& ctx)
 			unflatten3dArrayIndex(ctx.m_layerCount, ctx.m_faces, ctx.m_loader.getMipmapCount(), i, layer, face, mip);
 
 			barriers[barrierCount++] = {TextureView(ctx.m_tex.get(), TextureSubresourceDesc::surface(mip, face, layer)),
-										TextureUsageBit::kTransferDestination, TextureUsageBit::kSampledFragment | TextureUsageBit::kSampledGeometry};
+										TextureUsageBit::kCopyDestination, TextureUsageBit::kSrvFragment | TextureUsageBit::kSrvGeometry};
 		}
 		cmdb->setPipelineBarrier({&barriers[0], barrierCount}, {}, {});
 

AnKi/Resource/MeshResource.cpp

@@ -205,7 +205,7 @@ Error MeshResource::load(const ResourceFilename& filename, Bool async)
 			}
 		}
 
-		const BufferBarrierInfo barrier = {UnifiedGeometryBuffer::getSingleton().getBufferView(), BufferUsageBit::kTransferDestination,
+		const BufferBarrierInfo barrier = {UnifiedGeometryBuffer::getSingleton().getBufferView(), BufferUsageBit::kCopyDestination,
 										   BufferUsageBit::kVertex};
 
 		cmdb->setPipelineBarrier({}, {&barrier, 1}, {});
@@ -238,7 +238,7 @@ Error MeshResource::loadAsync(MeshBinaryLoader& loader) const
 	U32 handleCount = 0;
 
 	Buffer* unifiedGeometryBuffer = &UnifiedGeometryBuffer::getSingleton().getBuffer();
-	const BufferUsageBit unifiedGeometryBufferNonTransferUsage = unifiedGeometryBuffer->getBufferUsage() ^ BufferUsageBit::kTransferDestination;
+	const BufferUsageBit unifiedGeometryBufferNonTransferUsage = unifiedGeometryBuffer->getBufferUsage() ^ BufferUsageBit::kCopyDestination;
 
 	CommandBufferInitInfo cmdbinit;
 	cmdbinit.m_flags = CommandBufferFlag::kSmallBatch | CommandBufferFlag::kGeneralWork;
@@ -246,7 +246,7 @@ Error MeshResource::loadAsync(MeshBinaryLoader& loader) const
 
 	// Set transfer to transfer barrier because of the clear that happened while sync loading
 	const BufferBarrierInfo barrier = {UnifiedGeometryBuffer::getSingleton().getBufferView(), unifiedGeometryBufferNonTransferUsage,
-									   BufferUsageBit::kTransferDestination};
+									   BufferUsageBit::kCopyDestination};
 	cmdb->setPipelineBarrier({}, {&barrier, 1}, {});
 
 	// Upload index and vertex buffers
@@ -362,7 +362,7 @@ Error MeshResource::loadAsync(MeshBinaryLoader& loader) const
 		// Set the barriers
 		BufferBarrierInfo bufferBarrier;
 		bufferBarrier.m_bufferView = UnifiedGeometryBuffer::getSingleton().getBufferView();
-		bufferBarrier.m_previousUsage = BufferUsageBit::kTransferDestination;
+		bufferBarrier.m_previousUsage = BufferUsageBit::kCopyDestination;
 		bufferBarrier.m_nextUsage = unifiedGeometryBufferNonTransferUsage;
 
 		Array<AccelerationStructureBarrierInfo, kMaxLodCount> asBarriers;
@@ -402,7 +402,7 @@ Error MeshResource::loadAsync(MeshBinaryLoader& loader) const
 		// Only set a barrier
 		BufferBarrierInfo bufferBarrier;
 		bufferBarrier.m_bufferView = UnifiedGeometryBuffer::getSingleton().getBufferView();
-		bufferBarrier.m_previousUsage = BufferUsageBit::kTransferDestination;
+		bufferBarrier.m_previousUsage = BufferUsageBit::kCopyDestination;
 		bufferBarrier.m_nextUsage = unifiedGeometryBufferNonTransferUsage;
 
 		cmdb->setPipelineBarrier({}, {&bufferBarrier, 1}, {});

AnKi/Resource/TransferGpuAllocator.cpp

@@ -15,7 +15,7 @@ Error TransferGpuAllocator::StackAllocatorBuilderInterface::allocateChunk(PtrSiz
 {
 	out = newInstance<Chunk>(ResourceMemoryPool::getSingleton());
 
-	BufferInitInfo bufferInit(size, BufferUsageBit::kTransferSource, BufferMapAccessBit::kWrite, "Transfer");
+	BufferInitInfo bufferInit(size, BufferUsageBit::kCopySource, BufferMapAccessBit::kWrite, "Transfer");
 	out->m_buffer = GrManager::getSingleton().newBuffer(bufferInit);
 
 	out->m_mappedBuffer = out->m_buffer->map(0, kMaxPtrSize, BufferMapAccessBit::kWrite);

AnKi/Scene/Components/GlobalIlluminationProbeComponent.cpp

@@ -50,7 +50,7 @@ Error GlobalIlluminationProbeComponent::update(SceneComponentUpdateInfo& info, B
 		texInit.m_height = m_cellCounts.y();
 		texInit.m_depth = m_cellCounts.z();
 		texInit.m_type = TextureType::k3D;
-		texInit.m_usage = TextureUsageBit::kAllSampled | TextureUsageBit::kStorageComputeWrite | TextureUsageBit::kStorageComputeRead;
+		texInit.m_usage = TextureUsageBit::kAllSrv | TextureUsageBit::kUavCompute;
 
 		m_volTex = GrManager::getSingleton().newTexture(texInit);
 		m_volTexBindlessIdx = m_volTex->getOrCreateBindlessTextureIndex(TextureSubresourceDesc::all());
@@ -68,7 +68,7 @@ Error GlobalIlluminationProbeComponent::update(SceneComponentUpdateInfo& info, B
 
 		TextureBarrierInfo texBarrier;
 		texBarrier.m_previousUsage = TextureUsageBit::kNone;
-		texBarrier.m_nextUsage = TextureUsageBit::kStorageComputeWrite;
+		texBarrier.m_nextUsage = TextureUsageBit::kUavCompute;
 		texBarrier.m_textureView = TextureView(m_volTex.get(), TextureSubresourceDesc::all());
 		cmdb->setPipelineBarrier({&texBarrier, 1}, {}, {});
 
@@ -84,8 +84,8 @@ Error GlobalIlluminationProbeComponent::update(SceneComponentUpdateInfo& info, B
 		wgSize.z() = (8 - 1 + m_volTex->getDepth()) / 8;
 		cmdb->dispatchCompute(wgSize.x(), wgSize.y(), wgSize.z());
 
-		texBarrier.m_previousUsage = TextureUsageBit::kStorageComputeWrite;
-		texBarrier.m_nextUsage = TextureUsageBit::kAllSampled; // Put something random, the renderer will start from kNone
+		texBarrier.m_previousUsage = TextureUsageBit::kUavCompute;
+		texBarrier.m_nextUsage = TextureUsageBit::kAllSrv; // Put something random, the renderer will start from kNone
 		cmdb->setPipelineBarrier({&texBarrier, 1}, {}, {});
 
 		cmdb->endRecording();

AnKi/Scene/Components/ParticleEmitterComponent.cpp

@@ -238,7 +238,7 @@ ParticleEmitterComponent::ParticleEmitterComponent(SceneNode* node)
 	cmdb->copyBufferToBuffer(indicesAlloc, m_quadIndices);
 	BufferBarrierInfo barrier;
 	barrier.m_bufferView = BufferView(dstBuff);
-	barrier.m_previousUsage = BufferUsageBit::kTransferDestination;
+	barrier.m_previousUsage = BufferUsageBit::kCopyDestination;
 	barrier.m_nextUsage = dstBuff->getBufferUsage();
 	cmdb->setPipelineBarrier({}, {&barrier, 1}, {});
 	cmdb->endRecording();

AnKi/Scene/Components/ReflectionProbeComponent.cpp

@@ -28,8 +28,7 @@ ReflectionProbeComponent::ReflectionProbeComponent(SceneNode* node)
 	texInit.m_height = texInit.m_width;
 	texInit.m_mipmapCount = U8(computeMaxMipmapCount2d(texInit.m_width, texInit.m_height, 8));
 	texInit.m_type = TextureType::kCube;
-	texInit.m_usage = TextureUsageBit::kAllSampled | TextureUsageBit::kStorageComputeWrite | TextureUsageBit::kStorageComputeRead
-					  | TextureUsageBit::kAllFramebuffer;
+	texInit.m_usage = TextureUsageBit::kAllSrv | TextureUsageBit::kUavCompute | TextureUsageBit::kAllRtvDsv;
 
 	m_reflectionTex = GrManager::getSingleton().newTexture(texInit);
 

AnKi/Ui/Font.cpp

@@ -63,7 +63,7 @@ void Font::createTexture(const void* data, U32 width, U32 height)
 
 	// Create and populate the buffer
 	const U32 buffSize = width * height * 4;
-	BufferPtr buff = GrManager::getSingleton().newBuffer(BufferInitInfo(buffSize, BufferUsageBit::kTransferSource, BufferMapAccessBit::kWrite, "UI"));
+	BufferPtr buff = GrManager::getSingleton().newBuffer(BufferInitInfo(buffSize, BufferUsageBit::kCopySource, BufferMapAccessBit::kWrite, "UI"));
 	void* mapped = buff->map(0, buffSize, BufferMapAccessBit::kWrite);
 	memcpy(mapped, data, buffSize);
 	buff->flush(0, buffSize);
@@ -74,7 +74,7 @@ void Font::createTexture(const void* data, U32 width, U32 height)
 	texInit.m_width = width;
 	texInit.m_height = height;
 	texInit.m_format = Format::kR8G8B8A8_Unorm;
-	texInit.m_usage = TextureUsageBit::kTransferDestination | TextureUsageBit::kSampledFragment;
+	texInit.m_usage = TextureUsageBit::kCopyDestination | TextureUsageBit::kSrvFragment;
 	texInit.m_mipmapCount = 1; // No mips because it will appear blurry with trilinear filtering
 
 	m_tex = GrManager::getSingleton().newTexture(texInit);
@@ -90,13 +90,13 @@ void Font::createTexture(const void* data, U32 width, U32 height)
 	cmdbInit.m_flags = CommandBufferFlag::kGeneralWork | CommandBufferFlag::kSmallBatch;
 	CommandBufferPtr cmdb = GrManager::getSingleton().newCommandBuffer(cmdbInit);
 
-	TextureBarrierInfo barrier = {firstMipView, TextureUsageBit::kNone, TextureUsageBit::kTransferDestination};
+	TextureBarrierInfo barrier = {firstMipView, TextureUsageBit::kNone, TextureUsageBit::kCopyDestination};
 	cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
 	cmdb->copyBufferToTexture(BufferView(buff.get()), firstMipView);
 
-	barrier.m_previousUsage = TextureUsageBit::kTransferDestination;
-	barrier.m_nextUsage = TextureUsageBit::kSampledFragment;
+	barrier.m_previousUsage = TextureUsageBit::kCopyDestination;
+	barrier.m_nextUsage = TextureUsageBit::kSrvFragment;
 	cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
 	cmdb->endRecording();

Tests/Gr/Gr.cpp

@@ -96,7 +96,7 @@ ANKI_TEST(Gr, ClearScreen)
 		CommandBufferPtr cmdb = GrManager::getSingleton().newCommandBuffer(cinit);
 
 		const TextureBarrierInfo barrier = {TextureView(presentTex.get(), TextureSubresourceDesc::all()), TextureUsageBit::kNone,
-											TextureUsageBit::kFramebufferWrite};
+											TextureUsageBit::kRtvDsvWrite};
 		cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
 		RenderTarget rt;
@@ -106,7 +106,7 @@ ANKI_TEST(Gr, ClearScreen)
 		cmdb->beginRenderPass({rt});
 		cmdb->endRenderPass();
 
-		const TextureBarrierInfo barrier2 = {TextureView(presentTex.get(), TextureSubresourceDesc::all()), TextureUsageBit::kFramebufferWrite,
+		const TextureBarrierInfo barrier2 = {TextureView(presentTex.get(), TextureSubresourceDesc::all()), TextureUsageBit::kRtvDsvWrite,
 											 TextureUsageBit::kPresent};
 		cmdb->setPipelineBarrier({&barrier2, 1}, {}, {});
 
@@ -134,7 +134,7 @@ ANKI_TEST(Gr, SimpleCompute)
 		BufferInitInfo buffInit;
 		buffInit.m_mapAccess = BufferMapAccessBit::kWrite;
 		buffInit.m_size = sizeof(Vec4);
-		buffInit.m_usage = BufferUsageBit::kStorageComputeRead;
+		buffInit.m_usage = BufferUsageBit::kSrvCompute;
 
 		BufferPtr readBuff = GrManager::getSingleton().newBuffer(buffInit);
 
@@ -144,13 +144,13 @@ ANKI_TEST(Gr, SimpleCompute)
 		readBuff->unmap();
 
 		buffInit.m_mapAccess = BufferMapAccessBit::kRead;
-		buffInit.m_usage = BufferUsageBit::kStorageComputeWrite;
+		buffInit.m_usage = BufferUsageBit::kUavCompute;
 
 		BufferPtr writeBuff = GrManager::getSingleton().newBuffer(buffInit);
 
 		constexpr const char* kSrc = R"(
-StructuredBuffer<float4> g_in : ANKI_REG(t0);
-RWStructuredBuffer<float4> g_out : ANKI_REG(u0);
+StructuredBuffer<float4> g_in : register(t0);
+RWStructuredBuffer<float4> g_out : register(u0);
 
 [numthreads(1, 1, 1)]
 void main()
@@ -165,7 +165,7 @@ void main()
 		ShaderProgramPtr prog = GrManager::getSingleton().newShaderProgram(progInit);
 
 		CommandBufferInitInfo cmdbInit;
-		cmdbInit.m_flags = CommandBufferFlag::kSmallBatch;
+		cmdbInit.m_flags |= CommandBufferFlag::kSmallBatch;
 
 		CommandBufferPtr cmdb = GrManager::getSingleton().newCommandBuffer(cmdbInit);
 
@@ -291,23 +291,23 @@ void main()
 		const Vec4 kInvalidVec(1.0f, 2.0f, 3.0f, 4.0f);
 
 		const Array<Vec4, 2> data = {kMagicVec, kMagicVec * 2.0f};
-		BufferPtr structured = createBuffer(BufferUsageBit::kAllStorage, ConstWeakArray<Vec4>(data), "structured");
+		BufferPtr structured = createBuffer(BufferUsageBit::kAllUav | BufferUsageBit::kAllSrv, ConstWeakArray<Vec4>(data), "structured");
 
-		texInit.m_usage = TextureUsageBit::kSampledCompute | TextureUsageBit::kTransferDestination;
+		texInit.m_usage = TextureUsageBit::kSrvCompute | TextureUsageBit::kCopyDestination;
 		TexturePtr tex = createTexture2d(texInit, kMagicVec * 2.0f);
 
-		BufferPtr buff = createBuffer(BufferUsageBit::kAllTexel, kMagicVec * 2.0f, 1, "buff");
-		BufferPtr rwstructured = createBuffer(BufferUsageBit::kAllStorage, Foo(kInvalidVec), 2, "rwstructured");
-		BufferPtr rwbuff = createBuffer(BufferUsageBit::kAllTexel, kInvalidVec, 1, "rwbuff");
+		BufferPtr buff = createBuffer(BufferUsageBit::kAllUav | BufferUsageBit::kAllSrv, kMagicVec * 2.0f, 1, "buff");
+		BufferPtr rwstructured = createBuffer(BufferUsageBit::kAllUav | BufferUsageBit::kAllSrv, Foo(kInvalidVec), 2, "rwstructured");
+		BufferPtr rwbuff = createBuffer(BufferUsageBit::kAllUav | BufferUsageBit::kAllSrv, kInvalidVec, 1, "rwbuff");
 
 		Array<TexturePtr, 3> rwtex;
 
-		texInit.m_usage = TextureUsageBit::kStorageComputeWrite | TextureUsageBit::kTransferDestination;
+		texInit.m_usage = TextureUsageBit::kUavCompute | TextureUsageBit::kCopyDestination;
 		rwtex[0] = createTexture2d(texInit, kInvalidVec);
 		rwtex[1] = createTexture2d(texInit, kInvalidVec);
 		rwtex[2] = createTexture2d(texInit, kInvalidVec);
 
-		BufferPtr consts = createBuffer(BufferUsageBit::kUniformCompute, kMagicVec * 3.0f, 1, "consts");
+		BufferPtr consts = createBuffer(BufferUsageBit::kConstantCompute, kMagicVec * 3.0f, 1, "consts");
 
 		SamplerInitInfo samplInit;
 		SamplerPtr sampler = GrManager::getSingleton().newSampler(samplInit);
@@ -406,13 +406,13 @@ float4 main(float4 svPosition : SV_POSITION, float2 uv : TEXCOORDS, uint svPrimI
 		texInit.m_width = 2;
 		texInit.m_height = 2;
 		texInit.m_format = Format::kR32G32B32A32_Sfloat;
-		texInit.m_usage = TextureUsageBit::kAllSampled | TextureUsageBit::kAllTransfer;
+		texInit.m_usage = TextureUsageBit::kAllSrv | TextureUsageBit::kAllTransfer;
 		TexturePtr tex = GrManager::getSingleton().newTexture(texInit);
 
 		BufferInitInfo buffInit;
 		buffInit.m_mapAccess = BufferMapAccessBit::kWrite;
 		buffInit.m_size = sizeof(Vec4) * 4;
-		buffInit.m_usage = BufferUsageBit::kTransferSource;
+		buffInit.m_usage = BufferUsageBit::kCopySource;
 		BufferPtr uploadBuff = GrManager::getSingleton().newBuffer(buffInit);
 		void* mappedMem = uploadBuff->map(0, kMaxPtrSize, BufferMapAccessBit::kWrite);
 		const Array<Vec4, 4> texelData = {Vec4(1.0f, 0.0f, 0.0f, 1.0f), Vec4(0.0f, 1.0f, 0.0f, 1.0f), Vec4(0.0f, 0.0f, 1.0f, 1.0f),
@@ -424,10 +424,10 @@ float4 main(float4 svPosition : SV_POSITION, float2 uv : TEXCOORDS, uint svPrimI
 		cmdbInit.m_flags |= CommandBufferFlag::kSmallBatch;
 		CommandBufferPtr cmdb = GrManager::getSingleton().newCommandBuffer(cmdbInit);
 		TextureBarrierInfo barrier = {TextureView(tex.get(), TextureSubresourceDesc::all()), TextureUsageBit::kNone,
-									  TextureUsageBit::kTransferDestination};
+									  TextureUsageBit::kCopyDestination};
 		cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 		cmdb->copyBufferToTexture(BufferView(uploadBuff.get()), TextureView(tex.get(), TextureSubresourceDesc::all()));
-		barrier = {TextureView(tex.get(), TextureSubresourceDesc::all()), TextureUsageBit::kTransferDestination, TextureUsageBit::kSampledFragment};
+		barrier = {TextureView(tex.get(), TextureSubresourceDesc::all()), TextureUsageBit::kCopyDestination, TextureUsageBit::kSrvFragment};
 		cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 		cmdb->endRecording();
 		FencePtr fence;
@@ -455,7 +455,7 @@ float4 main(float4 svPosition : SV_POSITION, float2 uv : TEXCOORDS, uint svPrimI
 			cmdb->bindShaderProgram(prog.get());
 
 			const TextureBarrierInfo barrier = {TextureView(presentTex.get(), TextureSubresourceDesc::all()), TextureUsageBit::kNone,
-												TextureUsageBit::kFramebufferWrite};
+												TextureUsageBit::kRtvDsvWrite};
 			cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
 			cmdb->beginRenderPass({TextureView(presentTex.get(), TextureSubresourceDesc::firstSurface())});
@@ -469,7 +469,7 @@ float4 main(float4 svPosition : SV_POSITION, float2 uv : TEXCOORDS, uint svPrimI
 			cmdb->draw(PrimitiveTopology::kTriangles, 6);
 			cmdb->endRenderPass();
 
-			const TextureBarrierInfo barrier2 = {TextureView(presentTex.get(), TextureSubresourceDesc::all()), TextureUsageBit::kFramebufferWrite,
+			const TextureBarrierInfo barrier2 = {TextureView(presentTex.get(), TextureSubresourceDesc::all()), TextureUsageBit::kRtvDsvWrite,
 												 TextureUsageBit::kPresent};
 			cmdb->setPipelineBarrier({&barrier2, 1}, {}, {});
 
@@ -585,7 +585,7 @@ void main()
 	TextureInitInfo init;
 	init.m_depth = 1;
 	init.m_format = COL_FORMAT;
-	init.m_usage = TextureUsageBit::kSampledFragment | TextureUsageBit::kAllFramebuffer;
+	init.m_usage = TextureUsageBit::kSrvFragment | TextureUsageBit::kAllRtvDsv;
 	init.m_height = RT_HEIGHT;
 	init.m_width = RT_WIDTH;
 	init.m_mipmapCount = 1;
@@ -641,10 +641,10 @@ void main()
 			CommandBufferPtr cmdb = g_gr->newCommandBuffer(cinit);
 
 			cmdb->setViewport(0, 0, RT_WIDTH, RT_HEIGHT);
-			setTextureSurfaceBarrier(cmdb, rt, TextureUsageBit::kNone, TextureUsageBit::kFramebufferWrite, TextureSurfaceDescriptor(0, 0, 0, 0));
-			cmdb->beginRenderPass(fb[0].get(), {{TextureUsageBit::kFramebufferWrite}}, {});
+			setTextureSurfaceBarrier(cmdb, rt, TextureUsageBit::kNone, TextureUsageBit::kRtvDsvWrite, TextureSurfaceDescriptor(0, 0, 0, 0));
+			cmdb->beginRenderPass(fb[0].get(), {{TextureUsageBit::kRtvDsvWrite}}, {});
 			cmdb->endRenderPass();
-			setTextureSurfaceBarrier(cmdb, rt, TextureUsageBit::kFramebufferWrite, TextureUsageBit::kSampledFragment, TextureSurfaceDescriptor(0, 0, 0, 0));
+			setTextureSurfaceBarrier(cmdb, rt, TextureUsageBit::kRtvDsvWrite, TextureUsageBit::kSrvFragment, TextureSurfaceDescriptor(0, 0, 0, 0));
 			cmdb->endRecording();
 			GrManager::getSingleton().submit(cmdb.get());
 		}
@@ -654,12 +654,12 @@ void main()
 		CommandBufferPtr cmdb = g_gr->newCommandBuffer(cinit);
 
 		// Draw offscreen
-		setTextureSurfaceBarrier(cmdb, rt, TextureUsageBit::kSampledFragment, TextureUsageBit::kFramebufferWrite, TextureSurfaceDescriptor(0, 0, 0, 0));
+		setTextureSurfaceBarrier(cmdb, rt, TextureUsageBit::kSrvFragment, TextureUsageBit::kRtvDsvWrite, TextureSurfaceDescriptor(0, 0, 0, 0));
 		auto vp = VIEWPORTS[(i / 30) % 4];
 		cmdb->setViewport(vp[0], vp[1], vp[2], vp[3]);
 		cmdb->setScissor(vp[0] + SCISSOR_MARGIN, vp[1] + SCISSOR_MARGIN, vp[2] - SCISSOR_MARGIN * 2, vp[3] - SCISSOR_MARGIN * 2);
 		cmdb->bindShaderProgram(prog.get());
-		cmdb->beginRenderPass(fb[i % 4].get(), {{TextureUsageBit::kFramebufferWrite}}, {}, vp[0] + RENDER_AREA_MARGIN, vp[1] + RENDER_AREA_MARGIN,
+		cmdb->beginRenderPass(fb[i % 4].get(), {{TextureUsageBit::kRtvDsvWrite}}, {}, vp[0] + RENDER_AREA_MARGIN, vp[1] + RENDER_AREA_MARGIN,
 							  vp[2] - RENDER_AREA_MARGIN * 2, vp[3] - RENDER_AREA_MARGIN * 2);
 		cmdb->draw(PrimitiveTopology::kTriangleStrip, 4);
 		cmdb->endRenderPass();
@@ -668,10 +668,10 @@ void main()
 		cmdb->setViewport(0, 0, g_win->getWidth(), g_win->getHeight());
 		cmdb->setScissor(0, 0, g_win->getWidth(), g_win->getHeight());
 		cmdb->bindShaderProgram(blitProg.get());
-		setTextureSurfaceBarrier(cmdb, rt, TextureUsageBit::kFramebufferWrite, TextureUsageBit::kSampledFragment, TextureSurfaceDescriptor(0, 0, 0, 0));
+		setTextureSurfaceBarrier(cmdb, rt, TextureUsageBit::kRtvDsvWrite, TextureUsageBit::kSrvFragment, TextureSurfaceDescriptor(0, 0, 0, 0));
 		// cmdb->bindTextureAndSampler(0, 0, texView.get(), sampler.get());
 		presentBarrierA(cmdb, presentTex);
-		cmdb->beginRenderPass(dfb.get(), {TextureUsageBit::kFramebufferWrite}, {});
+		cmdb->beginRenderPass(dfb.get(), {TextureUsageBit::kRtvDsvWrite}, {});
 		cmdb->draw(PrimitiveTopology::kTriangles, 6);
 		cmdb->endRenderPass();
 		presentBarrierB(cmdb, presentTex);
@@ -700,7 +700,7 @@ ANKI_TEST(Gr, Buffer)
 
 	BufferInitInfo buffInit("a");
 	buffInit.m_size = 512;
-	buffInit.m_usage = BufferUsageBit::kAllUniform;
+	buffInit.m_usage = BufferUsageBit::kAllConstant;
 	buffInit.m_mapAccess = BufferMapAccessBit::kNone;
 	BufferPtr a = g_gr->newBuffer(buffInit);
 
@@ -813,7 +813,7 @@ float4 main(VertOut i) : SV_TARGET0
 			cmdb->bindShaderProgram(prog.get());
 
 			const TextureBarrierInfo barrier = {TextureView(presentTex.get(), TextureSubresourceDesc::all()), TextureUsageBit::kNone,
-												TextureUsageBit::kFramebufferWrite};
+												TextureUsageBit::kRtvDsvWrite};
 			cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
 			cmdb->pushDebugMarker("AnKi", Vec3(1.0f, 0.0f, 0.0f));
@@ -843,7 +843,7 @@ float4 main(VertOut i) : SV_TARGET0
 			cmdb->draw(PrimitiveTopology::kTriangles, 3);
 			cmdb->endRenderPass();
 
-			const TextureBarrierInfo barrier2 = {TextureView(presentTex.get(), TextureSubresourceDesc::all()), TextureUsageBit::kFramebufferWrite,
+			const TextureBarrierInfo barrier2 = {TextureView(presentTex.get(), TextureSubresourceDesc::all()), TextureUsageBit::kRtvDsvWrite,
 												 TextureUsageBit::kPresent};
 			cmdb->setPipelineBarrier({&barrier2, 1}, {}, {});
 
@@ -928,7 +928,7 @@ ANKI_TEST(Gr, DrawWithVertex)
 		cmdb->setPolygonOffset(0.0, 0.0);
 		cmdb->bindShaderProgram(prog.get());
 		presentBarrierA(cmdb, presentTex);
-		cmdb->beginRenderPass(fb.get(), {TextureUsageBit::kFramebufferWrite}, {});
+		cmdb->beginRenderPass(fb.get(), {TextureUsageBit::kRtvDsvWrite}, {});
 		cmdb->draw(PrimitiveTopology::kTriangles, 3);
 		cmdb->endRenderPass();
 		presentBarrierB(cmdb, presentTex);
@@ -970,7 +970,7 @@ ANKI_TEST(Gr, Texture)
 	TextureInitInfo init;
 	init.m_depth = 1;
 	init.m_format = Format::kR8G8B8_Unorm;
-	init.m_usage = TextureUsageBit::kSampledFragment;
+	init.m_usage = TextureUsageBit::kSrvFragment;
 	init.m_height = 4;
 	init.m_width = 4;
 	init.m_mipmapCount = 2;
@@ -1005,7 +1005,7 @@ ANKI_TEST(Gr, DrawWithTexture)
 	TextureInitInfo init;
 	init.m_depth = 1;
 	init.m_format = Format::kR8G8B8_Unorm;
-	init.m_usage = TextureUsageBit::kSampledFragment | TextureUsageBit::kTransferDestination;
+	init.m_usage = TextureUsageBit::kSrvFragment | TextureUsageBit::kCopyDestination;
 	init.m_height = 2;
 	init.m_width = 2;
 	init.m_mipmapCount = 2;
@@ -1024,7 +1024,7 @@ ANKI_TEST(Gr, DrawWithTexture)
 	init.m_width = 4;
 	init.m_height = 4;
 	init.m_mipmapCount = 3;
-	init.m_usage = TextureUsageBit::kSampledFragment | TextureUsageBit::kTransferDestination | TextureUsageBit::kGenerateMipmaps;
+	init.m_usage = TextureUsageBit::kSrvFragment | TextureUsageBit::kCopyDestination | TextureUsageBit::kGenerateMipmaps;
 
 	TexturePtr b = g_gr->newTexture(init);
 
@@ -1045,11 +1045,11 @@ ANKI_TEST(Gr, DrawWithTexture)
 	CommandBufferPtr cmdb = g_gr->newCommandBuffer(cmdbinit);
 
 	// Set barriers
-	setTextureSurfaceBarrier(cmdb, a, TextureUsageBit::kSampledFragment, TextureUsageBit::kTransferDestination, TextureSurfaceDescriptor(0, 0, 0, 0));
+	setTextureSurfaceBarrier(cmdb, a, TextureUsageBit::kSrvFragment, TextureUsageBit::kCopyDestination, TextureSurfaceDescriptor(0, 0, 0, 0));
 
-	setTextureSurfaceBarrier(cmdb, a, TextureUsageBit::kSampledFragment, TextureUsageBit::kTransferDestination, TextureSurfaceDescriptor(1, 0, 0, 0));
+	setTextureSurfaceBarrier(cmdb, a, TextureUsageBit::kSrvFragment, TextureUsageBit::kCopyDestination, TextureSurfaceDescriptor(1, 0, 0, 0));
 
-	setTextureSurfaceBarrier(cmdb, b, TextureUsageBit::kNone, TextureUsageBit::kTransferDestination, TextureSurfaceDescriptor(0, 0, 0, 0));
+	setTextureSurfaceBarrier(cmdb, b, TextureUsageBit::kNone, TextureUsageBit::kCopyDestination, TextureSurfaceDescriptor(0, 0, 0, 0));
 
 	TransferGpuAllocatorHandle handle0, handle1, handle2;
 	UPLOAD_TEX_SURFACE(cmdb, a, TextureSurfaceDescriptor(0, 0, 0, 0), &mip0[0], sizeof(mip0), handle0);
@@ -1059,18 +1059,18 @@ ANKI_TEST(Gr, DrawWithTexture)
 	UPLOAD_TEX_SURFACE(cmdb, b, TextureSurfaceDescriptor(0, 0, 0, 0), &bmip0[0], sizeof(bmip0), handle2);
 
 	// Gen mips
-	setTextureSurfaceBarrier(cmdb, b, TextureUsageBit::kTransferDestination, TextureUsageBit::kGenerateMipmaps, TextureSurfaceDescriptor(0, 0, 0, 0));
+	setTextureSurfaceBarrier(cmdb, b, TextureUsageBit::kCopyDestination, TextureUsageBit::kGenerateMipmaps, TextureSurfaceDescriptor(0, 0, 0, 0));
 
 	cmdb->generateMipmaps2d(g_gr->newTextureView(TextureViewInitInfo(b.get())).get());
 
 	// Set barriers
-	setTextureSurfaceBarrier(cmdb, a, TextureUsageBit::kTransferDestination, TextureUsageBit::kSampledFragment, TextureSurfaceDescriptor(0, 0, 0, 0));
+	setTextureSurfaceBarrier(cmdb, a, TextureUsageBit::kCopyDestination, TextureUsageBit::kSrvFragment, TextureSurfaceDescriptor(0, 0, 0, 0));
 
-	setTextureSurfaceBarrier(cmdb, a, TextureUsageBit::kTransferDestination, TextureUsageBit::kSampledFragment, TextureSurfaceDescriptor(1, 0, 0, 0));
+	setTextureSurfaceBarrier(cmdb, a, TextureUsageBit::kCopyDestination, TextureUsageBit::kSrvFragment, TextureSurfaceDescriptor(1, 0, 0, 0));
 
 	for(U32 i = 0; i < 3; ++i)
 	{
-		setTextureSurfaceBarrier(cmdb, b, TextureUsageBit::kGenerateMipmaps, TextureUsageBit::kSampledFragment, TextureSurfaceDescriptor(i, 0, 0, 0));
+		setTextureSurfaceBarrier(cmdb, b, TextureUsageBit::kGenerateMipmaps, TextureUsageBit::kSrvFragment, TextureSurfaceDescriptor(i, 0, 0, 0));
 	}
 
 	FencePtr fence;
@@ -1146,7 +1146,7 @@ void main()
 		cmdb->setViewport(0, 0, g_win->getWidth(), g_win->getHeight());
 		cmdb->bindShaderProgram(prog.get());
 		presentBarrierA(cmdb, presentTex);
-		cmdb->beginRenderPass(fb.get(), {TextureUsageBit::kFramebufferWrite}, {});
+		cmdb->beginRenderPass(fb.get(), {TextureUsageBit::kRtvDsvWrite}, {});
 
 		Vec4 pc(F32(g_win->getWidth()), F32(g_win->getHeight()), 0.0f, 0.0f);
 		cmdb->setPushConstants(&pc, sizeof(pc));
@@ -1231,7 +1231,7 @@ static void drawOffscreen(GrManager& gr)
 
 	TextureInitInfo init;
 	init.m_format = COL_FORMAT;
-	init.m_usage = TextureUsageBit::kSampledFragment | TextureUsageBit::kAllFramebuffer;
+	init.m_usage = TextureUsageBit::kSrvFragment | TextureUsageBit::kAllRtvDsv;
 	init.m_height = TEX_SIZE;
 	init.m_width = TEX_SIZE;
 	init.m_type = TextureType::k2D;
@@ -1289,25 +1289,25 @@ static void drawOffscreen(GrManager& gr)
 
 		cmdb->setPolygonOffset(0.0, 0.0);
 
-		setTextureSurfaceBarrier(cmdb, col0, TextureUsageBit::kNone, TextureUsageBit::kFramebufferWrite, TextureSurfaceDescriptor(0, 0, 0, 0));
-		setTextureSurfaceBarrier(cmdb, col1, TextureUsageBit::kNone, TextureUsageBit::kFramebufferWrite, TextureSurfaceDescriptor(0, 0, 0, 0));
-		setTextureSurfaceBarrier(cmdb, dp, TextureUsageBit::kNone, TextureUsageBit::kAllFramebuffer, TextureSurfaceDescriptor(0, 0, 0, 0));
-		cmdb->beginRenderPass(fb.get(), {{TextureUsageBit::kFramebufferWrite, TextureUsageBit::kFramebufferWrite}}, TextureUsageBit::kAllFramebuffer);
+		setTextureSurfaceBarrier(cmdb, col0, TextureUsageBit::kNone, TextureUsageBit::kRtvDsvWrite, TextureSurfaceDescriptor(0, 0, 0, 0));
+		setTextureSurfaceBarrier(cmdb, col1, TextureUsageBit::kNone, TextureUsageBit::kRtvDsvWrite, TextureSurfaceDescriptor(0, 0, 0, 0));
+		setTextureSurfaceBarrier(cmdb, dp, TextureUsageBit::kNone, TextureUsageBit::kAllRtvDsv, TextureSurfaceDescriptor(0, 0, 0, 0));
+		cmdb->beginRenderPass(fb.get(), {{TextureUsageBit::kRtvDsvWrite, TextureUsageBit::kRtvDsvWrite}}, TextureUsageBit::kAllRtvDsv);
 
 		drawOffscreenDrawcalls(gr, prog, cmdb, TEX_SIZE, indices, verts);
 
 		cmdb->endRenderPass();
 
-		setTextureSurfaceBarrier(cmdb, col0, TextureUsageBit::kFramebufferWrite, TextureUsageBit::kSampledFragment, TextureSurfaceDescriptor(0, 0, 0, 0));
-		setTextureSurfaceBarrier(cmdb, col1, TextureUsageBit::kFramebufferWrite, TextureUsageBit::kSampledFragment, TextureSurfaceDescriptor(0, 0, 0, 0));
-		setTextureSurfaceBarrier(cmdb, dp, TextureUsageBit::kAllFramebuffer, TextureUsageBit::kSampledFragment, TextureSurfaceDescriptor(0, 0, 0, 0));
+		setTextureSurfaceBarrier(cmdb, col0, TextureUsageBit::kRtvDsvWrite, TextureUsageBit::kSrvFragment, TextureSurfaceDescriptor(0, 0, 0, 0));
+		setTextureSurfaceBarrier(cmdb, col1, TextureUsageBit::kRtvDsvWrite, TextureUsageBit::kSrvFragment, TextureSurfaceDescriptor(0, 0, 0, 0));
+		setTextureSurfaceBarrier(cmdb, dp, TextureUsageBit::kAllRtvDsv, TextureUsageBit::kSrvFragment, TextureSurfaceDescriptor(0, 0, 0, 0));
 
 		// Draw quad
 		TexturePtr presentTex = gr.acquireNextPresentableTexture();
 		FramebufferPtr dfb = createColorFb(gr, presentTex);
 
 		presentBarrierA(cmdb, presentTex);
-		cmdb->beginRenderPass(dfb.get(), {TextureUsageBit::kFramebufferWrite}, {});
+		cmdb->beginRenderPass(dfb.get(), {TextureUsageBit::kRtvDsvWrite}, {});
 		cmdb->bindShaderProgram(resolveProg.get());
 		cmdb->setViewport(0, 0, WIDTH, HEIGHT);
 		// cmdb->bindTextureAndSampler(0, 0, col0View.get(), sampler.get());
@@ -1356,7 +1356,7 @@ ANKI_TEST(Gr, ImageLoadStore)
 	TextureInitInfo init;
 	init.m_width = init.m_height = 4;
 	init.m_mipmapCount = 2;
-	init.m_usage = TextureUsageBit::kTransferDestination | TextureUsageBit::kAllSampled | TextureUsageBit::kStorageComputeWrite;
+	init.m_usage = TextureUsageBit::kCopyDestination | TextureUsageBit::kAllSrv | TextureUsageBit::kUavCompute;
 	init.m_type = TextureType::k2D;
 	init.m_format = Format::kR8G8B8A8_Unorm;
 
@@ -1380,22 +1380,22 @@ ANKI_TEST(Gr, ImageLoadStore)
 	CommandBufferInitInfo cmdbinit;
 	CommandBufferPtr cmdb = g_gr->newCommandBuffer(cmdbinit);
 
-	setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kNone, TextureUsageBit::kTransferDestination, TextureSurfaceDescriptor(0, 0, 0, 0));
+	setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kNone, TextureUsageBit::kCopyDestination, TextureSurfaceDescriptor(0, 0, 0, 0));
 
 	ClearValue clear;
 	clear.m_colorf = {{0.0, 1.0, 0.0, 1.0}};
 	TextureViewInitInfo viewInit2(tex.get(), TextureSurfaceDescriptor(0, 0, 0, 0));
 	cmdb->clearTextureView(g_gr->newTextureView(viewInit2).get(), clear);
 
-	setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kTransferDestination, TextureUsageBit::kSampledFragment, TextureSurfaceDescriptor(0, 0, 0, 0));
+	setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kCopyDestination, TextureUsageBit::kSrvFragment, TextureSurfaceDescriptor(0, 0, 0, 0));
 
-	setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kNone, TextureUsageBit::kTransferDestination, TextureSurfaceDescriptor(1, 0, 0, 0));
+	setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kNone, TextureUsageBit::kCopyDestination, TextureSurfaceDescriptor(1, 0, 0, 0));
 
 	clear.m_colorf = {{0.0, 0.0, 1.0, 1.0}};
 	TextureViewInitInfo viewInit3(tex.get(), TextureSurfaceDescriptor(1, 0, 0, 0));
 	cmdb->clearTextureView(g_gr->newTextureView(viewInit3).get(), clear);
 
-	setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kTransferDestination, TextureUsageBit::kStorageComputeWrite, TextureSurfaceDescriptor(1, 0, 0, 0));
+	setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kCopyDestination, TextureUsageBit::kUavCompute, TextureSurfaceDescriptor(1, 0, 0, 0));
 
 	cmdb->endRecording();
 	GrManager::getSingleton().submit(cmdb.get());
@@ -1415,11 +1415,11 @@ ANKI_TEST(Gr, ImageLoadStore)
 		Vec4* col = SET_STORAGE(Vec4*, sizeof(*col), cmdb, 1, 0);
 		*col = Vec4(F32(iterations) / F32(ITERATION_COUNT));
 
-		setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kNone, TextureUsageBit::kStorageComputeWrite, TextureSurfaceDescriptor(1, 0, 0, 0));
+		setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kNone, TextureUsageBit::kUavCompute, TextureSurfaceDescriptor(1, 0, 0, 0));
 		cmdb->bindShaderProgram(compProg.get());
 		cmdb->bindStorageTexture(0, 0, view.get());
 		cmdb->dispatchCompute(WIDTH / 2, HEIGHT / 2, 1);
-		setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kStorageComputeWrite, TextureUsageBit::kSampledFragment, TextureSurfaceDescriptor(1, 0, 0, 0));
+		setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kUavCompute, TextureUsageBit::kSrvFragment, TextureSurfaceDescriptor(1, 0, 0, 0));
 
 		// Present image
 		cmdb->setViewport(0, 0, WIDTH, HEIGHT);
@@ -1428,7 +1428,7 @@ ANKI_TEST(Gr, ImageLoadStore)
 		TexturePtr presentTex = g_gr->acquireNextPresentableTexture();
 		FramebufferPtr dfb = createColorFb(*g_gr, presentTex);
 		presentBarrierA(cmdb, presentTex);
-		cmdb->beginRenderPass(dfb.get(), {TextureUsageBit::kFramebufferWrite}, {});
+		cmdb->beginRenderPass(dfb.get(), {TextureUsageBit::kRtvDsvWrite}, {});
 		// cmdb->bindTextureAndSampler(0, 0, g_gr->newTextureView(TextureViewInitInfo(tex.get())).get(), sampler.get());
 		cmdb->draw(PrimitiveTopology::kTriangles, 6);
 		cmdb->endRenderPass();
@@ -1469,7 +1469,7 @@ ANKI_TEST(Gr, 3DTextures)
 	TextureInitInfo init;
 	init.m_depth = 1;
 	init.m_format = Format::kR8G8B8A8_Unorm;
-	init.m_usage = TextureUsageBit::kSampledFragment | TextureUsageBit::kTransferDestination;
+	init.m_usage = TextureUsageBit::kSrvFragment | TextureUsageBit::kCopyDestination;
 	init.m_height = 2;
 	init.m_width = 2;
 	init.m_mipmapCount = 2;
@@ -1492,18 +1492,18 @@ ANKI_TEST(Gr, 3DTextures)
 	cmdbinit.m_flags = CommandBufferFlag::kGeneralWork | CommandBufferFlag::kSmallBatch;
 	CommandBufferPtr cmdb = g_gr->newCommandBuffer(cmdbinit);
 
-	setTextureVolumeBarrier(cmdb, a, TextureUsageBit::kNone, TextureUsageBit::kTransferDestination, TextureVolumeDescriptor(0));
+	setTextureVolumeBarrier(cmdb, a, TextureUsageBit::kNone, TextureUsageBit::kCopyDestination, TextureVolumeDescriptor(0));
 
-	setTextureVolumeBarrier(cmdb, a, TextureUsageBit::kNone, TextureUsageBit::kTransferDestination, TextureVolumeDescriptor(1));
+	setTextureVolumeBarrier(cmdb, a, TextureUsageBit::kNone, TextureUsageBit::kCopyDestination, TextureVolumeDescriptor(1));
 
 	TransferGpuAllocatorHandle handle0, handle1;
 	UPLOAD_TEX_VOL(cmdb, a, TextureVolumeDescriptor(0), &mip0[0], sizeof(mip0), handle0);
 
 	UPLOAD_TEX_VOL(cmdb, a, TextureVolumeDescriptor(1), &mip1[0], sizeof(mip1), handle1);
 
-	setTextureVolumeBarrier(cmdb, a, TextureUsageBit::kTransferDestination, TextureUsageBit::kSampledFragment, TextureVolumeDescriptor(0));
+	setTextureVolumeBarrier(cmdb, a, TextureUsageBit::kCopyDestination, TextureUsageBit::kSrvFragment, TextureVolumeDescriptor(0));
 
-	setTextureVolumeBarrier(cmdb, a, TextureUsageBit::kTransferDestination, TextureUsageBit::kSampledFragment, TextureVolumeDescriptor(1));
+	setTextureVolumeBarrier(cmdb, a, TextureUsageBit::kCopyDestination, TextureUsageBit::kSrvFragment, TextureVolumeDescriptor(1));
 
 	FencePtr fence;
 	cmdb->endRecording();
@@ -1534,7 +1534,7 @@ ANKI_TEST(Gr, 3DTextures)
 		TexturePtr presentTex = g_gr->acquireNextPresentableTexture();
 		FramebufferPtr dfb = createColorFb(*g_gr, presentTex);
 		presentBarrierA(cmdb, presentTex);
-		cmdb->beginRenderPass(dfb.get(), {TextureUsageBit::kFramebufferWrite}, {});
+		cmdb->beginRenderPass(dfb.get(), {TextureUsageBit::kRtvDsvWrite}, {});
 
 		cmdb->bindShaderProgram(prog.get());
 
@@ -1571,7 +1571,7 @@ static RenderTargetDesc newRTDescr(CString name)
 {
 	RenderTargetDesc texInf(name);
 	texInf.m_width = texInf.m_height = 16;
-	texInf.m_usage = TextureUsageBit::kFramebufferWrite | TextureUsageBit::kSampledFragment;
+	texInf.m_usage = TextureUsageBit::kRtvDsvWrite | TextureUsageBit::kSrvFragment;
 	texInf.m_format = Format::kR8G8B8A8_Unorm;
 	texInf.bake();
 	return texInf;
@@ -1590,7 +1590,7 @@ ANKI_TEST(Gr, RenderGraph)
 
 	TextureInitInfo texI("dummy");
 	texI.m_width = texI.m_height = 16;
-	texI.m_usage = TextureUsageBit::kFramebufferWrite | TextureUsageBit::kSampledFragment;
+	texI.m_usage = TextureUsageBit::kRtvDsvWrite | TextureUsageBit::kSrvFragment;
 	texI.m_format = Format::kR8G8B8A8_Unorm;
 	TexturePtr dummyTex = g_gr->newTexture(texI);
 
@@ -1598,15 +1598,15 @@ ANKI_TEST(Gr, RenderGraph)
 	RenderTargetHandle smScratchRt = descr.newRenderTarget(newRTDescr("SM scratch"));
 	{
 		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("SM");
-		pass.newTextureDependency(smScratchRt, TextureUsageBit::kAllFramebuffer);
+		pass.newTextureDependency(smScratchRt, TextureUsageBit::kAllRtvDsv);
 	}
 
 	// SM to exponential SM
-	RenderTargetHandle smExpRt = descr.importRenderTarget(dummyTex.get(), TextureUsageBit::kSampledFragment);
+	RenderTargetHandle smExpRt = descr.importRenderTarget(dummyTex.get(), TextureUsageBit::kSrvFragment);
 	{
 		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("ESM");
-		pass.newTextureDependency(smScratchRt, TextureUsageBit::kSampledFragment);
-		pass.newTextureDependency(smExpRt, TextureUsageBit::kFramebufferWrite);
+		pass.newTextureDependency(smScratchRt, TextureUsageBit::kSrvFragment);
+		pass.newTextureDependency(smExpRt, TextureUsageBit::kRtvDsvWrite);
 	}
 
 	// GI gbuff
@@ -1615,22 +1615,22 @@ ANKI_TEST(Gr, RenderGraph)
 	RenderTargetHandle giGbuffDepthRt = descr.newRenderTarget(newRTDescr("GI GBuff depth"));
 	{
 		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("GI gbuff");
-		pass.newTextureDependency(giGbuffNormRt, TextureUsageBit::kFramebufferWrite);
-		pass.newTextureDependency(giGbuffDepthRt, TextureUsageBit::kFramebufferWrite);
-		pass.newTextureDependency(giGbuffDiffRt, TextureUsageBit::kFramebufferWrite);
+		pass.newTextureDependency(giGbuffNormRt, TextureUsageBit::kRtvDsvWrite);
+		pass.newTextureDependency(giGbuffDepthRt, TextureUsageBit::kRtvDsvWrite);
+		pass.newTextureDependency(giGbuffDiffRt, TextureUsageBit::kRtvDsvWrite);
 	}
 
 	// GI light
-	RenderTargetHandle giGiLightRt = descr.importRenderTarget(dummyTex.get(), TextureUsageBit::kSampledFragment);
+	RenderTargetHandle giGiLightRt = descr.importRenderTarget(dummyTex.get(), TextureUsageBit::kSrvFragment);
 	for(U32 faceIdx = 0; faceIdx < 6; ++faceIdx)
 	{
 		TextureSubresourceInfo subresource(TextureSurfaceDescriptor(0, faceIdx, 0));
 
 		GraphicsRenderPass& pass = descr.newGraphicsRenderPass(String().sprintf("GI lp%u", faceIdx).toCString());
-		pass.newTextureDependency(giGiLightRt, TextureUsageBit::kFramebufferWrite, subresource);
-		pass.newTextureDependency(giGbuffNormRt, TextureUsageBit::kSampledFragment);
-		pass.newTextureDependency(giGbuffDepthRt, TextureUsageBit::kSampledFragment);
-		pass.newTextureDependency(giGbuffDiffRt, TextureUsageBit::kSampledFragment);
+		pass.newTextureDependency(giGiLightRt, TextureUsageBit::kRtvDsvWrite, subresource);
+		pass.newTextureDependency(giGbuffNormRt, TextureUsageBit::kSrvFragment);
+		pass.newTextureDependency(giGbuffDepthRt, TextureUsageBit::kSrvFragment);
+		pass.newTextureDependency(giGbuffDiffRt, TextureUsageBit::kSrvFragment);
 	}
 
 	// GI light mips
@@ -1654,70 +1654,70 @@ ANKI_TEST(Gr, RenderGraph)
 	RenderTargetHandle gbuffDepth = descr.newRenderTarget(newRTDescr("GBuff RT2"));
 	{
 		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("G-Buffer");
-		pass.newTextureDependency(gbuffRt0, TextureUsageBit::kFramebufferWrite);
-		pass.newTextureDependency(gbuffRt1, TextureUsageBit::kFramebufferWrite);
-		pass.newTextureDependency(gbuffRt2, TextureUsageBit::kFramebufferWrite);
-		pass.newTextureDependency(gbuffDepth, TextureUsageBit::kFramebufferWrite);
+		pass.newTextureDependency(gbuffRt0, TextureUsageBit::kRtvDsvWrite);
+		pass.newTextureDependency(gbuffRt1, TextureUsageBit::kRtvDsvWrite);
+		pass.newTextureDependency(gbuffRt2, TextureUsageBit::kRtvDsvWrite);
+		pass.newTextureDependency(gbuffDepth, TextureUsageBit::kRtvDsvWrite);
 	}
 
 	// Half depth
 	RenderTargetHandle halfDepthRt = descr.newRenderTarget(newRTDescr("Depth/2"));
 	{
 		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("HalfDepth");
-		pass.newTextureDependency(gbuffDepth, TextureUsageBit::kSampledFragment);
-		pass.newTextureDependency(halfDepthRt, TextureUsageBit::kFramebufferWrite);
+		pass.newTextureDependency(gbuffDepth, TextureUsageBit::kSrvFragment);
+		pass.newTextureDependency(halfDepthRt, TextureUsageBit::kRtvDsvWrite);
 	}
 
 	// Quarter depth
 	RenderTargetHandle quarterDepthRt = descr.newRenderTarget(newRTDescr("Depth/4"));
 	{
 		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("QuarterDepth");
-		pass.newTextureDependency(quarterDepthRt, TextureUsageBit::kFramebufferWrite);
-		pass.newTextureDependency(halfDepthRt, TextureUsageBit::kSampledFragment);
+		pass.newTextureDependency(quarterDepthRt, TextureUsageBit::kRtvDsvWrite);
+		pass.newTextureDependency(halfDepthRt, TextureUsageBit::kSrvFragment);
 	}
 
 	// SSAO
 	RenderTargetHandle ssaoRt = descr.newRenderTarget(newRTDescr("SSAO"));
 	{
 		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("SSAO main");
-		pass.newTextureDependency(ssaoRt, TextureUsageBit::kFramebufferWrite);
-		pass.newTextureDependency(quarterDepthRt, TextureUsageBit::kSampledFragment);
-		pass.newTextureDependency(gbuffRt2, TextureUsageBit::kSampledFragment);
+		pass.newTextureDependency(ssaoRt, TextureUsageBit::kRtvDsvWrite);
+		pass.newTextureDependency(quarterDepthRt, TextureUsageBit::kSrvFragment);
+		pass.newTextureDependency(gbuffRt2, TextureUsageBit::kSrvFragment);
 
 		RenderTargetHandle ssaoVBlurRt = descr.newRenderTarget(newRTDescr("SSAO tmp"));
 		GraphicsRenderPass& pass2 = descr.newGraphicsRenderPass("SSAO vblur");
-		pass2.newTextureDependency(ssaoRt, TextureUsageBit::kSampledFragment);
-		pass2.newTextureDependency(ssaoVBlurRt, TextureUsageBit::kFramebufferWrite);
+		pass2.newTextureDependency(ssaoRt, TextureUsageBit::kSrvFragment);
+		pass2.newTextureDependency(ssaoVBlurRt, TextureUsageBit::kRtvDsvWrite);
 
 		GraphicsRenderPass& pass3 = descr.newGraphicsRenderPass("SSAO hblur");
-		pass3.newTextureDependency(ssaoRt, TextureUsageBit::kFramebufferWrite);
-		pass3.newTextureDependency(ssaoVBlurRt, TextureUsageBit::kSampledFragment);
+		pass3.newTextureDependency(ssaoRt, TextureUsageBit::kRtvDsvWrite);
+		pass3.newTextureDependency(ssaoVBlurRt, TextureUsageBit::kSrvFragment);
 	}
 
 	// Volumetric
 	RenderTargetHandle volRt = descr.newRenderTarget(newRTDescr("Vol"));
 	{
 		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("Vol main");
-		pass.newTextureDependency(volRt, TextureUsageBit::kFramebufferWrite);
-		pass.newTextureDependency(quarterDepthRt, TextureUsageBit::kSampledFragment);
+		pass.newTextureDependency(volRt, TextureUsageBit::kRtvDsvWrite);
+		pass.newTextureDependency(quarterDepthRt, TextureUsageBit::kSrvFragment);
 
 		RenderTargetHandle volVBlurRt = descr.newRenderTarget(newRTDescr("Vol tmp"));
 		GraphicsRenderPass& pass2 = descr.newGraphicsRenderPass("Vol vblur");
-		pass2.newTextureDependency(volRt, TextureUsageBit::kSampledFragment);
-		pass2.newTextureDependency(volVBlurRt, TextureUsageBit::kFramebufferWrite);
+		pass2.newTextureDependency(volRt, TextureUsageBit::kSrvFragment);
+		pass2.newTextureDependency(volVBlurRt, TextureUsageBit::kRtvDsvWrite);
 
 		GraphicsRenderPass& pass3 = descr.newGraphicsRenderPass("Vol hblur");
-		pass3.newTextureDependency(volRt, TextureUsageBit::kFramebufferWrite);
-		pass3.newTextureDependency(volVBlurRt, TextureUsageBit::kSampledFragment);
+		pass3.newTextureDependency(volRt, TextureUsageBit::kRtvDsvWrite);
+		pass3.newTextureDependency(volVBlurRt, TextureUsageBit::kSrvFragment);
 	}
 
 	// Forward shading
 	RenderTargetHandle fsRt = descr.newRenderTarget(newRTDescr("FS"));
 	{
 		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("Forward shading");
-		pass.newTextureDependency(fsRt, TextureUsageBit::kFramebufferWrite);
-		pass.newTextureDependency(halfDepthRt, TextureUsageBit::kSampledFragment | TextureUsageBit::kFramebufferRead);
-		pass.newTextureDependency(volRt, TextureUsageBit::kSampledFragment);
+		pass.newTextureDependency(fsRt, TextureUsageBit::kRtvDsvWrite);
+		pass.newTextureDependency(halfDepthRt, TextureUsageBit::kSrvFragment | TextureUsageBit::kRtvDsvRead);
+		pass.newTextureDependency(volRt, TextureUsageBit::kSrvFragment);
 	}
 
 	// Light shading
@@ -1725,26 +1725,26 @@ ANKI_TEST(Gr, RenderGraph)
 	{
 		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("Light shading");
 
-		pass.newTextureDependency(lightRt, TextureUsageBit::kFramebufferWrite);
-		pass.newTextureDependency(gbuffRt0, TextureUsageBit::kSampledFragment);
-		pass.newTextureDependency(gbuffRt1, TextureUsageBit::kSampledFragment);
-		pass.newTextureDependency(gbuffRt2, TextureUsageBit::kSampledFragment);
-		pass.newTextureDependency(gbuffDepth, TextureUsageBit::kSampledFragment);
-		pass.newTextureDependency(smExpRt, TextureUsageBit::kSampledFragment);
-		pass.newTextureDependency(giGiLightRt, TextureUsageBit::kSampledFragment);
-		pass.newTextureDependency(ssaoRt, TextureUsageBit::kSampledFragment);
-		pass.newTextureDependency(fsRt, TextureUsageBit::kSampledFragment);
+		pass.newTextureDependency(lightRt, TextureUsageBit::kRtvDsvWrite);
+		pass.newTextureDependency(gbuffRt0, TextureUsageBit::kSrvFragment);
+		pass.newTextureDependency(gbuffRt1, TextureUsageBit::kSrvFragment);
+		pass.newTextureDependency(gbuffRt2, TextureUsageBit::kSrvFragment);
+		pass.newTextureDependency(gbuffDepth, TextureUsageBit::kSrvFragment);
+		pass.newTextureDependency(smExpRt, TextureUsageBit::kSrvFragment);
+		pass.newTextureDependency(giGiLightRt, TextureUsageBit::kSrvFragment);
+		pass.newTextureDependency(ssaoRt, TextureUsageBit::kSrvFragment);
+		pass.newTextureDependency(fsRt, TextureUsageBit::kSrvFragment);
 	}
 
 	// TAA
-	RenderTargetHandle taaHistoryRt = descr.importRenderTarget(dummyTex.get(), TextureUsageBit::kSampledFragment);
+	RenderTargetHandle taaHistoryRt = descr.importRenderTarget(dummyTex.get(), TextureUsageBit::kSrvFragment);
 	RenderTargetHandle taaRt = descr.importRenderTarget(dummyTex.get(), TextureUsageBit::kNone);
 	{
 		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("Temporal AA");
 
-		pass.newTextureDependency(lightRt, TextureUsageBit::kSampledFragment);
-		pass.newTextureDependency(taaRt, TextureUsageBit::kFramebufferWrite);
-		pass.newTextureDependency(taaHistoryRt, TextureUsageBit::kSampledFragment);
+		pass.newTextureDependency(lightRt, TextureUsageBit::kSrvFragment);
+		pass.newTextureDependency(taaRt, TextureUsageBit::kRtvDsvWrite);
+		pass.newTextureDependency(taaHistoryRt, TextureUsageBit::kSrvFragment);
 	}
 
 	rgraph->compileNewGraph(descr, pool);
@@ -1825,7 +1825,7 @@ void main()
 	texInit.m_width = texInit.m_height = 8;
 	texInit.m_format = Format::kR8G8B8_Uint;
 	texInit.m_type = TextureType::k2D;
-	texInit.m_usage = TextureUsageBit::kTransferDestination | TextureUsageBit::kAllSampled;
+	texInit.m_usage = TextureUsageBit::kCopyDestination | TextureUsageBit::kAllSrv;
 	texInit.m_mipmapCount = 2;
 	TexturePtr tex = g_gr->newTexture(texInit);
 	TextureViewPtr texView = g_gr->newTextureView(TextureViewInitInfo(tex.get()));
@@ -1835,7 +1835,7 @@ void main()
 
 	// Create the buffer to copy to the texture
 	BufferPtr uploadBuff =
-		g_gr->newBuffer(BufferInitInfo(PtrSize(texInit.m_width) * texInit.m_height * 3, BufferUsageBit::kAllTransfer, BufferMapAccessBit::kWrite));
+		g_gr->newBuffer(BufferInitInfo(PtrSize(texInit.m_width) * texInit.m_height * 3, BufferUsageBit::kAllCopy, BufferMapAccessBit::kWrite));
 	U8* data = static_cast<U8*>(uploadBuff->map(0, uploadBuff->getSize(), BufferMapAccessBit::kWrite));
 	for(U32 i = 0; i < texInit.m_width * texInit.m_height; ++i)
 	{
@@ -1847,7 +1847,7 @@ void main()
 	uploadBuff->unmap();
 
 	BufferPtr uploadBuff2 = g_gr->newBuffer(
-		BufferInitInfo(PtrSize(texInit.m_width >> 1) * (texInit.m_height >> 1) * 3, BufferUsageBit::kAllTransfer, BufferMapAccessBit::kWrite));
+		BufferInitInfo(PtrSize(texInit.m_width >> 1) * (texInit.m_height >> 1) * 3, BufferUsageBit::kAllCopy, BufferMapAccessBit::kWrite));
 	data = static_cast<U8*>(uploadBuff2->map(0, uploadBuff2->getSize(), BufferMapAccessBit::kWrite));
 	for(U i = 0; i < (texInit.m_width >> 1) * (texInit.m_height >> 1); ++i)
 	{
@@ -1859,7 +1859,7 @@ void main()
 	uploadBuff2->unmap();
 
 	// Create the result buffer
-	BufferPtr resultBuff = g_gr->newBuffer(BufferInitInfo(sizeof(UVec4), BufferUsageBit::kStorageComputeWrite, BufferMapAccessBit::kRead));
+	BufferPtr resultBuff = g_gr->newBuffer(BufferInitInfo(sizeof(UVec4), BufferUsageBit::kUavCompute, BufferMapAccessBit::kRead));
 
 	// Upload data and test them
 	CommandBufferInitInfo cmdbInit;
@@ -1868,17 +1868,17 @@ void main()
 
 	TextureSubresourceInfo subresource;
 	subresource.m_mipmapCount = texInit.m_mipmapCount;
-	setTextureBarrier(cmdb, tex, TextureUsageBit::kNone, TextureUsageBit::kTransferDestination, subresource);
+	setTextureBarrier(cmdb, tex, TextureUsageBit::kNone, TextureUsageBit::kCopyDestination, subresource);
 	cmdb->copyBufferToTexture(BufferView(uploadBuff.get()), g_gr->newTextureView(TextureViewInitInfo(tex.get(), TextureSurfaceDescriptor(0, 0, 0))).get());
 	cmdb->copyBufferToTexture(BufferView(uploadBuff2.get()), g_gr->newTextureView(TextureViewInitInfo(tex.get(), TextureSurfaceDescriptor(1, 0, 0))).get());
 
-	setTextureBarrier(cmdb, tex, TextureUsageBit::kTransferDestination, TextureUsageBit::kSampledCompute, subresource);
+	setTextureBarrier(cmdb, tex, TextureUsageBit::kCopyDestination, TextureUsageBit::kSrvCompute, subresource);
 	cmdb->bindShaderProgram(prog.get());
 	// cmdb->bindTextureAndSampler(0, 0, texView.get(), sampler.get());
 	cmdb->bindStorageBuffer(0, 1, BufferView(resultBuff.get()));
 	cmdb->dispatchCompute(1, 1, 1);
 
-	setBufferBarrier(cmdb, resultBuff, BufferUsageBit::kStorageComputeWrite, BufferUsageBit::kStorageComputeWrite, 0, resultBuff->getSize());
+	setBufferBarrier(cmdb, resultBuff, BufferUsageBit::kUavCompute, BufferUsageBit::kUavCompute, 0, resultBuff->getSize());
 
 	cmdb->endRecording();
 	GrManager::getSingleton().submit(cmdb.get());
@@ -1976,7 +1976,7 @@ void main()
 
 	// Create the result buffer
 	BufferPtr resultBuff =
-		g_gr->newBuffer(BufferInitInfo(sizeof(UVec4), BufferUsageBit::kAllStorage | BufferUsageBit::kTransferDestination, BufferMapAccessBit::kRead));
+		g_gr->newBuffer(BufferInitInfo(sizeof(UVec4), BufferUsageBit::kAllStorage | BufferUsageBit::kCopyDestination, BufferMapAccessBit::kRead));
 
 	// Draw
 	CommandBufferInitInfo cinit;
@@ -1984,7 +1984,7 @@ void main()
 	CommandBufferPtr cmdb = g_gr->newCommandBuffer(cinit);
 
 	cmdb->fillBuffer(resultBuff.get(), 0, resultBuff->getSize(), 0);
-	setBufferBarrier(cmdb, resultBuff, BufferUsageBit::kTransferDestination, BufferUsageBit::kStorageFragmentWrite, 0, resultBuff->getSize());
+	setBufferBarrier(cmdb, resultBuff, BufferUsageBit::kCopyDestination, BufferUsageBit::kStorageFragmentWrite, 0, resultBuff->getSize());
 
 	cmdb->setViewport(0, 0, WIDTH, HEIGHT);
 	cmdb->bindShaderProgram(prog.get());
@@ -2003,7 +2003,7 @@ void main()
 	TexturePtr presentTex = g_gr->acquireNextPresentableTexture();
 	FramebufferPtr dfb = createColorFb(*g_gr, presentTex);
 	presentBarrierA(cmdb, presentTex);
-	cmdb->beginRenderPass(dfb.get(), {TextureUsageBit::kFramebufferWrite}, {});
+	cmdb->beginRenderPass(dfb.get(), {TextureUsageBit::kRtvDsvWrite}, {});
 	cmdb->draw(PrimitiveTopology::kTriangles, 3);
 	cmdb->endRenderPass();
 	presentBarrierB(cmdb, presentTex);
@@ -2112,7 +2112,7 @@ ANKI_TEST(Gr, Bindless)
 	texInit.m_width = 1;
 	texInit.m_height = 1;
 	texInit.m_format = Format::R32G32B32A32_UINT;
-	texInit.m_usage = TextureUsageBit::kAllStorage | TextureUsageBit::ALL_TRANSFER | TextureUsageBit::kAllSampled;
+	texInit.m_usage = TextureUsageBit::kAllUav | TextureUsageBit::ALL_TRANSFER | TextureUsageBit::kAllSrv;
 	texInit.m_mipmapCount = 1;
 
 	TexturePtr texA = gr->newTexture(texInit);
@@ -2174,11 +2174,11 @@ void main()
 	cinit.m_flags = CommandBufferFlag::kComputeWork | CommandBufferFlag::kSmallBatch;
 	CommandBufferPtr cmdb = gr->newCommandBuffer(cinit);
 
-	setTextureSurfaceBarrier(cmdb, texA, TextureUsageBit::kNone, TextureUsageBit::kTransferDestination,
+	setTextureSurfaceBarrier(cmdb, texA, TextureUsageBit::kNone, TextureUsageBit::kCopyDestination,
 								   TextureSurfaceDescriptor());
-	setTextureSurfaceBarrier(cmdb, texB, TextureUsageBit::kNone, TextureUsageBit::kTransferDestination,
+	setTextureSurfaceBarrier(cmdb, texB, TextureUsageBit::kNone, TextureUsageBit::kCopyDestination,
 								   TextureSurfaceDescriptor());
-	setTextureSurfaceBarrier(cmdb, texC, TextureUsageBit::kNone, TextureUsageBit::kTransferDestination,
+	setTextureSurfaceBarrier(cmdb, texC, TextureUsageBit::kNone, TextureUsageBit::kCopyDestination,
 								   TextureSurfaceDescriptor());
 
 	TransferGpuAllocatorHandle handle0, handle1, handle2;
@@ -2189,11 +2189,11 @@ void main()
 	const Vec4 mip2 = Vec4(2.2f, 3.3f, 4.4f, 5.5f);
 	UPLOAD_TEX_SURFACE(cmdb, texC, TextureSurfaceDescriptor(0, 0, 0, 0), &mip2[0], sizeof(mip2), handle2);
 
-	setTextureSurfaceBarrier(cmdb, texA, TextureUsageBit::kTransferDestination, TextureUsageBit::kStorageComputeRead,
+	setTextureSurfaceBarrier(cmdb, texA, TextureUsageBit::kCopyDestination, TextureUsageBit::kUavComputeRead,
 								   TextureSurfaceDescriptor());
-	setTextureSurfaceBarrier(cmdb, texB, TextureUsageBit::kTransferDestination, TextureUsageBit::kSampledCompute,
+	setTextureSurfaceBarrier(cmdb, texB, TextureUsageBit::kCopyDestination, TextureUsageBit::kSrvCompute,
 								   TextureSurfaceDescriptor());
-	setTextureSurfaceBarrier(cmdb, texC, TextureUsageBit::kTransferDestination, TextureUsageBit::kSampledCompute,
+	setTextureSurfaceBarrier(cmdb, texC, TextureUsageBit::kCopyDestination, TextureUsageBit::kSrvCompute,
 								   TextureSurfaceDescriptor());
 
 	cmdb->bindStorageBuffer(1, 0, resBuff, 0, kMaxPtrSize);
@@ -2482,13 +2482,13 @@ void main()
 		TexturePtr presentTex = g_gr->acquireNextPresentableTexture();
 		FramebufferPtr fb = createColorFb(*g_gr, presentTex);
 
-		setTextureBarrier(cmdb, presentTex, TextureUsageBit::kNone, TextureUsageBit::kFramebufferWrite, TextureSubresourceInfo{});
+		setTextureBarrier(cmdb, presentTex, TextureUsageBit::kNone, TextureUsageBit::kRtvDsvWrite, TextureSubresourceInfo{});
 
-		cmdb->beginRenderPass(fb.get(), {TextureUsageBit::kFramebufferWrite}, {});
+		cmdb->beginRenderPass(fb.get(), {TextureUsageBit::kRtvDsvWrite}, {});
 		cmdb->draw(PrimitiveTopology::kTriangleStrip, 4);
 		cmdb->endRenderPass();
 
-		setTextureBarrier(cmdb, presentTex, TextureUsageBit::kFramebufferWrite, TextureUsageBit::kPresent, TextureSubresourceInfo{});
+		setTextureBarrier(cmdb, presentTex, TextureUsageBit::kRtvDsvWrite, TextureUsageBit::kPresent, TextureSubresourceInfo{});
 
 		cmdb->endRecording();
 		GrManager::getSingleton().submit(cmdb.get());
@@ -2511,7 +2511,7 @@ static void createCubeBuffers(GrManager& gr, Vec3 min, Vec3 max, BufferPtr& inde
 {
 	BufferInitInfo inf;
 	inf.m_mapAccess = BufferMapAccessBit::kWrite;
-	inf.m_usage = BufferUsageBit::kIndex | BufferUsageBit::kVertex | BufferUsageBit::kStorageTraceRaysRead;
+	inf.m_usage = BufferUsageBit::kIndex | BufferUsageBit::kVertex | BufferUsageBit::kSrvTraceRays;
 	inf.m_size = sizeof(Vec3) * 8;
 	vertBuffer = gr.newBuffer(inf);
 	WeakArray<Vec3, PtrSize> positions = vertBuffer->map<Vec3>(0, 8, BufferMapAccessBit::kWrite);
@@ -2637,7 +2637,7 @@ ANKI_TEST(Gr, RayGen)
 		inf.m_width = WIDTH;
 		inf.m_height = HEIGHT;
 		inf.m_format = Format::kR8G8B8A8_Unorm;
-		inf.m_usage = TextureUsageBit::kStorageTraceRaysRead | TextureUsageBit::kStorageTraceRaysWrite | TextureUsageBit::kStorageComputeRead;
+		inf.m_usage = TextureUsageBit::kUavTraceRaysRead | TextureUsageBit::kUavTraceRaysWrite | TextureUsageBit::kUavComputeRead;
 
 		offscreenRts[0] = g_gr->newTexture(inf);
 
@@ -3304,8 +3304,8 @@ void main()
 			offscreenHistoryView = g_gr->newTextureView(inf);
 		}
 
-		setTextureBarrier(cmdb, offscreenRts[i & 1], TextureUsageBit::kNone, TextureUsageBit::kStorageTraceRaysWrite, TextureSubresourceInfo());
-		setTextureBarrier(cmdb, offscreenRts[(i + 1) & 1], TextureUsageBit::kStorageComputeRead, TextureUsageBit::kStorageTraceRaysRead,
+		setTextureBarrier(cmdb, offscreenRts[i & 1], TextureUsageBit::kNone, TextureUsageBit::kUavTraceRaysWrite, TextureSubresourceInfo());
+		setTextureBarrier(cmdb, offscreenRts[(i + 1) & 1], TextureUsageBit::kUavComputeRead, TextureUsageBit::kUavTraceRaysRead,
 						  TextureSubresourceInfo());
 
 		cmdb->bindStorageBuffer(0, 0, BufferView(modelBuffer.get()));
@@ -3328,9 +3328,9 @@ void main()
 		cmdb->traceRays(BufferView(sbt.get()), sbtRecordSize, U32(GeomWhat::kCount) * 2, 2, WIDTH, HEIGHT, 1);
 
 		// Copy to present
-		setTextureBarrier(cmdb, offscreenRts[i & 1], TextureUsageBit::kStorageTraceRaysWrite, TextureUsageBit::kStorageComputeRead,
+		setTextureBarrier(cmdb, offscreenRts[i & 1], TextureUsageBit::kUavTraceRaysWrite, TextureUsageBit::kUavComputeRead,
 						  TextureSubresourceInfo());
-		setTextureBarrier(cmdb, presentTex, TextureUsageBit::kNone, TextureUsageBit::kStorageComputeWrite, TextureSubresourceInfo());
+		setTextureBarrier(cmdb, presentTex, TextureUsageBit::kNone, TextureUsageBit::kUavCompute, TextureSubresourceInfo());
 
 		cmdb->bindStorageTexture(0, 0, offscreenView.get());
 		cmdb->bindStorageTexture(0, 1, presentView.get());
@@ -3340,7 +3340,7 @@ void main()
 		const U32 sizeY = (HEIGHT + 8 - 1) / 8;
 		cmdb->dispatchCompute(sizeX, sizeY, 1);
 
-		setTextureBarrier(cmdb, presentTex, TextureUsageBit::kStorageComputeWrite, TextureUsageBit::kPresent, TextureSubresourceInfo());
+		setTextureBarrier(cmdb, presentTex, TextureUsageBit::kUavCompute, TextureUsageBit::kPresent, TextureSubresourceInfo());
 
 		cmdb->endRecording();
 		GrManager::getSingleton().submit(cmdb.get());

Tests/Gr/GrCommon.h

@@ -108,7 +108,7 @@ template<typename T>
 inline BufferPtr createBuffer(BufferUsageBit usage, ConstWeakArray<T> data, CString name = {})
 {
 	BufferPtr copyBuff =
-		GrManager::getSingleton().newBuffer(BufferInitInfo(data.getSizeInBytes(), BufferUsageBit::kTransferSource, BufferMapAccessBit::kWrite));
+		GrManager::getSingleton().newBuffer(BufferInitInfo(data.getSizeInBytes(), BufferUsageBit::kCopySource, BufferMapAccessBit::kWrite));
 
 	T* inData = static_cast<T*>(copyBuff->map(0, kMaxPtrSize, BufferMapAccessBit::kWrite));
 	for(U32 i = 0; i < data.getSize(); ++i)
@@ -118,7 +118,7 @@ inline BufferPtr createBuffer(BufferUsageBit usage, ConstWeakArray<T> data, CStr
 	copyBuff->unmap();
 
 	BufferPtr buff = GrManager::getSingleton().newBuffer(BufferInitInfo(
-		data.getSizeInBytes(), usage | BufferUsageBit::kTransferDestination | BufferUsageBit::kTransferSource, BufferMapAccessBit::kNone, name));
+		data.getSizeInBytes(), usage | BufferUsageBit::kCopyDestination | BufferUsageBit::kCopySource, BufferMapAccessBit::kNone, name));
 
 	CommandBufferInitInfo cmdbInit;
 	cmdbInit.m_flags |= CommandBufferFlag::kSmallBatch;
@@ -152,7 +152,6 @@ inline TexturePtr createTexture2d(const TextureInitInfo texInit_, ConstWeakArray
 	buffInit.m_size = texInit.m_height * texInit.m_width * getFormatInfo(texInit.m_format).m_texelSize;
 	ANKI_ASSERT(getFormatInfo(texInit.m_format).m_texelSize == sizeof(T));
 	ANKI_ASSERT(buffInit.m_size == data.getSizeInBytes());
-	buffInit.m_usage = BufferUsageBit::kTransferSource;
 
 	BufferPtr staging = GrManager::getSingleton().newBuffer(buffInit);
 
@@ -200,7 +199,7 @@ inline void readBuffer(BufferPtr buff, DynamicArray<T>& out)
 		BufferInitInfo buffInit;
 		buffInit.m_mapAccess = BufferMapAccessBit::kRead;
 		buffInit.m_size = buff->getSize();
-		buffInit.m_usage = BufferUsageBit::kTransferDestination;
+		buffInit.m_usage = BufferUsageBit::kCopyDestination;
 		tmpBuff = GrManager::getSingleton().newBuffer(buffInit);
 
 		CommandBufferPtr cmdb =

Tests/Gr/GrMeshShaders.cpp

@@ -137,7 +137,7 @@ float3 main(VertOut input) : SV_TARGET0
 		{
 			BufferInitInfo buffInit("Index");
 			buffInit.m_mapAccess = BufferMapAccessBit::kWrite;
-			buffInit.m_usage = BufferUsageBit::kStorageGeometryRead;
+			buffInit.m_usage = BufferUsageBit::kSrvGeometry;
 			buffInit.m_size = sizeof(U32) * 6;
 			indexBuff = GrManager::getSingleton().newBuffer(buffInit);
 
@@ -151,7 +151,7 @@ float3 main(VertOut input) : SV_TARGET0
 		{
 			BufferInitInfo buffInit("Positions");
 			buffInit.m_mapAccess = BufferMapAccessBit::kWrite;
-			buffInit.m_usage = BufferUsageBit::kStorageGeometryRead;
+			buffInit.m_usage = BufferUsageBit::kSrvGeometry;
 			buffInit.m_size = kVertCount * sizeof(Vec4) * kTileCount;
 			positionsBuff = GrManager::getSingleton().newBuffer(buffInit);
 
@@ -176,7 +176,7 @@ float3 main(VertOut input) : SV_TARGET0
 		{
 			BufferInitInfo buffInit("Colors");
 			buffInit.m_mapAccess = BufferMapAccessBit::kWrite;
-			buffInit.m_usage = BufferUsageBit::kStorageGeometryRead;
+			buffInit.m_usage = BufferUsageBit::kSrvGeometry;
 			buffInit.m_size = kVertCount * sizeof(Vec4) * kTileCount;
 			colorsBuff = GrManager::getSingleton().newBuffer(buffInit);
 
@@ -205,7 +205,7 @@ float3 main(VertOut input) : SV_TARGET0
 
 			BufferInitInfo buffInit("Meshlets");
 			buffInit.m_mapAccess = BufferMapAccessBit::kWrite;
-			buffInit.m_usage = BufferUsageBit::kStorageGeometryRead;
+			buffInit.m_usage = BufferUsageBit::kSrvGeometry;
 			buffInit.m_size = sizeof(Meshlet) * kTileCount;
 			meshletsBuff = GrManager::getSingleton().newBuffer(buffInit);
 
@@ -232,7 +232,7 @@ float3 main(VertOut input) : SV_TARGET0
 			TextureBarrierInfo barrier;
 			barrier.m_textureView = TextureView(swapchainTex.get(), TextureSubresourceDesc::all());
 			barrier.m_previousUsage = TextureUsageBit::kNone;
-			barrier.m_nextUsage = TextureUsageBit::kFramebufferWrite;
+			barrier.m_nextUsage = TextureUsageBit::kRtvDsvWrite;
 			cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
 			RenderTarget rt;
@@ -251,7 +251,7 @@ float3 main(VertOut input) : SV_TARGET0
 
 			cmdb->endRenderPass();
 
-			barrier.m_previousUsage = TextureUsageBit::kFramebufferWrite;
+			barrier.m_previousUsage = TextureUsageBit::kRtvDsvWrite;
 			barrier.m_nextUsage = TextureUsageBit::kPresent;
 			cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 

Tests/Gr/GrTextureBuffer.cpp

@@ -37,7 +37,7 @@ void main()
 		BufferInitInfo buffInit;
 		buffInit.m_mapAccess = BufferMapAccessBit::kWrite;
 		buffInit.m_size = sizeof(U8) * 4;
-		buffInit.m_usage = BufferUsageBit::kAllTexel;
+		buffInit.m_usage = BufferUsageBit::kAllUav | BufferUsageBit::kAllSrv;
 		BufferPtr texBuff = GrManager::getSingleton().newBuffer(buffInit);
 
 		I8* data = static_cast<I8*>(texBuff->map(0, kMaxPtrSize, BufferMapAccessBit::kWrite));
@@ -51,7 +51,7 @@ void main()
 
 		buffInit.m_mapAccess = BufferMapAccessBit::kRead;
 		buffInit.m_size = sizeof(F32) * 4;
-		buffInit.m_usage = BufferUsageBit::kAllStorage;
+		buffInit.m_usage = BufferUsageBit::kAllUav | BufferUsageBit::kAllSrv;
 		BufferPtr storageBuff = GrManager::getSingleton().newBuffer(buffInit);
 
 		CommandBufferInitInfo cmdbInit;

Tests/Gr/GrWorkGraphs.cpp

@@ -24,7 +24,7 @@ static void clearSwapchain(CommandBufferPtr cmdb = CommandBufferPtr())
 	}
 
 	const TextureBarrierInfo barrier = {TextureView(presentTex.get(), TextureSubresourceDesc::all()), TextureUsageBit::kNone,
-										TextureUsageBit::kFramebufferWrite};
+										TextureUsageBit::kRtvDsvWrite};
 	cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
 	RenderTarget rt;
@@ -33,7 +33,7 @@ static void clearSwapchain(CommandBufferPtr cmdb = CommandBufferPtr())
 	cmdb->beginRenderPass({rt});
 	cmdb->endRenderPass();
 
-	const TextureBarrierInfo barrier2 = {TextureView(presentTex.get(), TextureSubresourceDesc::all()), TextureUsageBit::kFramebufferWrite,
+	const TextureBarrierInfo barrier2 = {TextureView(presentTex.get(), TextureSubresourceDesc::all()), TextureUsageBit::kRtvDsvWrite,
 										 TextureUsageBit::kPresent};
 	cmdb->setPipelineBarrier({&barrier2, 1}, {}, {});
 
@@ -115,11 +115,11 @@ void thirdNode([MaxRecords(32)] GroupNodeInputRecords<ThirdNodeRecord> inp, uint
 		progInit.m_workGraph.m_nodeSpecializations = ConstWeakArray<WorkGraphNodeSpecialization>(&wgSpecialization, 1);
 		ShaderProgramPtr prog = GrManager::getSingleton().newShaderProgram(progInit);
 
-		BufferPtr counterBuff = createBuffer(BufferUsageBit::kAllStorage | BufferUsageBit::kTransferSource, 0u, 1, "CounterBuffer");
+		BufferPtr counterBuff = createBuffer(BufferUsageBit::kAllUav | BufferUsageBit::kCopySource, 0u, 1, "CounterBuffer");
 
 		BufferInitInfo scratchInit("scratch");
 		scratchInit.m_size = prog->getWorkGraphMemoryRequirements();
-		scratchInit.m_usage = BufferUsageBit::kAllStorage;
+		scratchInit.m_usage = BufferUsageBit::kAllUav;
 		BufferPtr scratchBuff = GrManager::getSingleton().newBuffer(scratchInit);
 
 		struct FirstNodeRecord
@@ -352,10 +352,10 @@ void main(uint svDispatchThreadId : SV_DispatchThreadId, uint svGroupIndex : SV_
 
 		printf("Obj count %u, pos count %u\n", kObjectCount, positionCount);
 
-		BufferPtr objBuff = createBuffer(BufferUsageBit::kStorageComputeRead, ConstWeakArray(objects), "Objects");
+		BufferPtr objBuff = createBuffer(BufferUsageBit::kSrvCompute, ConstWeakArray(objects), "Objects");
 
 		// AABBs
-		BufferPtr aabbsBuff = createBuffer(BufferUsageBit::kStorageComputeWrite, Aabb(), kObjectCount, "AABBs");
+		BufferPtr aabbsBuff = createBuffer(BufferUsageBit::kUavCompute, Aabb(), kObjectCount, "AABBs");
 
 		// Positions
 		GrDynamicArray<U32> positions;
@@ -378,7 +378,7 @@ void main(uint svDispatchThreadId : SV_DispatchThreadId, uint svGroupIndex : SV_
 			positionCount += obj.m_positionCount;
 		}
 
-		BufferPtr posBuff = createBuffer(BufferUsageBit::kStorageComputeRead, ConstWeakArray(positions), "Positions");
+		BufferPtr posBuff = createBuffer(BufferUsageBit::kSrvCompute, ConstWeakArray(positions), "Positions");
 
 		// Execute
 		for(U32 i = 0; i < ((benchmark) ? 200 : 1); ++i)
@@ -390,7 +390,7 @@ void main(uint svDispatchThreadId : SV_DispatchThreadId, uint svGroupIndex : SV_
 			{
 				BufferInitInfo scratchInit("scratch");
 				scratchInit.m_size = prog->getWorkGraphMemoryRequirements();
-				scratchInit.m_usage = BufferUsageBit::kAllStorage;
+				scratchInit.m_usage = BufferUsageBit::kAllUav;
 				scratchBuff = GrManager::getSingleton().newBuffer(scratchInit);
 			}
 

Tests/Ui/Ui.cpp

@@ -106,7 +106,7 @@ ANKI_TEST(Ui, Ui)
 
 			TextureBarrierInfo barrier;
 			barrier.m_previousUsage = TextureUsageBit::kNone;
-			barrier.m_nextUsage = TextureUsageBit::kFramebufferWrite;
+			barrier.m_nextUsage = TextureUsageBit::kRtvDsvWrite;
 			barrier.m_textureView = TextureView(presentTex.get(), TextureSubresourceDesc::all());
 			cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
@@ -118,7 +118,7 @@ ANKI_TEST(Ui, Ui)
 			canvas->appendToCommandBuffer(*cmdb);
 			cmdb->endRenderPass();
 
-			barrier.m_previousUsage = TextureUsageBit::kFramebufferWrite;
+			barrier.m_previousUsage = TextureUsageBit::kRtvDsvWrite;
 			barrier.m_nextUsage = TextureUsageBit::kPresent;
 			cmdb->setPipelineBarrier({&barrier, 1}, {}, {});