Rename back to Vulkan terminology

AnKi/Core/GpuMemory/GpuReadbackMemoryPool.cpp

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

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::kAllUav | BufferUsageBit::kTransferDestination;
+	BufferUsageBit buffUsage = BufferUsageBit::kAllStorage | BufferUsageBit::kTransferDestination;
 
 	m_pool.init(buffUsage, classes, poolSize, "GpuScene", true);
 
@@ -137,9 +137,9 @@ void GpuSceneMicroPatcher::patchGpuScene(CommandBuffer& cmdb)
 	const RebarAllocation dataToken = RebarTransientMemoryPool::getSingleton().allocateFrame(m_crntFramePatchData.getSizeInBytes(), mapped);
 	memcpy(mapped, &m_crntFramePatchData[0], m_crntFramePatchData.getSizeInBytes());
 
-	cmdb.bindUavBuffer(0, 0, headersToken);
-	cmdb.bindUavBuffer(0, 1, dataToken);
-	cmdb.bindUavBuffer(0, 2, &GpuSceneBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize);
+	cmdb.bindStorageBuffer(0, 0, headersToken);
+	cmdb.bindStorageBuffer(0, 1, dataToken);
+	cmdb.bindStorageBuffer(0, 2, &GpuSceneBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize);
 
 	cmdb.bindShaderProgram(m_grProgram.get());
 

AnKi/Core/GpuMemory/GpuVisibleTransientMemoryPool.h

@@ -74,12 +74,12 @@ private:
 
 	GpuVisibleTransientMemoryPool()
 	{
-		U32 alignment = GrManager::getSingleton().getDeviceCapabilities().m_constantBufferBindOffsetAlignment;
-		alignment = max(alignment, GrManager::getSingleton().getDeviceCapabilities().m_uavBufferBindOffsetAlignment);
+		U32 alignment = GrManager::getSingleton().getDeviceCapabilities().m_uniformBufferBindOffsetAlignment;
+		alignment = max(alignment, GrManager::getSingleton().getDeviceCapabilities().m_storageBufferBindOffsetAlignment);
 		alignment = max(alignment, GrManager::getSingleton().getDeviceCapabilities().m_sbtRecordAlignment);
 		alignment = max(alignment, GrManager::getSingleton().getDeviceCapabilities().m_accelerationStructureBuildScratchOffsetAlignment);
 
-		BufferUsageBit buffUsage = BufferUsageBit::kAllConstant | BufferUsageBit::kAllUav | BufferUsageBit::kIndirectDraw
+		BufferUsageBit buffUsage = BufferUsageBit::kAllUniform | BufferUsageBit::kAllStorage | BufferUsageBit::kIndirectDraw
 								   | BufferUsageBit::kIndirectCompute | BufferUsageBit::kVertex | BufferUsageBit::kTransferDestination;
 		if(GrManager::getSingleton().getDeviceCapabilities().m_rayTracingEnabled)
 		{

AnKi/Core/GpuMemory/RebarTransientMemoryPool.cpp

@@ -30,14 +30,14 @@ void RebarTransientMemoryPool::init()
 	BufferInitInfo buffInit("ReBar");
 	buffInit.m_mapAccess = BufferMapAccessBit::kWrite;
 	buffInit.m_size = g_rebarGpuMemorySizeCvar.get();
-	buffInit.m_usage = BufferUsageBit::kAllConstant | BufferUsageBit::kAllUav | BufferUsageBit::kVertex | BufferUsageBit::kIndex
+	buffInit.m_usage = BufferUsageBit::kAllUniform | BufferUsageBit::kAllStorage | BufferUsageBit::kVertex | BufferUsageBit::kIndex
 					   | BufferUsageBit::kShaderBindingTable | BufferUsageBit::kAllIndirect | BufferUsageBit::kTransferSource;
 	m_buffer = GrManager::getSingleton().newBuffer(buffInit);
 
 	m_bufferSize = buffInit.m_size;
 
-	m_alignment = GrManager::getSingleton().getDeviceCapabilities().m_constantBufferBindOffsetAlignment;
-	m_alignment = max(m_alignment, GrManager::getSingleton().getDeviceCapabilities().m_uavBufferBindOffsetAlignment);
+	m_alignment = GrManager::getSingleton().getDeviceCapabilities().m_uniformBufferBindOffsetAlignment;
+	m_alignment = max(m_alignment, GrManager::getSingleton().getDeviceCapabilities().m_storageBufferBindOffsetAlignment);
 	m_alignment = max(m_alignment, GrManager::getSingleton().getDeviceCapabilities().m_sbtRecordAlignment);
 
 	m_mappedMem = static_cast<U8*>(m_buffer->map(0, kMaxPtrSize, BufferMapAccessBit::kWrite));

AnKi/Core/GpuMemory/UnifiedGeometryBuffer.cpp

@@ -25,7 +25,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::kAllTexture & BufferUsageBit::kAllRead) | (BufferUsageBit::kAllUav & BufferUsageBit::kAllRead);
+							   | (BufferUsageBit::kAllTexel & BufferUsageBit::kAllRead) | (BufferUsageBit::kAllStorage & BufferUsageBit::kAllRead);
 
 	if(GrManager::getSingleton().getDeviceCapabilities().m_rayTracingEnabled)
 	{

AnKi/Gr/CommandBuffer.h

@@ -203,16 +203,16 @@ public:
 	/// @param offset The base of the binding.
 	/// @param range The bytes to bind starting from the offset. If it's kMaxPtrSize then map from offset to the end of the buffer.
 	/// @param arrayIdx The array index if the binding is an array.
-	void bindConstantBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, U32 arrayIdx = 0);
+	void bindUniformBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, U32 arrayIdx = 0);
 
 	/// Bind uniform buffer.
 	/// @param set The set to bind to.
 	/// @param binding The binding to bind to.
 	/// @param[in,out] buff The buffer to bind.
 	/// @param arrayIdx The array index if the binding is an array.
-	void bindConstantBuffer(U32 set, U32 binding, const BufferOffsetRange& buff, U32 arrayIdx = 0)
+	void bindUniformBuffer(U32 set, U32 binding, const BufferOffsetRange& buff, U32 arrayIdx = 0)
 	{
-		bindConstantBuffer(set, binding, buff.m_buffer, buff.m_offset, buff.m_range, arrayIdx);
+		bindUniformBuffer(set, binding, buff.m_buffer, buff.m_offset, buff.m_range, arrayIdx);
 	}
 
 	/// Bind storage buffer.
@@ -223,16 +223,16 @@ public:
 	/// @param range The bytes to bind starting from the offset. If it's kMaxPtrSize then map from offset to the end
 	///              of the buffer.
 	/// @param arrayIdx The array index if the binding is an array.
-	void bindUavBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, U32 arrayIdx = 0);
+	void bindStorageBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, U32 arrayIdx = 0);
 
 	/// Bind storage buffer.
 	/// @param set The set to bind to.
 	/// @param binding The binding to bind to.
 	/// @param[in,out] buff The buffer to bind.
 	/// @param arrayIdx The array index if the binding is an array.
-	void bindUavBuffer(U32 set, U32 binding, const BufferOffsetRange& buff, U32 arrayIdx = 0)
+	void bindStorageBuffer(U32 set, U32 binding, const BufferOffsetRange& buff, U32 arrayIdx = 0)
 	{
-		bindUavBuffer(set, binding, buff.m_buffer, buff.m_offset, buff.m_range, arrayIdx);
+		bindStorageBuffer(set, binding, buff.m_buffer, buff.m_offset, buff.m_range, arrayIdx);
 	}
 
 	/// Bind load/store image.
@@ -240,7 +240,7 @@ public:
 	/// @param binding The binding to bind to.
 	/// @param img The view to bind.
 	/// @param arrayIdx The array index if the binding is an array.
-	void bindUavTexture(U32 set, U32 binding, TextureView* img, U32 arrayIdx = 0);
+	void bindStorageTexture(U32 set, U32 binding, TextureView* img, U32 arrayIdx = 0);
 
 	/// Bind texture buffer.
 	/// @param set The set to bind to.
@@ -250,7 +250,7 @@ public:
 	/// @param range The bytes to bind starting from the offset. If it's kMaxPtrSize then map from offset to the end of the buffer.
 	/// @param fmt The format of the buffer.
 	/// @param arrayIdx The array index if the binding is an array.
-	void bindReadOnlyTextureBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, Format fmt, U32 arrayIdx = 0);
+	void bindReadOnlyTexelBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, Format fmt, U32 arrayIdx = 0);
 
 	/// Bind an acceleration structure.
 	/// @param set The set to bind to.

AnKi/Gr/Common.h

@@ -145,19 +145,19 @@ class GpuDeviceCapabilities
 {
 public:
 	/// The alignment of offsets when bounding constant buffers.
-	U32 m_constantBufferBindOffsetAlignment = kMaxU32;
+	U32 m_uniformBufferBindOffsetAlignment = kMaxU32;
 
 	/// The max visible range of constant buffers inside the shaders.
-	PtrSize m_constantBufferMaxRange = 0;
+	PtrSize m_uniformBufferMaxRange = 0;
 
-	/// The alignment of offsets when bounding UAV buffers.
-	U32 m_uavBufferBindOffsetAlignment = kMaxU32;
+	/// The alignment of offsets when bounding storage buffers.
+	U32 m_storageBufferBindOffsetAlignment = kMaxU32;
 
-	/// The max visible range of UAV buffers inside the shaders.
-	PtrSize m_uavBufferMaxRange = 0;
+	/// The max visible range of storage buffers inside the shaders.
+	PtrSize m_storageBufferMaxRange = 0;
 
 	/// The alignment of offsets when bounding texture buffers.
-	U32 m_textureBufferBindOffsetAlignment = kMaxU32;
+	U32 m_texelBufferBindOffsetAlignment = kMaxU32;
 
 	/// The max visible range of texture buffers inside the shaders.
 	PtrSize m_textureBufferMaxRange = 0;
@@ -479,14 +479,14 @@ enum class TextureUsageBit : U32
 	kSampledCompute = 1 << 2,
 	kSampledTraceRays = 1 << 3,
 
-	kUavGeometryRead = 1 << 4,
-	kUavGeometryWrite = 1 << 5,
-	kUavFragmentRead = 1 << 6,
-	kUavFragmentWrite = 1 << 7,
-	kUavComputeRead = 1 << 8,
-	kUavComputeWrite = 1 << 9,
-	kUavTraceRaysRead = 1 << 10,
-	kUavTraceRaysWrite = 1 << 11,
+	kStorageGeometryRead = 1 << 4,
+	kStorageGeometryWrite = 1 << 5,
+	kStorageFragmentRead = 1 << 6,
+	kStorageFragmentWrite = 1 << 7,
+	kStorageComputeRead = 1 << 8,
+	kStorageComputeWrite = 1 << 9,
+	kStorageTraceRaysRead = 1 << 10,
+	kStorageTraceRaysWrite = 1 << 11,
 
 	kFramebufferRead = 1 << 12,
 	kFramebufferWrite = 1 << 13,
@@ -499,19 +499,19 @@ enum class TextureUsageBit : U32
 
 	// Derived
 	kAllSampled = kSampledGeometry | kSampledFragment | kSampledCompute | kSampledTraceRays,
-	kAllUav = kUavGeometryRead | kUavGeometryWrite | kUavFragmentRead | kUavFragmentWrite | kUavComputeRead | kUavComputeWrite | kUavTraceRaysRead
-			  | kUavTraceRaysWrite,
+	kAllStorage = kStorageGeometryRead | kStorageGeometryWrite | kStorageFragmentRead | kStorageFragmentWrite | kStorageComputeRead
+				  | kStorageComputeWrite | kStorageTraceRaysRead | kStorageTraceRaysWrite,
 	kAllFramebuffer = kFramebufferRead | kFramebufferWrite,
 
-	kAllGraphics = kSampledGeometry | kSampledFragment | kUavGeometryRead | kUavGeometryWrite | kUavFragmentRead | kUavFragmentWrite
+	kAllGraphics = kSampledGeometry | kSampledFragment | kStorageGeometryRead | kStorageGeometryWrite | kStorageFragmentRead | kStorageFragmentWrite
 				   | kFramebufferRead | kFramebufferWrite | kFramebufferShadingRate,
-	kAllCompute = kSampledCompute | kUavComputeRead | kUavComputeWrite,
+	kAllCompute = kSampledCompute | kStorageComputeRead | kStorageComputeWrite,
 	kAllTransfer = kTransferDestination | kGenerateMipmaps,
 
-	kAllRead = kAllSampled | kUavGeometryRead | kUavFragmentRead | kUavComputeRead | kUavTraceRaysRead | kFramebufferRead | kFramebufferShadingRate
-			   | kPresent | kGenerateMipmaps,
-	kAllWrite =
-		kUavGeometryWrite | kUavFragmentWrite | kUavComputeWrite | kUavTraceRaysWrite | kFramebufferWrite | kTransferDestination | kGenerateMipmaps,
+	kAllRead = kAllSampled | kStorageGeometryRead | kStorageFragmentRead | kStorageComputeRead | kStorageTraceRaysRead | kFramebufferRead
+			   | kFramebufferShadingRate | kPresent | kGenerateMipmaps,
+	kAllWrite = kStorageGeometryWrite | kStorageFragmentWrite | kStorageComputeWrite | kStorageTraceRaysWrite | kFramebufferWrite
+				| kTransferDestination | kGenerateMipmaps,
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(TextureUsageBit)
 
@@ -698,28 +698,28 @@ enum class BufferUsageBit : U64
 {
 	kNone = 0,
 
-	kConstantGeometry = 1ull << 0ull,
-	kConstantFragment = 1ull << 1ull,
-	kConstantCompute = 1ull << 2ull,
-	kConstantTraceRays = 1ull << 3ull,
-
-	kUavGeometryRead = 1ull << 4ull,
-	kUavGeometryWrite = 1ull << 5ull,
-	kUavFragmentRead = 1ull << 6ull,
-	kUavFragmentWrite = 1ull << 7ull,
-	kUavComputeRead = 1ull << 8ull,
-	kUavComputeWrite = 1ull << 9ull,
-	kUavTraceRaysRead = 1ull << 10ull,
-	kUavTraceRaysWrite = 1ull << 11ull,
-
-	kTextureGeometryRead = 1ull << 12ull,
-	kTextureGeometryWrite = 1ull << 13ull,
-	kTextureFragmentRead = 1ull << 14ull,
-	kTextureFragmentWrite = 1ull << 15ull,
-	kTextureComputeRead = 1ull << 16ull,
-	kTextureComputeWrite = 1ull << 17ull,
-	kTextureTraceRaysRead = 1ull << 18ull,
-	kTextureTraceRaysWrite = 1ull << 19ull,
+	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,
@@ -736,27 +736,27 @@ enum class BufferUsageBit : U64
 	kAccelerationStructureBuildScratch = 1ull << 29ull, ///< Used in buildAccelerationStructureXXX commands.
 
 	// Derived
-	kAllConstant = kConstantGeometry | kConstantFragment | kConstantCompute | kConstantTraceRays,
-	kAllUav = kUavGeometryRead | kUavGeometryWrite | kUavFragmentRead | kUavFragmentWrite | kUavComputeRead | kUavComputeWrite | kUavTraceRaysRead
-			  | kUavTraceRaysWrite,
-	kAllTexture = kTextureGeometryRead | kTextureGeometryWrite | kTextureFragmentRead | kTextureFragmentWrite | kTextureComputeRead
-				  | kTextureComputeWrite | kTextureTraceRaysRead | kTextureTraceRaysWrite,
+	kAllUniform = kUniformGeometry | kUniformFragment | kUniformCompute | kUniformTraceRays,
+	kAllStorage = kStorageGeometryRead | kStorageGeometryWrite | kStorageFragmentRead | kStorageFragmentWrite | kStorageComputeRead
+				  | kStorageComputeWrite | kStorageTraceRaysRead | kStorageTraceRaysWrite,
+	kAllTexel = kTexelGeometryRead | kTexelGeometryWrite | kTexelFragmentRead | kTexelFragmentWrite | kTexelComputeRead | kTexelComputeWrite
+				| kTexelTraceRaysRead | kTexelTraceRaysWrite,
 	kAllIndirect = kIndirectCompute | kIndirectDraw | kIndirectTraceRays,
 	kAllTransfer = kTransferSource | kTransferDestination,
 
-	kAllGeometry = kConstantGeometry | kUavGeometryRead | kUavGeometryWrite | kTextureGeometryRead | kTextureGeometryWrite | kIndex | kVertex,
-	kAllFragment = kConstantFragment | kUavFragmentRead | kUavFragmentWrite | kTextureFragmentRead | kTextureFragmentWrite,
+	kAllGeometry = kUniformGeometry | kStorageGeometryRead | kStorageGeometryWrite | kTexelGeometryRead | kTexelGeometryWrite | kIndex | kVertex,
+	kAllFragment = kUniformFragment | kStorageFragmentRead | kStorageFragmentWrite | kTexelFragmentRead | kTexelFragmentWrite,
 	kAllGraphics = kAllGeometry | kAllFragment | kIndirectDraw,
-	kAllCompute = kConstantCompute | kUavComputeRead | kUavComputeWrite | kTextureComputeRead | kTextureComputeWrite | kIndirectCompute,
-	kAllTraceRays = kConstantTraceRays | kUavTraceRaysRead | kUavTraceRaysWrite | kTextureTraceRaysRead | kTextureTraceRaysWrite | kIndirectTraceRays
-					| kShaderBindingTable,
+	kAllCompute = kUniformCompute | kStorageComputeRead | kStorageComputeWrite | kTexelComputeRead | kTexelComputeWrite | kIndirectCompute,
+	kAllTraceRays = kUniformTraceRays | kStorageTraceRaysRead | kStorageTraceRaysWrite | kTexelTraceRaysRead | kTexelTraceRaysWrite
+					| kIndirectTraceRays | kShaderBindingTable,
 
 	kAllRayTracing = kAllTraceRays | kAccelerationStructureBuild | kAccelerationStructureBuildScratch,
-	kAllRead = kAllConstant | kUavGeometryRead | kUavFragmentRead | kUavComputeRead | kUavTraceRaysRead | kTextureGeometryRead | kTextureFragmentRead
-			   | kTextureComputeRead | kTextureTraceRaysRead | kIndex | kVertex | kIndirectCompute | kIndirectDraw | kIndirectTraceRays
-			   | kTransferSource | kAccelerationStructureBuild | kShaderBindingTable,
-	kAllWrite = kUavGeometryWrite | kUavFragmentWrite | kUavComputeWrite | kUavTraceRaysWrite | kTextureGeometryWrite | kTextureFragmentWrite
-				| kTextureComputeWrite | kTextureTraceRaysWrite | kTransferDestination | 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,
 	kAll = kAllRead | kAllWrite,
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(BufferUsageBit)

AnKi/Gr/D3D/D3DCommandBuffer.cpp

@@ -137,17 +137,17 @@ void CommandBuffer::bindSampler(U32 set, U32 binding, Sampler* sampler, U32 arra
 	ANKI_ASSERT(!"TODO");
 }
 
-void CommandBuffer::bindConstantBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, U32 arrayIdx)
+void CommandBuffer::bindUniformBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, U32 arrayIdx)
 {
 	ANKI_ASSERT(!"TODO");
 }
 
-void CommandBuffer::bindUavBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, U32 arrayIdx)
+void CommandBuffer::bindStorageBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, U32 arrayIdx)
 {
 	ANKI_ASSERT(!"TODO");
 }
 
-void CommandBuffer::bindUavTexture(U32 set, U32 binding, TextureView* img, U32 arrayIdx)
+void CommandBuffer::bindStorageTexture(U32 set, U32 binding, TextureView* img, U32 arrayIdx)
 {
 	ANKI_ASSERT(!"TODO");
 }
@@ -157,7 +157,7 @@ void CommandBuffer::bindAccelerationStructure(U32 set, U32 binding, Acceleration
 	ANKI_ASSERT(!"TODO");
 }
 
-void CommandBuffer::bindReadOnlyTextureBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, Format fmt, U32 arrayIdx)
+void CommandBuffer::bindReadOnlyTexelBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, Format fmt, U32 arrayIdx)
 {
 	ANKI_ASSERT(!"TODO");
 }

AnKi/Gr/RenderGraph.h

@@ -157,17 +157,17 @@ public:
 	}
 
 	/// Convenience method.
-	void bindUavTexture(U32 set, U32 binding, RenderTargetHandle handle, const TextureSubresourceInfo& subresource, U32 arrayIdx = 0)
+	void bindStorageTexture(U32 set, U32 binding, RenderTargetHandle handle, const TextureSubresourceInfo& subresource, U32 arrayIdx = 0)
 	{
 		Texture* tex;
 		getRenderTargetState(handle, subresource, tex);
 		TextureViewInitInfo viewInit(tex, subresource, "TmpRenderGraph");
 		TextureViewPtr view = GrManager::getSingleton().newTextureView(viewInit);
-		m_commandBuffer->bindUavTexture(set, binding, view.get(), arrayIdx);
+		m_commandBuffer->bindStorageTexture(set, binding, view.get(), arrayIdx);
 	}
 
 	/// Convenience method to bind the whole image.
-	void bindUavTexture(U32 set, U32 binding, RenderTargetHandle handle, U32 arrayIdx = 0)
+	void bindStorageTexture(U32 set, U32 binding, RenderTargetHandle handle, U32 arrayIdx = 0)
 	{
 		Texture* tex;
 #if ANKI_ASSERTIONS_ENABLED
@@ -178,25 +178,25 @@ public:
 		getRenderTargetState(handle, subresource, tex);
 		TextureViewInitInfo viewInit(tex, subresource, "TmpRenderGraph");
 		TextureViewPtr view = GrManager::getSingleton().newTextureView(viewInit);
-		m_commandBuffer->bindUavTexture(set, binding, view.get(), arrayIdx);
+		m_commandBuffer->bindStorageTexture(set, binding, view.get(), arrayIdx);
 	}
 
 	/// Convenience method.
-	void bindUavBuffer(U32 set, U32 binding, BufferHandle handle)
+	void bindStorageBuffer(U32 set, U32 binding, BufferHandle handle)
 	{
 		Buffer* buff;
 		PtrSize offset, range;
 		getBufferState(handle, buff, offset, range);
-		m_commandBuffer->bindUavBuffer(set, binding, buff, offset, range);
+		m_commandBuffer->bindStorageBuffer(set, binding, buff, offset, range);
 	}
 
 	/// Convenience method.
-	void bindConstantBuffer(U32 set, U32 binding, BufferHandle handle)
+	void bindUniformBuffer(U32 set, U32 binding, BufferHandle handle)
 	{
 		Buffer* buff;
 		PtrSize offset, range;
 		getBufferState(handle, buff, offset, range);
-		m_commandBuffer->bindConstantBuffer(set, binding, buff, offset, range);
+		m_commandBuffer->bindUniformBuffer(set, binding, buff, offset, range);
 	}
 
 	/// Convenience method.

AnKi/Gr/Vulkan/VkBuffer.cpp

@@ -361,17 +361,17 @@ VkAccessFlags BufferImpl::computeAccessMask(BufferUsageBit usage)
 {
 	VkAccessFlags mask = 0;
 
-	constexpr BufferUsageBit kShaderRead = BufferUsageBit::kUavGeometryRead | BufferUsageBit::kUavFragmentRead | BufferUsageBit::kUavComputeRead
-										   | BufferUsageBit::kUavTraceRaysRead | BufferUsageBit::kTextureGeometryRead
-										   | BufferUsageBit::kTextureFragmentRead | BufferUsageBit::kTextureComputeRead
-										   | BufferUsageBit::kTextureTraceRaysRead;
+	constexpr BufferUsageBit kShaderRead = BufferUsageBit::kStorageGeometryRead | BufferUsageBit::kStorageFragmentRead
+										   | BufferUsageBit::kStorageComputeRead | BufferUsageBit::kStorageTraceRaysRead
+										   | BufferUsageBit::kTexelGeometryRead | BufferUsageBit::kTexelFragmentRead
+										   | BufferUsageBit::kTexelComputeRead | BufferUsageBit::kTexelTraceRaysRead;
 
-	constexpr BufferUsageBit kShaderWrite = BufferUsageBit::kUavGeometryWrite | BufferUsageBit::kUavFragmentWrite | BufferUsageBit::kUavComputeWrite
-											| BufferUsageBit::kUavTraceRaysWrite | BufferUsageBit::kTextureGeometryWrite
-											| BufferUsageBit::kTextureFragmentWrite | BufferUsageBit::kTextureComputeWrite
-											| BufferUsageBit::kTextureTraceRaysWrite;
+	constexpr BufferUsageBit kShaderWrite = BufferUsageBit::kStorageGeometryWrite | BufferUsageBit::kStorageFragmentWrite
+											| BufferUsageBit::kStorageComputeWrite | BufferUsageBit::kStorageTraceRaysWrite
+											| BufferUsageBit::kTexelGeometryWrite | BufferUsageBit::kTexelFragmentWrite
+											| BufferUsageBit::kTexelComputeWrite | BufferUsageBit::kTexelTraceRaysWrite;
 
-	if(!!(usage & BufferUsageBit::kAllConstant))
+	if(!!(usage & BufferUsageBit::kAllUniform))
 	{
 		mask |= VK_ACCESS_UNIFORM_READ_BIT;
 	}
@@ -446,10 +446,10 @@ VkBufferView BufferImpl::getOrCreateBufferView(Format fmt, PtrSize offset, PtrSi
 	}
 
 	// Checks
-	ANKI_ASSERT(!!(m_usage & BufferUsageBit::kAllTexture));
+	ANKI_ASSERT(!!(m_usage & BufferUsageBit::kAllTexel));
 	ANKI_ASSERT(offset + range <= m_size);
 
-	ANKI_ASSERT(isAligned(getGrManagerImpl().getDeviceCapabilities().m_textureBufferBindOffsetAlignment, offset) && "Offset not aligned");
+	ANKI_ASSERT(isAligned(getGrManagerImpl().getDeviceCapabilities().m_texelBufferBindOffsetAlignment, offset) && "Offset not aligned");
 
 	ANKI_ASSERT((range % getFormatInfo(fmt).m_texelSize) == 0 && "Range doesn't align with the number of texel elements");
 

AnKi/Gr/Vulkan/VkCommandBuffer.cpp

@@ -279,25 +279,25 @@ void CommandBuffer::bindSampler(U32 set, U32 binding, Sampler* sampler, U32 arra
 	self.m_microCmdb->pushObjectRef(sampler);
 }
 
-void CommandBuffer::bindConstantBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, U32 arrayIdx)
+void CommandBuffer::bindUniformBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, U32 arrayIdx)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
 	self.commandCommon();
-	self.m_dsetState[set].bindConstantBuffer(binding, arrayIdx, buff, offset, range);
+	self.m_dsetState[set].bindUniformBuffer(binding, arrayIdx, buff, offset, range);
 }
 
-void CommandBuffer::bindUavBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, U32 arrayIdx)
+void CommandBuffer::bindStorageBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, U32 arrayIdx)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
 	self.commandCommon();
-	self.m_dsetState[set].bindUavBuffer(binding, arrayIdx, buff, offset, range);
+	self.m_dsetState[set].bindStorageBuffer(binding, arrayIdx, buff, offset, range);
 }
 
-void CommandBuffer::bindUavTexture(U32 set, U32 binding, TextureView* img, U32 arrayIdx)
+void CommandBuffer::bindStorageTexture(U32 set, U32 binding, TextureView* img, U32 arrayIdx)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
 	self.commandCommon();
-	self.m_dsetState[set].bindUavTexture(binding, arrayIdx, img);
+	self.m_dsetState[set].bindStorageTexture(binding, arrayIdx, img);
 
 	const Bool isPresentable = !!(static_cast<const TextureViewImpl&>(*img).getTextureImpl().getTextureUsage() & TextureUsageBit::kPresent);
 	if(isPresentable)
@@ -314,11 +314,11 @@ void CommandBuffer::bindAccelerationStructure(U32 set, U32 binding, Acceleration
 	self.m_microCmdb->pushObjectRef(as);
 }
 
-void CommandBuffer::bindReadOnlyTextureBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, Format fmt, U32 arrayIdx)
+void CommandBuffer::bindReadOnlyTexelBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, Format fmt, U32 arrayIdx)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
 	self.commandCommon();
-	self.m_dsetState[set].bindReadOnlyTextureBuffer(binding, arrayIdx, buff, offset, range, fmt);
+	self.m_dsetState[set].bindReadOnlyTexelBuffer(binding, arrayIdx, buff, offset, range, fmt);
 }
 
 void CommandBuffer::bindAllBindless(U32 set)

AnKi/Gr/Vulkan/VkCommon.cpp

@@ -276,12 +276,12 @@ VkBufferUsageFlags convertBufferUsageBit(BufferUsageBit usageMask)
 
 	const Bool rt = GrManager::getSingleton().getDeviceCapabilities().m_rayTracingEnabled;
 
-	if(!!(usageMask & BufferUsageBit::kAllConstant))
+	if(!!(usageMask & BufferUsageBit::kAllUniform))
 	{
 		out |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
 	}
 
-	if(!!(usageMask & BufferUsageBit::kAllUav))
+	if(!!(usageMask & BufferUsageBit::kAllStorage))
 	{
 		out |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
 	}
@@ -311,12 +311,12 @@ VkBufferUsageFlags convertBufferUsageBit(BufferUsageBit usageMask)
 		out |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
 	}
 
-	if(!!(usageMask & (BufferUsageBit::kAllTexture & BufferUsageBit::kAllRead)))
+	if(!!(usageMask & (BufferUsageBit::kAllTexel & BufferUsageBit::kAllRead)))
 	{
 		out |= VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT;
 	}
 
-	if(!!(usageMask & (BufferUsageBit::kAllTexture & BufferUsageBit::kAllWrite)))
+	if(!!(usageMask & (BufferUsageBit::kAllTexel & BufferUsageBit::kAllWrite)))
 	{
 		out |= VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT;
 	}
@@ -409,7 +409,7 @@ VkImageUsageFlags convertTextureUsage(const TextureUsageBit ak, const Format for
 		out |= VK_IMAGE_USAGE_SAMPLED_BIT;
 	}
 
-	if(!!(ak & TextureUsageBit::kAllUav))
+	if(!!(ak & TextureUsageBit::kAllStorage))
 	{
 		out |= VK_IMAGE_USAGE_STORAGE_BIT;
 	}

AnKi/Gr/Vulkan/VkDescriptorSet.h

@@ -192,7 +192,7 @@ public:
 		setBinding(binding, arrayIdx, b);
 	}
 
-	void bindConstantBuffer(U32 binding, U32 arrayIdx, const Buffer* buff, PtrSize offset, PtrSize range)
+	void bindUniformBuffer(U32 binding, U32 arrayIdx, const Buffer* buff, PtrSize offset, PtrSize range)
 	{
 		ANKI_ASSERT(buff && range > 0);
 		Binding b;
@@ -204,7 +204,7 @@ public:
 		setBinding(binding, arrayIdx, b);
 	}
 
-	void bindUavBuffer(U32 binding, U32 arrayIdx, const Buffer* buff, PtrSize offset, PtrSize range)
+	void bindStorageBuffer(U32 binding, U32 arrayIdx, const Buffer* buff, PtrSize offset, PtrSize range)
 	{
 		ANKI_ASSERT(buff && range > 0);
 		Binding b;
@@ -216,7 +216,7 @@ public:
 		setBinding(binding, arrayIdx, b);
 	}
 
-	void bindReadOnlyTextureBuffer(U32 binding, U32 arrayIdx, const Buffer* buff, PtrSize offset, PtrSize range, Format fmt)
+	void bindReadOnlyTexelBuffer(U32 binding, U32 arrayIdx, const Buffer* buff, PtrSize offset, PtrSize range, Format fmt)
 	{
 		ANKI_ASSERT(buff && range > 0);
 		Binding b;
@@ -226,7 +226,7 @@ public:
 		setBinding(binding, arrayIdx, b);
 	}
 
-	void bindUavTexture(U32 binding, U32 arrayIdx, const TextureView* texView)
+	void bindStorageTexture(U32 binding, U32 arrayIdx, const TextureView* texView)
 	{
 		ANKI_ASSERT(texView);
 		const TextureViewImpl* impl = static_cast<const TextureViewImpl*>(texView);

AnKi/Gr/Vulkan/VkGrManager.cpp

@@ -723,13 +723,13 @@ Error GrManagerImpl::initInstance()
 	ANKI_VK_LOGI("GPU is %s. Vendor identified as %s", m_devProps.properties.deviceName, &kGPUVendorStrings[m_capabilities.m_gpuVendor][0]);
 
 	// Set limits
-	m_capabilities.m_constantBufferBindOffsetAlignment =
+	m_capabilities.m_uniformBufferBindOffsetAlignment =
 		max<U32>(ANKI_SAFE_ALIGNMENT, U32(m_devProps.properties.limits.minUniformBufferOffsetAlignment));
-	m_capabilities.m_constantBufferMaxRange = m_devProps.properties.limits.maxUniformBufferRange;
-	m_capabilities.m_uavBufferBindOffsetAlignment = max<U32>(ANKI_SAFE_ALIGNMENT, U32(m_devProps.properties.limits.minStorageBufferOffsetAlignment));
-	m_capabilities.m_uavBufferMaxRange = m_devProps.properties.limits.maxStorageBufferRange;
-	m_capabilities.m_textureBufferBindOffsetAlignment =
-		max<U32>(ANKI_SAFE_ALIGNMENT, U32(m_devProps.properties.limits.minTexelBufferOffsetAlignment));
+	m_capabilities.m_uniformBufferMaxRange = m_devProps.properties.limits.maxUniformBufferRange;
+	m_capabilities.m_storageBufferBindOffsetAlignment =
+		max<U32>(ANKI_SAFE_ALIGNMENT, U32(m_devProps.properties.limits.minStorageBufferOffsetAlignment));
+	m_capabilities.m_storageBufferMaxRange = m_devProps.properties.limits.maxStorageBufferRange;
+	m_capabilities.m_texelBufferBindOffsetAlignment = max<U32>(ANKI_SAFE_ALIGNMENT, U32(m_devProps.properties.limits.minTexelBufferOffsetAlignment));
 	m_capabilities.m_textureBufferMaxRange = kMaxU32;
 	m_capabilities.m_computeSharedMemorySize = m_devProps.properties.limits.maxComputeSharedMemorySize;
 	m_capabilities.m_maxDrawIndirectCount = m_devProps.properties.limits.maxDrawIndirectCount;

AnKi/Gr/Vulkan/VkSwapchainFactory.cpp

@@ -229,7 +229,7 @@ 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::kUavComputeWrite | TextureUsageBit::kUavTraceRaysWrite | TextureUsageBit::kFramebufferRead
+			init.m_usage = TextureUsageBit::kStorageComputeWrite | TextureUsageBit::kStorageTraceRaysWrite | TextureUsageBit::kFramebufferRead
 						   | TextureUsageBit::kFramebufferWrite | TextureUsageBit::kPresent;
 			init.m_type = TextureType::k2D;
 

AnKi/Gr/Vulkan/VkTexture.cpp

@@ -348,51 +348,51 @@ void TextureImpl::computeBarrierInfo(TextureUsageBit usage, Bool src, U32 level,
 	const Bool depthStencil = !!m_aspect;
 	const Bool rt = getGrManagerImpl().getDeviceCapabilities().m_rayTracingEnabled;
 
-	if(!!(usage & (TextureUsageBit::kSampledGeometry | TextureUsageBit::kUavGeometryRead)))
+	if(!!(usage & (TextureUsageBit::kSampledGeometry | TextureUsageBit::kStorageGeometryRead)))
 	{
 		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::kUavGeometryWrite))
+	if(!!(usage & TextureUsageBit::kStorageGeometryWrite))
 	{
 		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::kUavFragmentRead)))
+	if(!!(usage & (TextureUsageBit::kSampledFragment | TextureUsageBit::kStorageFragmentRead)))
 	{
 		stages |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
 		accesses |= VK_ACCESS_SHADER_READ_BIT;
 	}
 
-	if(!!(usage & TextureUsageBit::kUavFragmentWrite))
+	if(!!(usage & TextureUsageBit::kStorageFragmentWrite))
 	{
 		stages |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
 		accesses |= VK_ACCESS_SHADER_WRITE_BIT;
 	}
 
-	if(!!(usage & (TextureUsageBit::kSampledCompute | TextureUsageBit::kUavComputeRead)))
+	if(!!(usage & (TextureUsageBit::kSampledCompute | TextureUsageBit::kStorageComputeRead)))
 	{
 		stages |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
 		accesses |= VK_ACCESS_SHADER_READ_BIT;
 	}
 
-	if(!!(usage & TextureUsageBit::kUavComputeWrite))
+	if(!!(usage & TextureUsageBit::kStorageComputeWrite))
 	{
 		stages |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
 		accesses |= VK_ACCESS_SHADER_WRITE_BIT;
 	}
 
-	if(!!(usage & (TextureUsageBit::kSampledTraceRays | TextureUsageBit::kUavTraceRaysRead)) && rt)
+	if(!!(usage & (TextureUsageBit::kSampledTraceRays | TextureUsageBit::kStorageTraceRaysRead)) && rt)
 	{
 		stages |= VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
 		accesses |= VK_ACCESS_SHADER_READ_BIT;
 	}
 
-	if(!!(usage & TextureUsageBit::kUavTraceRaysWrite) && rt)
+	if(!!(usage & TextureUsageBit::kStorageTraceRaysWrite) && rt)
 	{
 		stages |= VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
 		accesses |= VK_ACCESS_SHADER_WRITE_BIT;
@@ -520,7 +520,7 @@ VkImageLayout TextureImpl::computeLayout(TextureUsageBit usage, U level) const
 		// SRI
 		out = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR;
 	}
-	else if(!(usage & ~TextureUsageBit::kAllUav))
+	else if(!(usage & ~TextureUsageBit::kAllStorage))
 	{
 		// Only image load/store
 		out = VK_IMAGE_LAYOUT_GENERAL;

AnKi/Renderer/Bloom.cpp

@@ -91,7 +91,7 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 			ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("Bloom Main");
 
 			rpass.newTextureDependency(getRenderer().getDownscaleBlur().getRt(), TextureUsageBit::kSampledCompute, inputTexSubresource);
-			rpass.newTextureDependency(m_runCtx.m_exposureRt, TextureUsageBit::kUavComputeWrite);
+			rpass.newTextureDependency(m_runCtx.m_exposureRt, TextureUsageBit::kStorageComputeWrite);
 
 			prpass = &rpass;
 		}
@@ -120,11 +120,11 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 			const Vec4 consts(g_bloomThresholdCVar.get(), g_bloomScaleCVar.get(), 0.0f, 0.0f);
 			cmdb.setPushConstants(&consts, sizeof(consts));
 
-			rgraphCtx.bindUavTexture(0, 2, getRenderer().getTonemapping().getRt());
+			rgraphCtx.bindStorageTexture(0, 2, getRenderer().getTonemapping().getRt());
 
 			if(g_preferComputeCVar.get())
 			{
-				rgraphCtx.bindUavTexture(0, 3, m_runCtx.m_exposureRt, TextureSubresourceInfo());
+				rgraphCtx.bindStorageTexture(0, 3, m_runCtx.m_exposureRt, TextureSubresourceInfo());
 
 				dispatchPPCompute(cmdb, 8, 8, m_exposure.m_rtDescr.m_width, m_exposure.m_rtDescr.m_height);
 			}
@@ -149,7 +149,7 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 			ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("Bloom Upscale");
 
 			rpass.newTextureDependency(m_runCtx.m_exposureRt, TextureUsageBit::kSampledCompute);
-			rpass.newTextureDependency(m_runCtx.m_upscaleRt, TextureUsageBit::kUavComputeWrite);
+			rpass.newTextureDependency(m_runCtx.m_upscaleRt, TextureUsageBit::kStorageComputeWrite);
 
 			prpass = &rpass;
 		}
@@ -175,7 +175,7 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 
 			if(g_preferComputeCVar.get())
 			{
-				rgraphCtx.bindUavTexture(0, 3, m_runCtx.m_upscaleRt, TextureSubresourceInfo());
+				rgraphCtx.bindStorageTexture(0, 3, m_runCtx.m_upscaleRt, TextureSubresourceInfo());
 
 				dispatchPPCompute(cmdb, 8, 8, m_upscale.m_rtDescr.m_width, m_upscale.m_rtDescr.m_height);
 			}

AnKi/Renderer/ClusterBinning.cpp

@@ -71,9 +71,9 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 		for(GpuSceneNonRenderableObjectType type : EnumIterable<GpuSceneNonRenderableObjectType>())
 		{
 			rpass.newBufferDependency(getRenderer().getPrimaryNonRenderableVisibility().getVisibleIndicesBufferHandle(type),
-									  BufferUsageBit::kUavComputeRead);
+									  BufferUsageBit::kStorageComputeRead);
 		}
-		rpass.newBufferDependency(indirectArgsHandle, BufferUsageBit::kUavComputeWrite);
+		rpass.newBufferDependency(indirectArgsHandle, BufferUsageBit::kStorageComputeWrite);
 		rpass.newBufferDependency(m_runCtx.m_clustersHandle, BufferUsageBit::kTransferDestination);
 
 		rpass.setWork([this, indirectArgsBuff](RenderPassWorkContext& rgraphCtx) {
@@ -87,10 +87,10 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 			for(GpuSceneNonRenderableObjectType type : EnumIterable<GpuSceneNonRenderableObjectType>())
 			{
 				const BufferOffsetRange& buff = getRenderer().getPrimaryNonRenderableVisibility().getVisibleIndicesBuffer(type);
-				cmdb.bindUavBuffer(0, 0, buff.m_buffer, buff.m_offset, buff.m_range, U32(type));
+				cmdb.bindStorageBuffer(0, 0, buff.m_buffer, buff.m_offset, buff.m_range, U32(type));
 			}
 
-			cmdb.bindUavBuffer(0, 1, indirectArgsBuff.m_buffer, indirectArgsBuff.m_offset, indirectArgsBuff.m_range);
+			cmdb.bindStorageBuffer(0, 1, indirectArgsBuff.m_buffer, indirectArgsBuff.m_offset, indirectArgsBuff.m_range);
 
 			cmdb.dispatchCompute(1, 1, 1);
 
@@ -105,7 +105,7 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 		ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("Cluster binning");
 
 		rpass.newBufferDependency(indirectArgsHandle, BufferUsageBit::kIndirectCompute);
-		rpass.newBufferDependency(m_runCtx.m_clustersHandle, BufferUsageBit::kUavComputeWrite);
+		rpass.newBufferDependency(m_runCtx.m_clustersHandle, BufferUsageBit::kStorageComputeWrite);
 
 		rpass.setWork([this, &ctx, indirectArgsBuff](RenderPassWorkContext& rgraphCtx) {
 			CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
@@ -116,7 +116,7 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 				cmdb.bindShaderProgram(m_binningGrProgs[type].get());
 
 				const BufferOffsetRange& idsBuff = getRenderer().getPrimaryNonRenderableVisibility().getVisibleIndicesBuffer(type);
-				cmdb.bindUavBuffer(0, 0, idsBuff.m_buffer, idsBuff.m_offset, idsBuff.m_range);
+				cmdb.bindStorageBuffer(0, 0, idsBuff.m_buffer, idsBuff.m_offset, idsBuff.m_range);
 
 				PtrSize objBufferOffset = 0;
 				PtrSize objBufferRange = 0;
@@ -152,10 +152,11 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 					objBufferRange = kMaxPtrSize;
 				}
 
-				cmdb.bindUavBuffer(0, 1, &GpuSceneBuffer::getSingleton().getBuffer(), objBufferOffset, objBufferRange);
-				cmdb.bindUavBuffer(0, 2, m_runCtx.m_clustersBuffer.m_buffer, m_runCtx.m_clustersBuffer.m_offset, m_runCtx.m_clustersBuffer.m_range);
+				cmdb.bindStorageBuffer(0, 1, &GpuSceneBuffer::getSingleton().getBuffer(), objBufferOffset, objBufferRange);
+				cmdb.bindStorageBuffer(0, 2, m_runCtx.m_clustersBuffer.m_buffer, m_runCtx.m_clustersBuffer.m_offset,
+									   m_runCtx.m_clustersBuffer.m_range);
 
-				struct ClusterBinningConstants
+				struct ClusterBinningUniforms
 				{
 					Vec3 m_cameraOrigin;
 					F32 m_zSplitCountOverFrustumLength;
@@ -172,23 +173,23 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 					I32 m_padding2;
 
 					Mat4 m_invertedViewProjMat;
-				} consts;
+				} unis;
 
-				consts.m_cameraOrigin = ctx.m_matrices.m_cameraTransform.getTranslationPart().xyz();
-				consts.m_zSplitCountOverFrustumLength = F32(getRenderer().getZSplitCount()) / (ctx.m_cameraFar - ctx.m_cameraNear);
-				consts.m_renderingSize = Vec2(getRenderer().getInternalResolution());
-				consts.m_tileCountX = getRenderer().getTileCounts().x();
-				consts.m_tileCount = getRenderer().getTileCounts().x() * getRenderer().getTileCounts().y();
+				unis.m_cameraOrigin = ctx.m_matrices.m_cameraTransform.getTranslationPart().xyz();
+				unis.m_zSplitCountOverFrustumLength = F32(getRenderer().getZSplitCount()) / (ctx.m_cameraFar - ctx.m_cameraNear);
+				unis.m_renderingSize = Vec2(getRenderer().getInternalResolution());
+				unis.m_tileCountX = getRenderer().getTileCounts().x();
+				unis.m_tileCount = getRenderer().getTileCounts().x() * getRenderer().getTileCounts().y();
 
 				Plane nearPlane;
 				extractClipPlane(ctx.m_matrices.m_viewProjection, FrustumPlaneType::kNear, nearPlane);
-				consts.m_nearPlaneWorld = Vec4(nearPlane.getNormal().xyz(), nearPlane.getOffset());
+				unis.m_nearPlaneWorld = Vec4(nearPlane.getNormal().xyz(), nearPlane.getOffset());
 
-				consts.m_zSplitCountMinusOne = getRenderer().getZSplitCount() - 1;
+				unis.m_zSplitCountMinusOne = getRenderer().getZSplitCount() - 1;
 
-				consts.m_invertedViewProjMat = ctx.m_matrices.m_invertedViewProjectionJitter;
+				unis.m_invertedViewProjMat = ctx.m_matrices.m_invertedViewProjectionJitter;
 
-				cmdb.setPushConstants(&consts, sizeof(consts));
+				cmdb.setPushConstants(&unis, sizeof(unis));
 
 				cmdb.dispatchComputeIndirect(indirectArgsBuff.m_buffer, indirectArgsBuffOffset);
 				indirectArgsBuffOffset += sizeof(DispatchIndirectArgs);
@@ -211,7 +212,7 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 		rpass.newBufferDependency(indirectArgsHandle, BufferUsageBit::kIndirectCompute);
 		for(GpuSceneNonRenderableObjectType type : EnumIterable<GpuSceneNonRenderableObjectType>())
 		{
-			rpass.newBufferDependency(m_runCtx.m_packedObjectsHandles[type], BufferUsageBit::kUavComputeWrite);
+			rpass.newBufferDependency(m_runCtx.m_packedObjectsHandles[type], BufferUsageBit::kStorageComputeWrite);
 		}
 
 		rpass.setWork([this, indirectArgsBuff](RenderPassWorkContext& rgraphCtx) {
@@ -256,12 +257,12 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 					objBufferRange = kMaxPtrSize;
 				}
 
-				cmdb.bindUavBuffer(0, 0, &GpuSceneBuffer::getSingleton().getBuffer(), objBufferOffset, objBufferRange);
-				cmdb.bindUavBuffer(0, 1, m_runCtx.m_packedObjectsBuffers[type].m_buffer, m_runCtx.m_packedObjectsBuffers[type].m_offset,
-								   m_runCtx.m_packedObjectsBuffers[type].m_range);
+				cmdb.bindStorageBuffer(0, 0, &GpuSceneBuffer::getSingleton().getBuffer(), objBufferOffset, objBufferRange);
+				cmdb.bindStorageBuffer(0, 1, m_runCtx.m_packedObjectsBuffers[type].m_buffer, m_runCtx.m_packedObjectsBuffers[type].m_offset,
+									   m_runCtx.m_packedObjectsBuffers[type].m_range);
 
 				const BufferOffsetRange& idsBuff = getRenderer().getPrimaryNonRenderableVisibility().getVisibleIndicesBuffer(type);
-				cmdb.bindUavBuffer(0, 2, idsBuff.m_buffer, idsBuff.m_offset, idsBuff.m_range);
+				cmdb.bindStorageBuffer(0, 2, idsBuff.m_buffer, idsBuff.m_offset, idsBuff.m_range);
 
 				cmdb.dispatchComputeIndirect(indirectArgsBuff.m_buffer, indirectArgsBuffOffset);
 				indirectArgsBuffOffset += sizeof(DispatchIndirectArgs);

AnKi/Renderer/Common.h

@@ -87,7 +87,7 @@ public:
 
 	Array<Mat4, kMaxShadowCascades> m_dirLightTextureMatrices;
 
-	BufferOffsetRange m_globalRenderingConstsBuffer;
+	BufferOffsetRange m_globalRenderingUniformsBuffer;
 
 	RenderingContext(StackMemoryPool* pool)
 		: m_renderGraphDescr(pool)

AnKi/Renderer/Dbg.cpp

@@ -133,7 +133,7 @@ void Dbg::drawNonRenderable(GpuSceneNonRenderableObjectType type, U32 objCount,
 	m_nonRenderablesProg->getOrCreateVariant(variantInitInfo, variant);
 	cmdb.bindShaderProgram(&variant->getProgram());
 
-	class Constants
+	class Uniforms
 	{
 	public:
 		Mat4 m_viewProjMat;
@@ -143,8 +143,8 @@ void Dbg::drawNonRenderable(GpuSceneNonRenderableObjectType type, U32 objCount,
 	unis.m_camTrf = ctx.m_matrices.m_cameraTransform;
 	cmdb.setPushConstants(&unis, sizeof(unis));
 
-	cmdb.bindUavBuffer(0, 2, getRenderer().getClusterBinning().getPackedObjectsBuffer(type));
-	cmdb.bindUavBuffer(0, 3, getRenderer().getPrimaryNonRenderableVisibility().getVisibleIndicesBuffer(type));
+	cmdb.bindStorageBuffer(0, 2, getRenderer().getClusterBinning().getPackedObjectsBuffer(type));
+	cmdb.bindStorageBuffer(0, 3, getRenderer().getPrimaryNonRenderableVisibility().getVisibleIndicesBuffer(type));
 
 	cmdb.bindSampler(0, 4, getRenderer().getSamplers().m_trilinearRepeat.get());
 	cmdb.bindTexture(0, 5, &image.getTextureView());
@@ -181,7 +181,7 @@ void Dbg::run(RenderPassWorkContext& rgraphCtx, const RenderingContext& ctx)
 		m_renderablesProg->getOrCreateVariant(variantInitInfo, variant);
 		cmdb.bindShaderProgram(&variant->getProgram());
 
-		class Constants
+		class Uniforms
 		{
 		public:
 			Vec4 m_color;
@@ -195,12 +195,12 @@ void Dbg::run(RenderPassWorkContext& rgraphCtx, const RenderingContext& ctx)
 		cmdb.setVertexAttribute(VertexAttribute::kPosition, 0, Format::kR32G32B32_Sfloat, 0);
 		cmdb.bindIndexBuffer(m_cubeIndicesBuffer.get(), 0, IndexType::kU16);
 
-		cmdb.bindUavBuffer(0, 2, GpuSceneArrays::RenderableBoundingVolumeGBuffer::getSingleton().getBufferOffsetRange());
+		cmdb.bindStorageBuffer(0, 2, GpuSceneArrays::RenderableBoundingVolumeGBuffer::getSingleton().getBufferOffsetRange());
 
 		BufferOffsetRange indicesBuff;
 		BufferHandle dep;
 		getRenderer().getGBuffer().getVisibleAabbsBuffer(indicesBuff, dep);
-		cmdb.bindUavBuffer(0, 3, indicesBuff);
+		cmdb.bindStorageBuffer(0, 3, indicesBuff);
 
 		cmdb.drawIndexed(PrimitiveTopology::kLines, 12 * 2, allAabbCount);
 	}
@@ -211,12 +211,12 @@ void Dbg::run(RenderPassWorkContext& rgraphCtx, const RenderingContext& ctx)
 
 		if(allAabbCount)
 		{
-			cmdb.bindUavBuffer(0, 2, GpuSceneArrays::RenderableBoundingVolumeForward::getSingleton().getBufferOffsetRange());
+			cmdb.bindStorageBuffer(0, 2, GpuSceneArrays::RenderableBoundingVolumeForward::getSingleton().getBufferOffsetRange());
 
 			BufferOffsetRange indicesBuff;
 			BufferHandle dep;
 			getRenderer().getForwardShading().getVisibleAabbsBuffer(indicesBuff, dep);
-			cmdb.bindUavBuffer(0, 3, indicesBuff);
+			cmdb.bindStorageBuffer(0, 3, indicesBuff);
 
 			cmdb.drawIndexed(PrimitiveTopology::kLines, 12 * 2, allAabbCount);
 		}
@@ -264,12 +264,12 @@ void Dbg::populateRenderGraph(RenderingContext& ctx)
 	BufferOffsetRange indicesBuff;
 	BufferHandle dep;
 	getRenderer().getGBuffer().getVisibleAabbsBuffer(indicesBuff, dep);
-	pass.newBufferDependency(dep, BufferUsageBit::kUavGeometryRead);
+	pass.newBufferDependency(dep, BufferUsageBit::kStorageGeometryRead);
 
 	if(GpuSceneArrays::RenderableBoundingVolumeForward::getSingleton().getElementCount())
 	{
 		getRenderer().getForwardShading().getVisibleAabbsBuffer(indicesBuff, dep);
-		pass.newBufferDependency(dep, BufferUsageBit::kUavGeometryRead);
+		pass.newBufferDependency(dep, BufferUsageBit::kStorageGeometryRead);
 	}
 }
 

AnKi/Renderer/DepthDownscale.cpp

@@ -60,7 +60,7 @@ Error DepthDownscale::initInternal()
 	{
 		BufferInitInfo buffInit("Depth downscale counter buffer");
 		buffInit.m_size = sizeof(U32);
-		buffInit.m_usage = BufferUsageBit::kUavComputeWrite | BufferUsageBit::kTransferDestination;
+		buffInit.m_usage = BufferUsageBit::kStorageComputeWrite | BufferUsageBit::kTransferDestination;
 		m_counterBuffer = GrManager::getSingleton().newBuffer(buffInit);
 
 		// Zero it
@@ -123,7 +123,7 @@ void DepthDownscale::populateRenderGraph(RenderingContext& ctx)
 		{
 			TextureSubresourceInfo subresource;
 			subresource.m_firstMipmap = mip;
-			pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kUavComputeWrite, subresource);
+			pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kStorageComputeWrite, subresource);
 		}
 
 		pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
@@ -137,7 +137,7 @@ void DepthDownscale::populateRenderGraph(RenderingContext& ctx)
 			varAU4(rectInfo) = initAU4(0, 0, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
 			SpdSetup(dispatchThreadGroupCountXY, workGroupOffset, numWorkGroupsAndMips, rectInfo, m_mipCount);
 
-			DepthDownscaleConstants pc;
+			DepthDownscaleUniforms pc;
 			pc.m_threadgroupCount = numWorkGroupsAndMips[0];
 			pc.m_mipmapCount = numWorkGroupsAndMips[1];
 			pc.m_srcTexSizeOverOne = 1.0f / Vec2(getRenderer().getInternalResolution());
@@ -156,10 +156,10 @@ void DepthDownscale::populateRenderGraph(RenderingContext& ctx)
 					subresource.m_firstMipmap = 0; // Put something random
 				}
 
-				rgraphCtx.bindUavTexture(0, 0, m_runCtx.m_rt, subresource, mip);
+				rgraphCtx.bindStorageTexture(0, 0, m_runCtx.m_rt, subresource, mip);
 			}
 
-			cmdb.bindUavBuffer(0, 1, m_counterBuffer.get(), 0, sizeof(U32));
+			cmdb.bindStorageBuffer(0, 1, m_counterBuffer.get(), 0, sizeof(U32));
 
 			cmdb.bindSampler(0, 2, getRenderer().getSamplers().m_trilinearClamp.get());
 			rgraphCtx.bindTexture(0, 3, getRenderer().getGBuffer().getDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::kDepth));

AnKi/Renderer/DownscaleBlur.cpp

@@ -38,7 +38,7 @@ Error DownscaleBlur::initInternal()
 	texinit.m_usage = TextureUsageBit::kSampledFragment | TextureUsageBit::kSampledCompute;
 	if(preferCompute)
 	{
-		texinit.m_usage |= TextureUsageBit::kUavComputeWrite;
+		texinit.m_usage |= TextureUsageBit::kStorageComputeWrite;
 	}
 	else
 	{
@@ -96,7 +96,7 @@ void DownscaleBlur::populateRenderGraph(RenderingContext& ctx)
 		}
 
 		const TextureUsageBit readUsage = (g_preferComputeCVar.get()) ? TextureUsageBit::kSampledCompute : TextureUsageBit::kSampledFragment;
-		const TextureUsageBit writeUsage = (g_preferComputeCVar.get()) ? TextureUsageBit::kUavComputeWrite : TextureUsageBit::kFramebufferWrite;
+		const TextureUsageBit writeUsage = (g_preferComputeCVar.get()) ? TextureUsageBit::kStorageComputeWrite : TextureUsageBit::kFramebufferWrite;
 
 		if(i > 0)
 		{
@@ -144,7 +144,7 @@ void DownscaleBlur::run(U32 passIdx, RenderPassWorkContext& rgraphCtx)
 		rgraphCtx.bindColorTexture(0, 1, getRenderer().getLightShading().getRt());
 	}
 
-	rgraphCtx.bindUavTexture(0, 2, getRenderer().getTonemapping().getRt());
+	rgraphCtx.bindStorageTexture(0, 2, getRenderer().getTonemapping().getRt());
 
 	if(g_preferComputeCVar.get())
 	{
@@ -153,7 +153,7 @@ void DownscaleBlur::run(U32 passIdx, RenderPassWorkContext& rgraphCtx)
 
 		TextureSubresourceInfo sampleSubresource;
 		sampleSubresource.m_firstMipmap = passIdx;
-		rgraphCtx.bindUavTexture(0, 3, m_runCtx.m_rt, sampleSubresource);
+		rgraphCtx.bindStorageTexture(0, 3, m_runCtx.m_rt, sampleSubresource);
 
 		dispatchPPCompute(cmdb, 8, 8, vpWidth, vpHeight);
 	}

AnKi/Renderer/ForwardShading.cpp

@@ -79,14 +79,14 @@ void ForwardShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgr
 							  DepthDownscale::kQuarterInternalResolution);
 		rgraphCtx.bindColorTexture(set, U32(MaterialBinding::kLightVolume), getRenderer().getVolumetricLightingAccumulation().getRt());
 
-		cmdb.bindConstantBuffer(set, U32(MaterialBinding::kClusterShadingConstants), ctx.m_globalRenderingConstsBuffer);
+		cmdb.bindUniformBuffer(set, U32(MaterialBinding::kClusterShadingUniforms), ctx.m_globalRenderingUniformsBuffer);
 
-		cmdb.bindUavBuffer(set, U32(MaterialBinding::kClusterShadingLights),
-						   getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kLight));
+		cmdb.bindStorageBuffer(set, U32(MaterialBinding::kClusterShadingLights),
+							   getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kLight));
 
 		rgraphCtx.bindColorTexture(set, U32(MaterialBinding::kClusterShadingLights) + 1, getRenderer().getShadowMapping().getShadowmapRt());
 
-		cmdb.bindUavBuffer(set, U32(MaterialBinding::kClusters), getRenderer().getClusterBinning().getClustersBuffer());
+		cmdb.bindStorageBuffer(set, U32(MaterialBinding::kClusters), getRenderer().getClusterBinning().getClustersBuffer());
 
 		// Draw
 		RenderableDrawerArguments args;

AnKi/Renderer/GBuffer.cpp

@@ -60,7 +60,7 @@ Error GBuffer::initInternal()
 	}
 
 	{
-		const TextureUsageBit usage = TextureUsageBit::kSampledCompute | TextureUsageBit::kUavComputeWrite | TextureUsageBit::kSampledGeometry;
+		const TextureUsageBit usage = TextureUsageBit::kSampledCompute | TextureUsageBit::kStorageComputeWrite | TextureUsageBit::kSampledGeometry;
 
 		TextureInitInfo texinit =
 			getRenderer().create2DRenderTargetInitInfo(g_hzbWidthCVar.get(), g_hzbHeightCVar.get(), Format::kR32_Sfloat, usage, "GBuffer HZB");
@@ -267,7 +267,7 @@ void GBuffer::populateRenderGraph(RenderingContext& ctx)
 		pass.newTextureDependency(m_runCtx.m_hzbRt, TextureUsageBit::kSampledGeometry);
 	}
 
-	pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kUavGeometryRead | BufferUsageBit::kUavFragmentRead);
+	pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kStorageGeometryRead | BufferUsageBit::kStorageFragmentRead);
 
 	// Only add one depedency to the GPU visibility. No need to track all buffers
 	pass.newBufferDependency((meshletVisOut.isFilled()) ? meshletVisOut.m_dependency : visOut.m_dependency, BufferUsageBit::kIndirectDraw);

AnKi/Renderer/GBufferPost.cpp

@@ -68,9 +68,9 @@ void GBufferPost::populateRenderGraph(RenderingContext& ctx)
 
 		cmdb.bindSampler(0, 2, getRenderer().getSamplers().m_trilinearRepeat.get());
 
-		cmdb.bindConstantBuffer(0, 3, ctx.m_globalRenderingConstsBuffer);
-		cmdb.bindUavBuffer(0, 4, getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kDecal));
-		cmdb.bindUavBuffer(0, 5, getRenderer().getClusterBinning().getClustersBuffer());
+		cmdb.bindUniformBuffer(0, 3, ctx.m_globalRenderingUniformsBuffer);
+		cmdb.bindStorageBuffer(0, 4, getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kDecal));
+		cmdb.bindStorageBuffer(0, 5, getRenderer().getClusterBinning().getClustersBuffer());
 
 		cmdb.bindAllBindless(1);
 
@@ -89,9 +89,9 @@ void GBufferPost::populateRenderGraph(RenderingContext& ctx)
 	rpass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSampledFragment,
 							   TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
-	rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kUavFragmentRead);
+	rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kStorageFragmentRead);
 	rpass.newBufferDependency(getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kDecal),
-							  BufferUsageBit::kUavFragmentRead);
+							  BufferUsageBit::kStorageFragmentRead);
 }
 
 } // end namespace anki

AnKi/Renderer/IndirectDiffuseProbes.cpp

@@ -402,7 +402,7 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 				GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass(generateTempPassName("GI: Light shading", cellIdx, "face", f));
 				pass.setFramebufferInfo(fbDescr, {lightShadingRt});
 
-				pass.newBufferDependency(lightVis.m_visiblesBufferHandle, BufferUsageBit::kUavFragmentRead);
+				pass.newBufferDependency(lightVis.m_visiblesBufferHandle, BufferUsageBit::kStorageFragmentRead);
 
 				pass.newTextureDependency(lightShadingRt, TextureUsageBit::kFramebufferWrite, TextureSurfaceInfo(0, 0, f, 0));
 
@@ -464,7 +464,7 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 					dsInfo.m_gbufferDepthRenderTarget = gbufferDepthRt;
 					dsInfo.m_directionalLightShadowmapRenderTarget = shadowsRt;
 					dsInfo.m_skyLutRenderTarget = (getRenderer().getSky().isEnabled()) ? getRenderer().getSky().getSkyLutRt() : RenderTargetHandle();
-					dsInfo.m_globalRendererConsts = rctx.m_globalRenderingConstsBuffer;
+					dsInfo.m_globalRendererConsts = rctx.m_globalRenderingUniformsBuffer;
 					dsInfo.m_renderpassContext = &rgraphCtx;
 
 					m_lightShading.m_deferred.drawLights(dsInfo);
@@ -477,7 +477,7 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 			ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass(generateTempPassName("GI: Irradiance", cellIdx));
 
 			pass.newTextureDependency(lightShadingRt, TextureUsageBit::kSampledCompute);
-			pass.newTextureDependency(irradianceVolume, TextureUsageBit::kUavComputeWrite);
+			pass.newTextureDependency(irradianceVolume, TextureUsageBit::kStorageComputeWrite);
 			for(U32 i = 0; i < kGBufferColorRenderTargetCount - 1; ++i)
 			{
 				pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kSampledCompute);
@@ -499,7 +499,7 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 					rgraphCtx.bindColorTexture(0, 2, gbufferColorRts[i], i);
 				}
 
-				rgraphCtx.bindUavTexture(0, 3, irradianceVolume, TextureSubresourceInfo());
+				rgraphCtx.bindStorageTexture(0, 3, irradianceVolume, TextureSubresourceInfo());
 
 				class
 				{

AnKi/Renderer/LensFlare.cpp

@@ -60,7 +60,7 @@ void LensFlare::populateRenderGraph(RenderingContext& ctx)
 	// Create the pass
 	ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("Lens flare indirect");
 
-	rpass.newBufferDependency(m_runCtx.m_indirectBuffHandle, BufferUsageBit::kUavComputeWrite);
+	rpass.newBufferDependency(m_runCtx.m_indirectBuffHandle, BufferUsageBit::kStorageComputeWrite);
 	rpass.newTextureDependency(getRenderer().getDepthDownscale().getRt(), TextureUsageBit::kSampledCompute,
 							   DepthDownscale::kEighthInternalResolution);
 
@@ -76,14 +76,14 @@ void LensFlare::populateRenderGraph(RenderingContext& ctx)
 		cmdb.setPushConstants(&ctx.m_matrices.m_viewProjectionJitter, sizeof(ctx.m_matrices.m_viewProjectionJitter));
 
 		// Write flare info
-		Vec4* flarePositions = allocateAndBindUav<Vec4>(cmdb, 0, 0, flareCount);
+		Vec4* flarePositions = allocateAndBindStorageBuffer<Vec4>(cmdb, 0, 0, flareCount);
 		for(const LensFlareComponent& comp : SceneGraph::getSingleton().getComponentArrays().getLensFlares())
 		{
 			*flarePositions = Vec4(comp.getWorldPosition(), 1.0f);
 			++flarePositions;
 		}
 
-		rgraphCtx.bindUavBuffer(0, 1, m_runCtx.m_indirectBuffHandle);
+		rgraphCtx.bindStorageBuffer(0, 1, m_runCtx.m_indirectBuffHandle);
 		// Bind neareset because you don't need high quality
 		cmdb.bindSampler(0, 2, getRenderer().getSamplers().m_nearestNearestClamp.get());
 		rgraphCtx.bindTexture(0, 3, getRenderer().getDepthDownscale().getRt(), DepthDownscale::kEighthInternalResolution);
@@ -123,7 +123,7 @@ void LensFlare::runDrawFlares(const RenderingContext& ctx, CommandBuffer& cmdb)
 		U32 spritesCount = max<U32>(1, m_maxSpritesPerFlare);
 
 		// Get uniform memory
-		LensFlareSprite* tmpSprites = allocateAndBindUav<LensFlareSprite>(cmdb, 0, 0, spritesCount);
+		LensFlareSprite* tmpSprites = allocateAndBindStorageBuffer<LensFlareSprite>(cmdb, 0, 0, spritesCount);
 		WeakArray<LensFlareSprite> sprites(tmpSprites, spritesCount);
 
 		// misc

AnKi/Renderer/LightShading.cpp

@@ -122,12 +122,13 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 		cmdb.setDepthWrite(false);
 
 		// Bind all
-		cmdb.bindConstantBuffer(0, 0, ctx.m_globalRenderingConstsBuffer);
-		cmdb.bindUavBuffer(0, 1, getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kLight));
-		cmdb.bindUavBuffer(0, 2, getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kGlobalIlluminationProbe));
-		cmdb.bindUavBuffer(0, 3, getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kReflectionProbe));
+		cmdb.bindUniformBuffer(0, 0, ctx.m_globalRenderingUniformsBuffer);
+		cmdb.bindStorageBuffer(0, 1, getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kLight));
+		cmdb.bindStorageBuffer(0, 2,
+							   getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kGlobalIlluminationProbe));
+		cmdb.bindStorageBuffer(0, 3, getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kReflectionProbe));
 		rgraphCtx.bindColorTexture(0, 4, getRenderer().getShadowMapping().getShadowmapRt());
-		cmdb.bindUavBuffer(0, 5, getRenderer().getClusterBinning().getClustersBuffer());
+		cmdb.bindStorageBuffer(0, 5, getRenderer().getClusterBinning().getClustersBuffer());
 
 		cmdb.bindSampler(0, 6, getRenderer().getSamplers().m_nearestNearestClamp.get());
 		cmdb.bindSampler(0, 7, getRenderer().getSamplers().m_trilinearClamp.get());
@@ -198,7 +199,7 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 
 			cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp.get());
 			rgraphCtx.bindColorTexture(0, 1, getRenderer().getSky().getSkyLutRt());
-			cmdb.bindConstantBuffer(0, 2, ctx.m_globalRenderingConstsBuffer);
+			cmdb.bindUniformBuffer(0, 2, ctx.m_globalRenderingUniformsBuffer);
 		}
 
 		drawQuad(cmdb);
@@ -319,9 +320,9 @@ void LightShading::populateRenderGraph(RenderingContext& ctx)
 							  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 	pass.newTextureDependency(getRenderer().getShadowMapping().getShadowmapRt(), readUsage);
 	pass.newTextureDependency(getRenderer().getShadowmapsResolve().getRt(), readUsage);
-	pass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kUavFragmentRead);
+	pass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kStorageFragmentRead);
 	pass.newBufferDependency(getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kLight),
-							 BufferUsageBit::kUavFragmentRead);
+							 BufferUsageBit::kStorageFragmentRead);
 	pass.newTextureDependency(getRenderer().getSsao().getRt(), readUsage);
 	pass.newTextureDependency(getRenderer().getSsr().getRt(), readUsage);
 

AnKi/Renderer/MotionVectors.cpp

@@ -55,7 +55,7 @@ void MotionVectors::populateRenderGraph(RenderingContext& ctx)
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("MotionVectors");
 
 		readUsage = TextureUsageBit::kSampledCompute;
-		writeUsage = TextureUsageBit::kUavComputeWrite;
+		writeUsage = TextureUsageBit::kStorageComputeWrite;
 		ppass = &pass;
 	}
 	else
@@ -78,14 +78,14 @@ void MotionVectors::populateRenderGraph(RenderingContext& ctx)
 		rgraphCtx.bindTexture(0, 1, getRenderer().getGBuffer().getDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 		rgraphCtx.bindColorTexture(0, 2, getRenderer().getGBuffer().getColorRt(3));
 
-		class Constants
+		class Uniforms
 		{
 		public:
 			Mat4 m_currentViewProjMat;
 			Mat4 m_currentInvViewProjMat;
 			Mat4 m_prevViewProjMat;
 		} * pc;
-		pc = allocateAndBindConstants<Constants>(cmdb, 0, 3);
+		pc = allocateAndBindConstants<Uniforms>(cmdb, 0, 3);
 
 		pc->m_currentViewProjMat = ctx.m_matrices.m_viewProjection;
 		pc->m_currentInvViewProjMat = ctx.m_matrices.m_invertedViewProjection;
@@ -93,7 +93,7 @@ void MotionVectors::populateRenderGraph(RenderingContext& ctx)
 
 		if(g_preferComputeCVar.get())
 		{
-			rgraphCtx.bindUavTexture(0, 4, m_runCtx.m_motionVectorsRtHandle, TextureSubresourceInfo());
+			rgraphCtx.bindStorageTexture(0, 4, m_runCtx.m_motionVectorsRtHandle, TextureSubresourceInfo());
 		}
 
 		if(g_preferComputeCVar.get())

AnKi/Renderer/ProbeReflections.cpp

@@ -118,7 +118,7 @@ Error ProbeReflections::initIrradiance()
 	// Create buff
 	{
 		BufferInitInfo init;
-		init.m_usage = BufferUsageBit::kAllUav;
+		init.m_usage = BufferUsageBit::kAllStorage;
 		init.m_size = 6 * sizeof(Vec4);
 		m_irradiance.m_diceValuesBuff = GrManager::getSingleton().newBuffer(init);
 	}
@@ -396,7 +396,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 			GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass(generateTempPassName("Cube refl: light shading", f));
 			pass.setFramebufferInfo(fbDescr, {probeTexture});
 
-			pass.newBufferDependency(lightVis.m_visiblesBufferHandle, BufferUsageBit::kUavFragmentRead);
+			pass.newBufferDependency(lightVis.m_visiblesBufferHandle, BufferUsageBit::kStorageFragmentRead);
 			pass.newTextureDependency(probeTexture, TextureUsageBit::kFramebufferWrite, TextureSubresourceInfo(TextureSurfaceInfo(0, 0, f, 0)));
 
 			for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
@@ -443,7 +443,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 					dsInfo.m_directionalLightShadowmapRenderTarget = shadowMapRt;
 				}
 				dsInfo.m_skyLutRenderTarget = getRenderer().getSky().getSkyLutRt();
-				dsInfo.m_globalRendererConsts = rctx.m_globalRenderingConstsBuffer;
+				dsInfo.m_globalRendererConsts = rctx.m_globalRenderingUniformsBuffer;
 				dsInfo.m_renderpassContext = &rgraphCtx;
 
 				m_lightShading.m_deferred.drawLights(dsInfo);
@@ -457,7 +457,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 
 		pass.newTextureDependency(probeTexture, TextureUsageBit::kSampledCompute);
 
-		pass.newBufferDependency(irradianceDiceValuesBuffHandle, BufferUsageBit::kUavComputeWrite);
+		pass.newBufferDependency(irradianceDiceValuesBuffHandle, BufferUsageBit::kStorageComputeWrite);
 
 		pass.setWork([this, probeTexture](RenderPassWorkContext& rgraphCtx) {
 			ANKI_TRACE_SCOPED_EVENT(ProbeReflections);
@@ -470,7 +470,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 
 			rgraphCtx.bindColorTexture(0, 1, probeTexture);
 
-			cmdb.bindUavBuffer(0, 3, m_irradiance.m_diceValuesBuff.get(), 0, m_irradiance.m_diceValuesBuff->getSize());
+			cmdb.bindStorageBuffer(0, 3, m_irradiance.m_diceValuesBuff.get(), 0, m_irradiance.m_diceValuesBuff->getSize());
 
 			cmdb.dispatchCompute(1, 1, 1);
 		});
@@ -485,9 +485,9 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 			pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kSampledCompute);
 		}
 
-		pass.newTextureDependency(probeTexture, TextureUsageBit::kUavComputeRead | TextureUsageBit::kUavComputeWrite);
+		pass.newTextureDependency(probeTexture, TextureUsageBit::kStorageComputeRead | TextureUsageBit::kStorageComputeWrite);
 
-		pass.newBufferDependency(irradianceDiceValuesBuffHandle, BufferUsageBit::kUavComputeRead);
+		pass.newBufferDependency(irradianceDiceValuesBuffHandle, BufferUsageBit::kStorageComputeRead);
 
 		pass.setWork([this, gbufferColorRts, probeTexture](RenderPassWorkContext& rgraphCtx) {
 			ANKI_TRACE_SCOPED_EVENT(ProbeReflections);
@@ -504,14 +504,14 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 				rgraphCtx.bindColorTexture(0, 1, gbufferColorRts[i], i);
 			}
 
-			cmdb.bindUavBuffer(0, 2, m_irradiance.m_diceValuesBuff.get(), 0, m_irradiance.m_diceValuesBuff->getSize());
+			cmdb.bindStorageBuffer(0, 2, m_irradiance.m_diceValuesBuff.get(), 0, m_irradiance.m_diceValuesBuff->getSize());
 
 			for(U8 f = 0; f < 6; ++f)
 			{
 				TextureSubresourceInfo subresource;
 				subresource.m_faceCount = 1;
 				subresource.m_firstFace = f;
-				rgraphCtx.bindUavTexture(0, 3, probeTexture, subresource, f);
+				rgraphCtx.bindStorageTexture(0, 3, probeTexture, subresource, f);
 			}
 
 			dispatchPPCompute(cmdb, 8, 8, m_lightShading.m_tileSize, m_lightShading.m_tileSize);

AnKi/Renderer/Renderer.cpp

@@ -167,7 +167,7 @@ Error Renderer::initInternal(UVec2 swapchainResolution)
 	{
 		TextureInitInfo texinit("RendererDummy");
 		texinit.m_width = texinit.m_height = 4;
-		texinit.m_usage = TextureUsageBit::kAllSampled | TextureUsageBit::kUavComputeWrite;
+		texinit.m_usage = TextureUsageBit::kAllSampled | TextureUsageBit::kStorageComputeWrite;
 		texinit.m_format = Format::kR8G8B8A8_Unorm;
 		TexturePtr tex = createAndClearRenderTarget(texinit, TextureUsageBit::kAllSampled);
 
@@ -181,7 +181,7 @@ Error Renderer::initInternal(UVec2 swapchainResolution)
 		m_dummyTexView3d = GrManager::getSingleton().newTextureView(viewinit);
 
 		m_dummyBuff = GrManager::getSingleton().newBuffer(
-			BufferInitInfo(1024, BufferUsageBit::kAllConstant | BufferUsageBit::kAllUav, BufferMapAccessBit::kNone, "Dummy"));
+			BufferInitInfo(1024, BufferUsageBit::kAllUniform | BufferUsageBit::kAllStorage, BufferMapAccessBit::kNone, "Dummy"));
 	}
 
 	// Init the stages
@@ -291,8 +291,8 @@ Error Renderer::populateRenderGraph(RenderingContext& ctx)
 	ctx.m_cameraFar = cam.getFar();
 
 	// Allocate global constants
-	GlobalRendererConstants* globalConsts;
-	ctx.m_globalRenderingConstsBuffer = RebarTransientMemoryPool::getSingleton().allocateFrame(1, globalConsts);
+	GlobalRendererUniforms* globalUnis;
+	ctx.m_globalRenderingUniformsBuffer = RebarTransientMemoryPool::getSingleton().allocateFrame(1, globalUnis);
 
 	// Import RTs first
 	m_downscaleBlur->importRenderTargets(ctx);
@@ -341,12 +341,12 @@ Error Renderer::populateRenderGraph(RenderingContext& ctx)
 
 	m_finalComposite->populateRenderGraph(ctx);
 
-	writeGlobalRendererConstants(ctx, *globalConsts);
+	writeGlobalRendererConstants(ctx, *globalUnis);
 
 	return Error::kNone;
 }
 
-void Renderer::writeGlobalRendererConstants(RenderingContext& ctx, GlobalRendererConstants& unis)
+void Renderer::writeGlobalRendererConstants(RenderingContext& ctx, GlobalRendererUniforms& unis)
 {
 	ANKI_TRACE_SCOPED_EVENT(RWriteGlobalRendererConstants);
 
@@ -411,7 +411,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::kUavComputeWrite));
+	ANKI_ASSERT(!!(usage & TextureUsageBit::kFramebufferWrite) || !!(usage & TextureUsageBit::kStorageComputeWrite));
 	TextureInitInfo init(name);
 
 	init.m_width = w;
@@ -446,7 +446,7 @@ RenderTargetDescription Renderer::create2DRenderTargetDescription(U32 w, U32 h,
 
 TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, TextureUsageBit initialUsage, const ClearValue& clearVal)
 {
-	ANKI_ASSERT(!!(inf.m_usage & TextureUsageBit::kFramebufferWrite) || !!(inf.m_usage & TextureUsageBit::kUavComputeWrite));
+	ANKI_ASSERT(!!(inf.m_usage & TextureUsageBit::kFramebufferWrite) || !!(inf.m_usage & TextureUsageBit::kStorageComputeWrite));
 
 	const U faceCount = (inf.m_type == TextureType::kCube || inf.m_type == TextureType::kCubeArray) ? 6 : 1;
 
@@ -455,7 +455,7 @@ TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, Text
 	{
 		useCompute = false;
 	}
-	else if(!!(inf.m_usage & TextureUsageBit::kUavComputeWrite))
+	else if(!!(inf.m_usage & TextureUsageBit::kStorageComputeWrite))
 	{
 		useCompute = true;
 	}
@@ -569,9 +569,9 @@ TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, Text
 					cmdb->setPushConstants(&clearVal.m_colorf[0], sizeof(clearVal.m_colorf));
 
 					TextureViewPtr view = GrManager::getSingleton().newTextureView(TextureViewInitInfo(tex.get(), surf));
-					cmdb->bindUavTexture(0, 0, view.get());
+					cmdb->bindStorageTexture(0, 0, view.get());
 
-					const TextureBarrierInfo barrier = {tex.get(), TextureUsageBit::kNone, TextureUsageBit::kUavComputeWrite, surf};
+					const TextureBarrierInfo barrier = {tex.get(), TextureUsageBit::kNone, TextureUsageBit::kStorageComputeWrite, surf};
 					cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
 					UVec3 wgSize;
@@ -583,7 +583,7 @@ TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, Text
 
 					if(!!initialUsage)
 					{
-						const TextureBarrierInfo barrier = {tex.get(), TextureUsageBit::kUavComputeWrite, initialUsage, surf};
+						const TextureBarrierInfo barrier = {tex.get(), TextureUsageBit::kStorageComputeWrite, initialUsage, surf};
 
 						cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 					}
@@ -694,7 +694,7 @@ void Renderer::gpuSceneCopy(RenderingContext& ctx)
 	if(GpuSceneMicroPatcher::getSingleton().patchingIsNeeded())
 	{
 		ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("GPU scene patching");
-		rpass.newBufferDependency(m_runCtx.m_gpuSceneHandle, BufferUsageBit::kUavComputeWrite);
+		rpass.newBufferDependency(m_runCtx.m_gpuSceneHandle, BufferUsageBit::kStorageComputeWrite);
 
 		rpass.setWork([](RenderPassWorkContext& rgraphCtx) {
 			GpuSceneMicroPatcher::getSingleton().patchGpuScene(*rgraphCtx.m_commandBuffer);

AnKi/Renderer/Renderer.h

@@ -280,7 +280,7 @@ private:
 	void updatePipelineStats();
 #endif
 
-	void writeGlobalRendererConstants(RenderingContext& ctx, GlobalRendererConstants& unis);
+	void writeGlobalRendererConstants(RenderingContext& ctx, GlobalRendererUniforms& unis);
 };
 /// @}
 

AnKi/Renderer/RendererObject.h

@@ -67,17 +67,17 @@ protected:
 		T* ptr;
 		const RebarAllocation alloc = RebarTransientMemoryPool::getSingleton().allocateFrame(1, ptr);
 		ANKI_ASSERT(isAligned(alignof(T), ptrToNumber(ptr)));
-		cmdb.bindConstantBuffer(set, binding, alloc);
+		cmdb.bindUniformBuffer(set, binding, alloc);
 		return ptr;
 	}
 
 	template<typename T>
-	static T* allocateAndBindUav(CommandBuffer& cmdb, U32 set, U32 binding, U32 count = 1)
+	static T* allocateAndBindStorageBuffer(CommandBuffer& cmdb, U32 set, U32 binding, U32 count = 1)
 	{
 		T* ptr;
 		const RebarAllocation alloc = RebarTransientMemoryPool::getSingleton().allocateFrame(count, ptr);
 		ANKI_ASSERT(isAligned(alignof(T), ptrToNumber(ptr)));
-		cmdb.bindUavBuffer(set, binding, alloc);
+		cmdb.bindStorageBuffer(set, binding, alloc);
 		return ptr;
 	}
 

AnKi/Renderer/RtShadows.cpp

@@ -98,7 +98,7 @@ Error RtShadows::initInternal()
 	{
 		TextureInitInfo texinit = getRenderer().create2DRenderTargetInitInfo(
 			getRenderer().getInternalResolution().x() / 2, getRenderer().getInternalResolution().y() / 2, Format::kR8_Unorm,
-			TextureUsageBit::kAllSampled | TextureUsageBit::kUavTraceRaysWrite | TextureUsageBit::kUavComputeWrite, "RtShadows History");
+			TextureUsageBit::kAllSampled | TextureUsageBit::kStorageTraceRaysWrite | TextureUsageBit::kStorageComputeWrite, "RtShadows History");
 		m_historyRt = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
 	}
 
@@ -113,7 +113,7 @@ Error RtShadows::initInternal()
 	{
 		TextureInitInfo texinit = getRenderer().create2DRenderTargetInitInfo(
 			getRenderer().getInternalResolution().x() / 2, getRenderer().getInternalResolution().y() / 2, Format::kR32G32_Sfloat,
-			TextureUsageBit::kAllSampled | TextureUsageBit::kUavTraceRaysWrite | TextureUsageBit::kUavComputeWrite, "RtShadows Moments #1");
+			TextureUsageBit::kAllSampled | TextureUsageBit::kStorageTraceRaysWrite | TextureUsageBit::kStorageComputeWrite, "RtShadows Moments #1");
 		m_momentsRts[0] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
 
 		texinit.setName("RtShadows Moments #2");
@@ -138,7 +138,7 @@ Error RtShadows::initInternal()
 	{
 		TextureInitInfo texinit = getRenderer().create2DRenderTargetInitInfo(
 			getRenderer().getInternalResolution().x() / 2, getRenderer().getInternalResolution().y() / 2, Format::kR32_Sfloat,
-			TextureUsageBit::kAllSampled | TextureUsageBit::kUavTraceRaysWrite | TextureUsageBit::kUavComputeWrite, "RtShadows history len");
+			TextureUsageBit::kAllSampled | TextureUsageBit::kStorageTraceRaysWrite | TextureUsageBit::kStorageComputeWrite, "RtShadows history len");
 		ClearValue clear;
 		clear.m_colorf[0] = 1.0f;
 		m_dummyHistoryLenTex = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment, clear);
@@ -212,7 +212,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 	BufferOffsetRange sbtBuildIndirectArgsBuffer;
 	{
 		sbtBuildIndirectArgsBuffer = GpuVisibleTransientMemoryPool::getSingleton().allocate(sizeof(DispatchIndirectArgs));
-		sbtBuildIndirectArgsHandle = rgraph.importBuffer(BufferUsageBit::kUavComputeWrite, sbtBuildIndirectArgsBuffer);
+		sbtBuildIndirectArgsHandle = rgraph.importBuffer(BufferUsageBit::kStorageComputeWrite, sbtBuildIndirectArgsBuffer);
 
 		ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("RtShadows setup build SBT");
 
@@ -224,8 +224,8 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 
 			cmdb.bindShaderProgram(m_setupBuildSbtGrProg.get());
 
-			cmdb.bindUavBuffer(0, 0, GpuSceneArrays::RenderableBoundingVolumeRt::getSingleton().getBufferOffsetRange());
-			cmdb.bindUavBuffer(0, 1, sbtBuildIndirectArgsBuffer);
+			cmdb.bindStorageBuffer(0, 0, GpuSceneArrays::RenderableBoundingVolumeRt::getSingleton().getBufferOffsetRange());
+			cmdb.bindStorageBuffer(0, 1, sbtBuildIndirectArgsBuffer);
 
 			cmdb.dispatchCompute(1, 1, 1);
 		});
@@ -239,7 +239,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 		U8* sbtMem;
 		sbtBuffer = RebarTransientMemoryPool::getSingleton().allocateFrame(
 			(GpuSceneArrays::RenderableBoundingVolumeRt::getSingleton().getElementCount() + 2) * m_sbtRecordSize, sbtMem);
-		sbtHandle = rgraph.importBuffer(BufferUsageBit::kUavComputeWrite, sbtBuffer);
+		sbtHandle = rgraph.importBuffer(BufferUsageBit::kStorageComputeWrite, sbtBuffer);
 
 		// Write the first 2 entries of the SBT
 		ConstWeakArray<U8> shaderGroupHandles = m_rtLibraryGrProg->getShaderGroupHandles();
@@ -254,7 +254,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 		BufferOffsetRange visibleRenderableIndicesBuff;
 		getRenderer().getAccelerationStructureBuilder().getVisibilityInfo(visibilityHandle, visibleRenderableIndicesBuff);
 
-		rpass.newBufferDependency(visibilityHandle, BufferUsageBit::kUavComputeRead);
+		rpass.newBufferDependency(visibilityHandle, BufferUsageBit::kStorageComputeRead);
 		rpass.newBufferDependency(sbtBuildIndirectArgsHandle, BufferUsageBit::kIndirectCompute);
 
 		rpass.setWork([this, sbtBuildIndirectArgsBuffer, sbtBuffer, visibleRenderableIndicesBuff](RenderPassWorkContext& rgraphCtx) {
@@ -263,13 +263,13 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 
 			cmdb.bindShaderProgram(m_buildSbtGrProg.get());
 
-			cmdb.bindUavBuffer(0, 0, GpuSceneArrays::Renderable::getSingleton().getBufferOffsetRange());
-			cmdb.bindUavBuffer(0, 1, &GpuSceneBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize);
-			cmdb.bindUavBuffer(0, 2, visibleRenderableIndicesBuff);
-			cmdb.bindUavBuffer(0, 3, &m_rtLibraryGrProg->getShaderGroupHandlesGpuBuffer(), 0, kMaxPtrSize);
-			cmdb.bindUavBuffer(0, 4, sbtBuffer);
+			cmdb.bindStorageBuffer(0, 0, GpuSceneArrays::Renderable::getSingleton().getBufferOffsetRange());
+			cmdb.bindStorageBuffer(0, 1, &GpuSceneBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize);
+			cmdb.bindStorageBuffer(0, 2, visibleRenderableIndicesBuff);
+			cmdb.bindStorageBuffer(0, 3, &m_rtLibraryGrProg->getShaderGroupHandlesGpuBuffer(), 0, kMaxPtrSize);
+			cmdb.bindStorageBuffer(0, 4, sbtBuffer);
 
-			RtShadowsSbtBuildConstants unis = {};
+			RtShadowsSbtBuildUniforms unis = {};
 			ANKI_ASSERT(m_sbtRecordSize % 4 == 0);
 			unis.m_sbtRecordDwordSize = m_sbtRecordSize / 4;
 			const U32 shaderHandleSize = GrManager::getSingleton().getDeviceCapabilities().m_shaderGroupHandleSize;
@@ -286,7 +286,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 		ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("RtShadows");
 
 		rpass.newTextureDependency(m_runCtx.m_historyRt, TextureUsageBit::kSampledTraceRays);
-		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[0], TextureUsageBit::kUavTraceRaysWrite);
+		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[0], TextureUsageBit::kStorageTraceRaysWrite);
 		rpass.newAccelerationStructureDependency(getRenderer().getAccelerationStructureBuilder().getAccelerationStructureHandle(),
 												 AccelerationStructureUsageBit::kTraceRaysRead);
 		rpass.newTextureDependency(ANKI_DEPTH_DEP);
@@ -294,9 +294,9 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 		rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(2), TextureUsageBit::kSampledTraceRays);
 
 		rpass.newTextureDependency(m_runCtx.m_prevMomentsRt, TextureUsageBit::kSampledTraceRays);
-		rpass.newTextureDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kUavTraceRaysWrite);
+		rpass.newTextureDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kStorageTraceRaysWrite);
 
-		rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kUavTraceRaysRead);
+		rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kStorageTraceRaysRead);
 
 		rpass.setWork([this, sbtBuffer, &ctx](RenderPassWorkContext& rgraphCtx) {
 			ANKI_TRACE_SCOPED_EVENT(RtShadows);
@@ -306,34 +306,34 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 
 			// Allocate, set and bind global uniforms
 			{
-				MaterialGlobalConstants* globalUniforms;
+				MaterialGlobalUniforms* globalUniforms;
 				const RebarAllocation globalUniformsToken = RebarTransientMemoryPool::getSingleton().allocateFrame(1, globalUniforms);
 
 				memset(globalUniforms, 0, sizeof(*globalUniforms)); // Don't care for now
 
-				cmdb.bindConstantBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kGlobalConstants), globalUniformsToken);
+				cmdb.bindUniformBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kGlobalUniforms), globalUniformsToken);
 			}
 
 			// More globals
 			cmdb.bindAllBindless(U32(MaterialSet::kBindless));
 			cmdb.bindSampler(U32(MaterialSet::kGlobal), U32(MaterialBinding::kTrilinearRepeatSampler),
 							 getRenderer().getSamplers().m_trilinearRepeat.get());
-			cmdb.bindUavBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kGpuScene), &GpuSceneBuffer::getSingleton().getBuffer(), 0,
-							   kMaxPtrSize);
+			cmdb.bindStorageBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kGpuScene), &GpuSceneBuffer::getSingleton().getBuffer(), 0,
+								   kMaxPtrSize);
 
 #define ANKI_UNIFIED_GEOM_FORMAT(fmt, shaderType) \
-	cmdb.bindReadOnlyTextureBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kUnifiedGeometry_##fmt), \
-								   &UnifiedGeometryBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize, Format::k##fmt);
+	cmdb.bindReadOnlyTexelBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kUnifiedGeometry_##fmt), \
+								 &UnifiedGeometryBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize, Format::k##fmt);
 #include <AnKi/Shaders/Include/UnifiedGeometryTypes.def.h>
 
 			constexpr U32 kSet = 2;
 
-			cmdb.bindConstantBuffer(kSet, 0, ctx.m_globalRenderingConstsBuffer);
-			cmdb.bindUavBuffer(kSet, 1, getRenderer().getClusterBinning().getClustersBuffer());
+			cmdb.bindUniformBuffer(kSet, 0, ctx.m_globalRenderingUniformsBuffer);
+			cmdb.bindStorageBuffer(kSet, 1, getRenderer().getClusterBinning().getClustersBuffer());
 
 			cmdb.bindSampler(kSet, 2, getRenderer().getSamplers().m_trilinearRepeat.get());
 
-			rgraphCtx.bindUavTexture(kSet, 3, m_runCtx.m_intermediateShadowsRts[0]);
+			rgraphCtx.bindStorageTexture(kSet, 3, m_runCtx.m_intermediateShadowsRts[0]);
 			rgraphCtx.bindColorTexture(kSet, 4, m_runCtx.m_historyRt);
 			cmdb.bindSampler(kSet, 5, getRenderer().getSamplers().m_trilinearClamp.get());
 			rgraphCtx.bindTexture(kSet, 6, getRenderer().getDepthDownscale().getRt(), DepthDownscale::kQuarterInternalResolution);
@@ -342,7 +342,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 			rgraphCtx.bindColorTexture(kSet, 9, getRenderer().getGBuffer().getColorRt(2));
 			rgraphCtx.bindAccelerationStructure(kSet, 10, getRenderer().getAccelerationStructureBuilder().getAccelerationStructureHandle());
 			rgraphCtx.bindColorTexture(kSet, 11, m_runCtx.m_prevMomentsRt);
-			rgraphCtx.bindUavTexture(kSet, 12, m_runCtx.m_currentMomentsRt);
+			rgraphCtx.bindStorageTexture(kSet, 12, m_runCtx.m_currentMomentsRt);
 			cmdb.bindTexture(kSet, 13, &m_blueNoiseImage->getTextureView());
 
 			cmdb.traceRays(sbtBuffer.m_buffer, sbtBuffer.m_offset, m_sbtRecordSize,
@@ -365,7 +365,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 		rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(2), TextureUsageBit::kSampledCompute);
 		rpass.newTextureDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kSampledCompute);
 
-		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[1], TextureUsageBit::kUavComputeWrite);
+		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[1], TextureUsageBit::kStorageComputeWrite);
 	}
 
 	// Denoise pass vertical
@@ -381,7 +381,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 		rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(2), TextureUsageBit::kSampledCompute);
 		rpass.newTextureDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kSampledCompute);
 
-		rpass.newTextureDependency(m_runCtx.m_historyRt, TextureUsageBit::kUavComputeWrite);
+		rpass.newTextureDependency(m_runCtx.m_historyRt, TextureUsageBit::kStorageComputeWrite);
 	}
 
 	// Variance calculation pass
@@ -394,8 +394,8 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 		rpass.newTextureDependency(ANKI_DEPTH_DEP);
 		rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(2), TextureUsageBit::kSampledCompute);
 
-		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[1], TextureUsageBit::kUavComputeWrite);
-		rpass.newTextureDependency(m_runCtx.m_varianceRts[1], TextureUsageBit::kUavComputeWrite);
+		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[1], TextureUsageBit::kStorageComputeWrite);
+		rpass.newTextureDependency(m_runCtx.m_varianceRts[1], TextureUsageBit::kStorageComputeWrite);
 
 		rpass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
 			ANKI_TRACE_SCOPED_EVENT(RtShadows);
@@ -410,8 +410,8 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 			cmdb.bindTexture(0, 3, m_dummyHistoryLenTexView.get());
 			rgraphCtx.bindTexture(0, 4, getRenderer().getDepthDownscale().getRt(), DepthDownscale::kQuarterInternalResolution);
 
-			rgraphCtx.bindUavTexture(0, 5, m_runCtx.m_intermediateShadowsRts[1]);
-			rgraphCtx.bindUavTexture(0, 6, m_runCtx.m_varianceRts[1]);
+			rgraphCtx.bindStorageTexture(0, 5, m_runCtx.m_intermediateShadowsRts[1]);
+			rgraphCtx.bindStorageTexture(0, 6, m_runCtx.m_varianceRts[1]);
 
 			const Mat4& invProjMat = ctx.m_matrices.m_projectionJitter.getInverse();
 			cmdb.setPushConstants(&invProjMat, sizeof(invProjMat));
@@ -437,13 +437,13 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 
 			if(!lastPass)
 			{
-				rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[!readRtIdx], TextureUsageBit::kUavComputeWrite);
+				rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[!readRtIdx], TextureUsageBit::kStorageComputeWrite);
 
-				rpass.newTextureDependency(m_runCtx.m_varianceRts[!readRtIdx], TextureUsageBit::kUavComputeWrite);
+				rpass.newTextureDependency(m_runCtx.m_varianceRts[!readRtIdx], TextureUsageBit::kStorageComputeWrite);
 			}
 			else
 			{
-				rpass.newTextureDependency(m_runCtx.m_historyRt, TextureUsageBit::kUavComputeWrite);
+				rpass.newTextureDependency(m_runCtx.m_historyRt, TextureUsageBit::kStorageComputeWrite);
 			}
 
 			rpass.setWork([this, &ctx, passIdx = i](RenderPassWorkContext& rgraphCtx) {
@@ -471,12 +471,12 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 
 				if(!lastPass)
 				{
-					rgraphCtx.bindUavTexture(0, 5, m_runCtx.m_intermediateShadowsRts[!readRtIdx]);
-					rgraphCtx.bindUavTexture(0, 6, m_runCtx.m_varianceRts[!readRtIdx]);
+					rgraphCtx.bindStorageTexture(0, 5, m_runCtx.m_intermediateShadowsRts[!readRtIdx]);
+					rgraphCtx.bindStorageTexture(0, 6, m_runCtx.m_varianceRts[!readRtIdx]);
 				}
 				else
 				{
-					rgraphCtx.bindUavTexture(0, 5, m_runCtx.m_historyRt);
+					rgraphCtx.bindStorageTexture(0, 5, m_runCtx.m_historyRt);
 				}
 
 				const Mat4& invProjMat = ctx.m_matrices.m_projectionJitter.getInverse();
@@ -495,7 +495,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 		rpass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSampledCompute);
 		rpass.newTextureDependency(ANKI_DEPTH_DEP);
 
-		rpass.newTextureDependency(m_runCtx.m_upscaledRt, TextureUsageBit::kUavComputeWrite);
+		rpass.newTextureDependency(m_runCtx.m_upscaledRt, TextureUsageBit::kStorageComputeWrite);
 
 		rpass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 			ANKI_TRACE_SCOPED_EVENT(RtShadows);
@@ -506,7 +506,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 			cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp.get());
 
 			rgraphCtx.bindColorTexture(0, 1, m_runCtx.m_historyRt);
-			rgraphCtx.bindUavTexture(0, 2, m_runCtx.m_upscaledRt);
+			rgraphCtx.bindStorageTexture(0, 2, m_runCtx.m_upscaledRt);
 			rgraphCtx.bindTexture(0, 3, getRenderer().getDepthDownscale().getRt(), DepthDownscale::kQuarterInternalResolution);
 			rgraphCtx.bindTexture(0, 4, getRenderer().getGBuffer().getDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
@@ -529,9 +529,9 @@ void RtShadows::runDenoise(const RenderingContext& ctx, RenderPassWorkContext& r
 	rgraphCtx.bindColorTexture(0, 4, m_runCtx.m_currentMomentsRt);
 	cmdb.bindTexture(0, 5, m_dummyHistoryLenTexView.get());
 
-	rgraphCtx.bindUavTexture(0, 6, (horizontal) ? m_runCtx.m_intermediateShadowsRts[1] : m_runCtx.m_historyRt);
+	rgraphCtx.bindStorageTexture(0, 6, (horizontal) ? m_runCtx.m_intermediateShadowsRts[1] : m_runCtx.m_historyRt);
 
-	RtShadowsDenoiseConstants consts;
+	RtShadowsDenoiseUniforms consts;
 	consts.m_invViewProjMat = ctx.m_matrices.m_invertedViewProjectionJitter;
 	consts.m_time = F32(GlobalFrameIndex::getSingleton().m_value % 0xFFFFu);
 	consts.m_minSampleCount = 8;

AnKi/Renderer/Scale.cpp

@@ -171,7 +171,7 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 
 		// DLSS says input textures in sampled state and out as storage image
 		const TextureUsageBit readUsage = TextureUsageBit::kAllSampled & TextureUsageBit::kAllCompute;
-		const TextureUsageBit writeUsage = TextureUsageBit::kAllUav & TextureUsageBit::kAllCompute;
+		const TextureUsageBit writeUsage = TextureUsageBit::kAllStorage & TextureUsageBit::kAllCompute;
 
 		pass.newTextureDependency(getRenderer().getLightShading().getRt(), readUsage);
 		pass.newTextureDependency(getRenderer().getMotionVectors().getMotionVectorsRt(), readUsage);
@@ -193,7 +193,7 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		{
 			ComputeRenderPassDescription& pass = ctx.m_renderGraphDescr.newComputeRenderPass("Scale");
 			pass.newTextureDependency(inRt, TextureUsageBit::kSampledCompute);
-			pass.newTextureDependency(outRt, TextureUsageBit::kUavComputeWrite);
+			pass.newTextureDependency(outRt, TextureUsageBit::kStorageComputeWrite);
 
 			pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 				runFsrOrBilinearScaling(rgraphCtx);
@@ -230,7 +230,7 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		{
 			ComputeRenderPassDescription& pass = ctx.m_renderGraphDescr.newComputeRenderPass("Tonemap");
 			pass.newTextureDependency(inRt, TextureUsageBit::kSampledCompute);
-			pass.newTextureDependency(outRt, TextureUsageBit::kUavComputeWrite);
+			pass.newTextureDependency(outRt, TextureUsageBit::kStorageComputeWrite);
 
 			pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 				runTonemapping(rgraphCtx);
@@ -264,7 +264,7 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		{
 			ComputeRenderPassDescription& pass = ctx.m_renderGraphDescr.newComputeRenderPass("Sharpen");
 			pass.newTextureDependency(inRt, TextureUsageBit::kSampledCompute);
-			pass.newTextureDependency(outRt, TextureUsageBit::kUavComputeWrite);
+			pass.newTextureDependency(outRt, TextureUsageBit::kStorageComputeWrite);
 
 			pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 				runRcasSharpening(rgraphCtx);
@@ -305,7 +305,7 @@ void Scale::runFsrOrBilinearScaling(RenderPassWorkContext& rgraphCtx)
 
 	if(preferCompute)
 	{
-		rgraphCtx.bindUavTexture(0, 2, outRt);
+		rgraphCtx.bindStorageTexture(0, 2, outRt);
 	}
 
 	if(m_upscalingMethod == UpscalingMethod::kFsr)
@@ -370,7 +370,7 @@ void Scale::runRcasSharpening(RenderPassWorkContext& rgraphCtx)
 
 	if(preferCompute)
 	{
-		rgraphCtx.bindUavTexture(0, 2, outRt);
+		rgraphCtx.bindStorageTexture(0, 2, outRt);
 	}
 
 	class
@@ -438,7 +438,7 @@ void Scale::runTonemapping(RenderPassWorkContext& rgraphCtx)
 	cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
 	rgraphCtx.bindColorTexture(0, 1, inRt);
 
-	rgraphCtx.bindUavTexture(0, 2, getRenderer().getTonemapping().getRt());
+	rgraphCtx.bindStorageTexture(0, 2, getRenderer().getTonemapping().getRt());
 
 	if(preferCompute)
 	{
@@ -451,7 +451,7 @@ void Scale::runTonemapping(RenderPassWorkContext& rgraphCtx)
 		pc.m_viewportSizeOverOne = 1.0f / Vec2(getRenderer().getPostProcessResolution());
 		pc.m_viewportSize = getRenderer().getPostProcessResolution();
 		cmdb.setPushConstants(&pc, sizeof(pc));
-		rgraphCtx.bindUavTexture(0, 3, outRt);
+		rgraphCtx.bindStorageTexture(0, 3, outRt);
 
 		dispatchPPCompute(cmdb, 8, 8, getRenderer().getPostProcessResolution().x(), getRenderer().getPostProcessResolution().y());
 	}

AnKi/Renderer/ShadowMapping.cpp

@@ -592,7 +592,7 @@ BufferOffsetRange ShadowMapping::createVetVisibilityPass(CString passName, const
 	ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass(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::kUavComputeWrite);
+	pass.newBufferDependency(visOut.m_dependency, BufferUsageBit::kStorageComputeWrite);
 
 	pass.setWork([this, &lightc, hashBuff = visOut.m_visiblesHashBuffer, mdiBuff = visOut.m_legacy.m_mdiDrawCountsBuffer, clearTileIndirectArgs,
 				  taskShadersIndirectArgs = visOut.m_mesh.m_taskShaderIndirectArgsBuffer](RenderPassWorkContext& rpass) {
@@ -603,12 +603,12 @@ BufferOffsetRange ShadowMapping::createVetVisibilityPass(CString passName, const
 		const UVec4 lightIndex(lightc.getGpuSceneLightAllocation().getIndex());
 		cmdb.setPushConstants(&lightIndex, sizeof(lightIndex));
 
-		cmdb.bindUavBuffer(0, 0, hashBuff);
-		cmdb.bindUavBuffer(0, 1, mdiBuff);
-		cmdb.bindUavBuffer(0, 2, GpuSceneArrays::Light::getSingleton().getBufferOffsetRange());
-		cmdb.bindUavBuffer(0, 3, GpuSceneArrays::LightVisibleRenderablesHash::getSingleton().getBufferOffsetRange());
-		cmdb.bindUavBuffer(0, 4, clearTileIndirectArgs);
-		cmdb.bindUavBuffer(0, 5, taskShadersIndirectArgs);
+		cmdb.bindStorageBuffer(0, 0, hashBuff);
+		cmdb.bindStorageBuffer(0, 1, mdiBuff);
+		cmdb.bindStorageBuffer(0, 2, GpuSceneArrays::Light::getSingleton().getBufferOffsetRange());
+		cmdb.bindStorageBuffer(0, 3, GpuSceneArrays::LightVisibleRenderablesHash::getSingleton().getBufferOffsetRange());
+		cmdb.bindStorageBuffer(0, 4, clearTileIndirectArgs);
+		cmdb.bindStorageBuffer(0, 5, taskShadersIndirectArgs);
 
 		ANKI_ASSERT(RenderStateBucketContainer::getSingleton().getBucketCount(RenderingTechnique::kDepth) <= 64 && "TODO");
 		cmdb.dispatchCompute(1, 1, 1);

AnKi/Renderer/ShadowmapsResolve.cpp

@@ -68,14 +68,14 @@ void ShadowmapsResolve::populateRenderGraph(RenderingContext& ctx)
 			run(rgraphCtx, ctx);
 		});
 
-		rpass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kUavComputeWrite);
+		rpass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kStorageComputeWrite);
 		rpass.newTextureDependency((m_quarterRez) ? getRenderer().getDepthDownscale().getRt() : getRenderer().getGBuffer().getDepthRt(),
 								   TextureUsageBit::kSampledCompute, TextureSurfaceInfo(0, 0, 0, 0));
 		rpass.newTextureDependency(getRenderer().getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledCompute);
 
-		rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kUavComputeRead);
+		rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kStorageComputeRead);
 		rpass.newBufferDependency(getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kLight),
-								  BufferUsageBit::kUavComputeRead);
+								  BufferUsageBit::kStorageComputeRead);
 
 		if(getRenderer().getRtShadowsEnabled())
 		{
@@ -96,9 +96,9 @@ void ShadowmapsResolve::populateRenderGraph(RenderingContext& ctx)
 								   TextureUsageBit::kSampledFragment, TextureSurfaceInfo(0, 0, 0, 0));
 		rpass.newTextureDependency(getRenderer().getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledFragment);
 
-		rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kUavFragmentRead);
+		rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kStorageFragmentRead);
 		rpass.newBufferDependency(getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kLight),
-								  BufferUsageBit::kUavFragmentRead);
+								  BufferUsageBit::kStorageFragmentRead);
 
 		if(getRenderer().getRtShadowsEnabled())
 		{
@@ -114,10 +114,10 @@ void ShadowmapsResolve::run(RenderPassWorkContext& rgraphCtx, RenderingContext&
 
 	cmdb.bindShaderProgram(m_grProg.get());
 
-	cmdb.bindConstantBuffer(0, 0, ctx.m_globalRenderingConstsBuffer);
-	cmdb.bindUavBuffer(0, 1, getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kLight));
+	cmdb.bindUniformBuffer(0, 0, ctx.m_globalRenderingUniformsBuffer);
+	cmdb.bindStorageBuffer(0, 1, getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kLight));
 	rgraphCtx.bindColorTexture(0, 2, getRenderer().getShadowMapping().getShadowmapRt());
-	cmdb.bindUavBuffer(0, 3, getRenderer().getClusterBinning().getClustersBuffer());
+	cmdb.bindStorageBuffer(0, 3, getRenderer().getClusterBinning().getClustersBuffer());
 
 	cmdb.bindSampler(0, 4, getRenderer().getSamplers().m_trilinearClamp.get());
 	cmdb.bindSampler(0, 5, getRenderer().getSamplers().m_trilinearClampShadow.get());
@@ -146,7 +146,7 @@ void ShadowmapsResolve::run(RenderPassWorkContext& rgraphCtx, RenderingContext&
 
 	if(g_preferComputeCVar.get())
 	{
-		rgraphCtx.bindUavTexture(0, 10, m_runCtx.m_rt, TextureSubresourceInfo());
+		rgraphCtx.bindStorageTexture(0, 10, m_runCtx.m_rt, TextureSubresourceInfo());
 		dispatchPPCompute(cmdb, 8, 8, m_rtDescr.m_width, m_rtDescr.m_height);
 	}
 	else

AnKi/Renderer/Sky.cpp

@@ -103,7 +103,7 @@ void Sky::populateRenderGraph(RenderingContext& ctx)
 	{
 		ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("SkyTransmittanceLut");
 
-		rpass.newTextureDependency(transmittanceLutRt, TextureUsageBit::kUavComputeWrite);
+		rpass.newTextureDependency(transmittanceLutRt, TextureUsageBit::kStorageComputeWrite);
 
 		rpass.setWork([this, transmittanceLutRt](RenderPassWorkContext& rgraphCtx) {
 			ANKI_TRACE_SCOPED_EVENT(SkyTransmittanceLut);
@@ -112,7 +112,7 @@ void Sky::populateRenderGraph(RenderingContext& ctx)
 
 			cmdb.bindShaderProgram(m_transmittanceLutGrProg.get());
 
-			rgraphCtx.bindUavTexture(0, 0, transmittanceLutRt);
+			rgraphCtx.bindStorageTexture(0, 0, transmittanceLutRt);
 
 			dispatchPPCompute(cmdb, 8, 8, kTransmittanceLutSize.x(), kTransmittanceLutSize.y());
 		});
@@ -124,7 +124,7 @@ void Sky::populateRenderGraph(RenderingContext& ctx)
 		ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("SkyMultipleScatteringLut");
 
 		rpass.newTextureDependency(transmittanceLutRt, TextureUsageBit::kSampledCompute);
-		rpass.newTextureDependency(multipleScatteringLutRt, TextureUsageBit::kUavComputeWrite);
+		rpass.newTextureDependency(multipleScatteringLutRt, TextureUsageBit::kStorageComputeWrite);
 
 		rpass.setWork([this, transmittanceLutRt, multipleScatteringLutRt](RenderPassWorkContext& rgraphCtx) {
 			ANKI_TRACE_SCOPED_EVENT(SkyMultipleScatteringLut);
@@ -135,7 +135,7 @@ void Sky::populateRenderGraph(RenderingContext& ctx)
 
 			rgraphCtx.bindColorTexture(0, 0, transmittanceLutRt);
 			cmdb.bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
-			rgraphCtx.bindUavTexture(0, 2, multipleScatteringLutRt);
+			rgraphCtx.bindStorageTexture(0, 2, multipleScatteringLutRt);
 
 			dispatchPPCompute(cmdb, 8, 8, kMultipleScatteringLutSize.x(), kMultipleScatteringLutSize.y());
 		});
@@ -148,7 +148,7 @@ void Sky::populateRenderGraph(RenderingContext& ctx)
 
 		rpass.newTextureDependency(transmittanceLutRt, TextureUsageBit::kSampledCompute);
 		rpass.newTextureDependency(multipleScatteringLutRt, TextureUsageBit::kSampledCompute);
-		rpass.newTextureDependency(m_runCtx.m_skyLutRt, TextureUsageBit::kUavComputeWrite);
+		rpass.newTextureDependency(m_runCtx.m_skyLutRt, TextureUsageBit::kStorageComputeWrite);
 
 		rpass.setWork([this, transmittanceLutRt, multipleScatteringLutRt, &ctx](RenderPassWorkContext& rgraphCtx) {
 			ANKI_TRACE_SCOPED_EVENT(SkyLut);
@@ -160,8 +160,8 @@ void Sky::populateRenderGraph(RenderingContext& ctx)
 			rgraphCtx.bindColorTexture(0, 0, transmittanceLutRt);
 			rgraphCtx.bindColorTexture(0, 1, multipleScatteringLutRt);
 			cmdb.bindSampler(0, 2, getRenderer().getSamplers().m_trilinearClamp.get());
-			rgraphCtx.bindUavTexture(0, 3, m_runCtx.m_skyLutRt);
-			cmdb.bindConstantBuffer(0, 4, ctx.m_globalRenderingConstsBuffer);
+			rgraphCtx.bindStorageTexture(0, 3, m_runCtx.m_skyLutRt);
+			cmdb.bindUniformBuffer(0, 4, ctx.m_globalRenderingUniformsBuffer);
 
 			dispatchPPCompute(cmdb, 8, 8, kSkyLutSize.x(), kSkyLutSize.y());
 		});
@@ -181,7 +181,7 @@ void Sky::populateRenderGraph(RenderingContext& ctx)
 			cmdb.bindShaderProgram(m_computeSunColorGrProg.get());
 
 			rgraphCtx.bindColorTexture(0, 0, transmittanceLutRt);
-			cmdb.bindUavBuffer(0, 1, ctx.m_globalRenderingConstsBuffer);
+			cmdb.bindStorageBuffer(0, 1, ctx.m_globalRenderingUniformsBuffer);
 
 			cmdb.dispatchCompute(1, 1, 1);
 		});

AnKi/Renderer/Ssao.cpp

@@ -39,7 +39,7 @@ Error Ssao::initInternal()
 
 	{
 		TextureUsageBit usage = TextureUsageBit::kAllSampled;
-		usage |= (preferCompute) ? TextureUsageBit::kUavComputeWrite : TextureUsageBit::kFramebufferWrite;
+		usage |= (preferCompute) ? TextureUsageBit::kStorageComputeWrite : TextureUsageBit::kFramebufferWrite;
 		TextureInitInfo texInit =
 			getRenderer().create2DRenderTargetInitInfo(rez.x(), rez.y(), Format::kR8G8B8A8_Snorm, usage, "Bent normals + SSAO #1");
 		m_tex[0] = getRenderer().createAndClearRenderTarget(texInit, TextureUsageBit::kAllSampled);
@@ -100,7 +100,7 @@ void Ssao::populateRenderGraph(RenderingContext& ctx)
 	if(preferCompute)
 	{
 		readUsage = TextureUsageBit::kSampledCompute;
-		writeUsage = TextureUsageBit::kUavComputeWrite;
+		writeUsage = TextureUsageBit::kStorageComputeWrite;
 	}
 	else
 	{
@@ -141,7 +141,7 @@ void Ssao::populateRenderGraph(RenderingContext& ctx)
 
 			const UVec2 rez = (g_ssaoQuarterRez.get()) ? getRenderer().getInternalResolution() / 2u : getRenderer().getInternalResolution();
 
-			SsaoConstants consts;
+			SsaoUniforms consts;
 			consts.m_radius = g_ssaoRadiusCVar.get();
 			consts.m_sampleCount = g_ssaoSampleCountCVar.get();
 			consts.m_viewportSizef = Vec2(rez);
@@ -157,7 +157,7 @@ void Ssao::populateRenderGraph(RenderingContext& ctx)
 
 			if(g_preferComputeCVar.get())
 			{
-				rgraphCtx.bindUavTexture(0, 5, finalRt);
+				rgraphCtx.bindStorageTexture(0, 5, finalRt);
 
 				dispatchPPCompute(cmdb, 8, 8, rez.x(), rez.y());
 			}
@@ -201,14 +201,14 @@ void Ssao::populateRenderGraph(RenderingContext& ctx)
 
 			const UVec2 rez = (g_ssaoQuarterRez.get()) ? getRenderer().getInternalResolution() / 2u : getRenderer().getInternalResolution();
 
-			SsaoSpatialDenoiseConstants consts;
+			SsaoSpatialDenoiseUniforms consts;
 			computeLinearizeDepthOptimal(ctx.m_cameraNear, ctx.m_cameraFar, consts.m_linearizeDepthParams.x(), consts.m_linearizeDepthParams.y());
 			consts.m_viewToWorldMat = ctx.m_matrices.m_cameraTransform;
 			cmdb.setPushConstants(&consts, sizeof(consts));
 
 			if(g_preferComputeCVar.get())
 			{
-				rgraphCtx.bindUavTexture(0, 3, bentNormalsAndSsaoTempRt);
+				rgraphCtx.bindStorageTexture(0, 3, bentNormalsAndSsaoTempRt);
 				dispatchPPCompute(cmdb, 8, 8, rez.x(), rez.y());
 			}
 			else
@@ -254,7 +254,7 @@ void Ssao::populateRenderGraph(RenderingContext& ctx)
 
 			if(g_preferComputeCVar.get())
 			{
-				rgraphCtx.bindUavTexture(0, 4, finalRt);
+				rgraphCtx.bindStorageTexture(0, 4, finalRt);
 				dispatchPPCompute(cmdb, 8, 8, rez.x(), rez.y());
 			}
 			else

AnKi/Renderer/Ssr.cpp

@@ -54,7 +54,7 @@ Error Ssr::initInternal()
 	TextureUsageBit mipTexUsage = TextureUsageBit::kAllSampled;
 	if(g_preferComputeCVar.get())
 	{
-		mipTexUsage |= TextureUsageBit::kUavComputeWrite;
+		mipTexUsage |= TextureUsageBit::kStorageComputeWrite;
 	}
 	else
 	{
@@ -90,7 +90,7 @@ void Ssr::populateRenderGraph(RenderingContext& ctx)
 		ppass = &pass;
 
 		readUsage = TextureUsageBit::kSampledCompute;
-		writeUsage = TextureUsageBit::kUavComputeWrite;
+		writeUsage = TextureUsageBit::kStorageComputeWrite;
 	}
 	else
 	{
@@ -117,7 +117,7 @@ void Ssr::populateRenderGraph(RenderingContext& ctx)
 
 		cmdb.bindShaderProgram(m_ssrGrProg.get());
 
-		SsrConstants consts = {};
+		SsrUniforms consts = {};
 		consts.m_viewportSizef = Vec2(rez);
 		consts.m_frameCount = getRenderer().getFrameCount() % kMaxU32;
 		consts.m_maxIterations = g_ssrMaxIterationsCVar.get();
@@ -128,7 +128,7 @@ void Ssr::populateRenderGraph(RenderingContext& ctx)
 		consts.m_unprojectionParameters = ctx.m_matrices.m_unprojectionParameters;
 		consts.m_prevViewProjMatMulInvViewProjMat = ctx.m_prevMatrices.m_viewProjection * ctx.m_matrices.m_viewProjectionJitter.getInverse();
 		consts.m_normalMat = Mat3x4(Vec3(0.0f), ctx.m_matrices.m_view.getRotationPart());
-		*allocateAndBindConstants<SsrConstants>(cmdb, 0, 0) = consts;
+		*allocateAndBindConstants<SsrUniforms>(cmdb, 0, 0) = consts;
 
 		cmdb.bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
 		rgraphCtx.bindColorTexture(0, 2, getRenderer().getGBuffer().getColorRt(1));
@@ -138,7 +138,7 @@ void Ssr::populateRenderGraph(RenderingContext& ctx)
 
 		if(g_preferComputeCVar.get())
 		{
-			rgraphCtx.bindUavTexture(0, 6, m_runCtx.m_ssrRt);
+			rgraphCtx.bindStorageTexture(0, 6, m_runCtx.m_ssrRt);
 			dispatchPPCompute(cmdb, 8, 8, rez.x(), rez.y());
 		}
 		else

AnKi/Renderer/TemporalAA.cpp

@@ -34,7 +34,7 @@ Error TemporalAA::initInternal()
 	for(U32 i = 0; i < 2; ++i)
 	{
 		TextureUsageBit usage = TextureUsageBit::kSampledFragment | TextureUsageBit::kSampledCompute;
-		usage |= (g_preferComputeCVar.get()) ? TextureUsageBit::kUavComputeWrite : TextureUsageBit::kFramebufferWrite;
+		usage |= (g_preferComputeCVar.get()) ? TextureUsageBit::kStorageComputeWrite : TextureUsageBit::kFramebufferWrite;
 
 		TextureInitInfo texinit =
 			getRenderer().create2DRenderTargetInitInfo(getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y(),
@@ -85,8 +85,8 @@ void TemporalAA::populateRenderGraph(RenderingContext& ctx)
 	{
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("TemporalAA");
 
-		pass.newTextureDependency(m_runCtx.m_renderRt, TextureUsageBit::kUavComputeWrite);
-		pass.newTextureDependency(m_runCtx.m_tonemappedRt, TextureUsageBit::kUavComputeWrite);
+		pass.newTextureDependency(m_runCtx.m_renderRt, TextureUsageBit::kStorageComputeWrite);
+		pass.newTextureDependency(m_runCtx.m_tonemappedRt, TextureUsageBit::kStorageComputeWrite);
 
 		readUsage = TextureUsageBit::kSampledCompute;
 
@@ -120,12 +120,12 @@ void TemporalAA::populateRenderGraph(RenderingContext& ctx)
 		rgraphCtx.bindColorTexture(0, 1, getRenderer().getLightShading().getRt());
 		rgraphCtx.bindColorTexture(0, 2, m_runCtx.m_historyRt);
 		rgraphCtx.bindColorTexture(0, 3, getRenderer().getMotionVectors().getMotionVectorsRt());
-		rgraphCtx.bindUavTexture(0, 4, getRenderer().getTonemapping().getRt());
+		rgraphCtx.bindStorageTexture(0, 4, getRenderer().getTonemapping().getRt());
 
 		if(g_preferComputeCVar.get())
 		{
-			rgraphCtx.bindUavTexture(0, 5, m_runCtx.m_renderRt, TextureSubresourceInfo());
-			rgraphCtx.bindUavTexture(0, 6, m_runCtx.m_tonemappedRt, TextureSubresourceInfo());
+			rgraphCtx.bindStorageTexture(0, 5, m_runCtx.m_renderRt, TextureSubresourceInfo());
+			rgraphCtx.bindStorageTexture(0, 6, m_runCtx.m_tonemappedRt, TextureSubresourceInfo());
 
 			dispatchPPCompute(cmdb, 8, 8, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
 		}

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::kAllUav;
+	const TextureUsageBit usage = TextureUsageBit::kAllStorage;
 	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::kAllUav, clearValue);
+	m_exposureAndAvgLuminance1x1 = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kAllStorage, clearValue);
 
 	return Error::kNone;
 }
@@ -46,7 +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::kAllUav);
+	m_runCtx.m_exposureLuminanceHandle = ctx.m_renderGraphDescr.importRenderTarget(m_exposureAndAvgLuminance1x1.get(), TextureUsageBit::kAllStorage);
 }
 
 void Tonemapping::populateRenderGraph(RenderingContext& ctx)
@@ -62,7 +62,7 @@ void Tonemapping::populateRenderGraph(RenderingContext& ctx)
 		CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
 		cmdb.bindShaderProgram(m_grProg.get());
-		rgraphCtx.bindUavTexture(0, 1, m_runCtx.m_exposureLuminanceHandle);
+		rgraphCtx.bindStorageTexture(0, 1, m_runCtx.m_exposureLuminanceHandle);
 
 		TextureSubresourceInfo inputTexSubresource;
 		inputTexSubresource.m_firstMipmap = m_inputTexMip;

AnKi/Renderer/Utils/Drawer.cpp

@@ -31,7 +31,7 @@ void RenderableDrawer::setState(const RenderableDrawerArguments& args, CommandBu
 {
 	// Allocate, set and bind global uniforms
 	{
-		MaterialGlobalConstants* globalUniforms;
+		MaterialGlobalUniforms* globalUniforms;
 		const RebarAllocation globalUniformsToken = RebarTransientMemoryPool::getSingleton().allocateFrame(1, globalUniforms);
 
 		globalUniforms->m_viewProjectionMatrix = args.m_viewProjectionMatrix;
@@ -46,32 +46,33 @@ void RenderableDrawer::setState(const RenderableDrawerArguments& args, CommandBu
 
 		globalUniforms->m_enableHzbTesting = args.m_hzbTexture != nullptr;
 
-		cmdb.bindConstantBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kGlobalConstants), globalUniformsToken);
+		cmdb.bindUniformBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kGlobalUniforms), globalUniformsToken);
 	}
 
 	// More globals
 	cmdb.bindAllBindless(U32(MaterialSet::kBindless));
 	cmdb.bindSampler(U32(MaterialSet::kGlobal), U32(MaterialBinding::kTrilinearRepeatSampler), args.m_sampler);
-	cmdb.bindUavBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kGpuScene), &GpuSceneBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize);
+	cmdb.bindStorageBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kGpuScene), &GpuSceneBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize);
 
 #define ANKI_UNIFIED_GEOM_FORMAT(fmt, shaderType) \
-	cmdb.bindReadOnlyTextureBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kUnifiedGeometry_##fmt), \
-								   &UnifiedGeometryBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize, Format::k##fmt);
+	cmdb.bindReadOnlyTexelBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kUnifiedGeometry_##fmt), \
+								 &UnifiedGeometryBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize, Format::k##fmt);
 #include <AnKi/Shaders/Include/UnifiedGeometryTypes.def.h>
 
-	cmdb.bindUavBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kMeshletBoundingVolumes),
-					   UnifiedGeometryBuffer::getSingleton().getBufferOffsetRange());
-	cmdb.bindUavBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kMeshletGeometryDescriptors),
-					   UnifiedGeometryBuffer::getSingleton().getBufferOffsetRange());
+	cmdb.bindStorageBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kMeshletBoundingVolumes),
+						   UnifiedGeometryBuffer::getSingleton().getBufferOffsetRange());
+	cmdb.bindStorageBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kMeshletGeometryDescriptors),
+						   UnifiedGeometryBuffer::getSingleton().getBufferOffsetRange());
 	if(args.m_mesh.m_meshletGroupInstancesBuffer.m_range)
 	{
-		cmdb.bindUavBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kMeshletGroups), args.m_mesh.m_meshletGroupInstancesBuffer);
+		cmdb.bindStorageBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kMeshletGroups), args.m_mesh.m_meshletGroupInstancesBuffer);
 	}
-	cmdb.bindUavBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kRenderables),
-					   GpuSceneArrays::Renderable::getSingleton().getBufferOffsetRange());
-	cmdb.bindUavBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kMeshLods), GpuSceneArrays::MeshLod::getSingleton().getBufferOffsetRange());
-	cmdb.bindUavBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kTransforms),
-					   GpuSceneArrays::Transform::getSingleton().getBufferOffsetRange());
+	cmdb.bindStorageBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kRenderables),
+						   GpuSceneArrays::Renderable::getSingleton().getBufferOffsetRange());
+	cmdb.bindStorageBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kMeshLods),
+						   GpuSceneArrays::MeshLod::getSingleton().getBufferOffsetRange());
+	cmdb.bindStorageBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kTransforms),
+						   GpuSceneArrays::Transform::getSingleton().getBufferOffsetRange());
 	cmdb.bindTexture(U32(MaterialSet::kGlobal), U32(MaterialBinding::kHzbTexture),
 					 (args.m_hzbTexture) ? args.m_hzbTexture : &getRenderer().getDummyTextureView2d());
 	cmdb.bindSampler(U32(MaterialSet::kGlobal), U32(MaterialBinding::kNearestClampSampler), getRenderer().getSamplers().m_nearestNearestClamp.get());

AnKi/Renderer/Utils/GpuVisibility.cpp

@@ -360,9 +360,9 @@ void GpuVisibility::populateRenderGraphInternal(Bool distanceBased, BaseGpuVisib
 
 	ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass(passName.getBegin());
 
-	pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kUavComputeRead);
-	pass.newBufferDependency(zeroStuffDependency, BufferUsageBit::kUavComputeWrite);
-	pass.newBufferDependency(out.m_dependency, BufferUsageBit::kUavComputeWrite);
+	pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kStorageComputeRead);
+	pass.newBufferDependency(zeroStuffDependency, BufferUsageBit::kStorageComputeWrite);
+	pass.newBufferDependency(out.m_dependency, BufferUsageBit::kStorageComputeWrite);
 
 	if(!distanceBased && static_cast<FrustumGpuVisibilityInput&>(in).m_hzbRt)
 	{
@@ -418,25 +418,25 @@ void GpuVisibility::populateRenderGraphInternal(Bool distanceBased, BaseGpuVisib
 			ANKI_ASSERT(0);
 		}
 
-		cmdb.bindUavBuffer(0, 0, aabbsBuffer);
-		cmdb.bindUavBuffer(0, 1, GpuSceneArrays::Renderable::getSingleton().getBufferOffsetRange());
-		cmdb.bindUavBuffer(0, 2, GpuSceneArrays::MeshLod::getSingleton().getBufferOffsetRange());
-		cmdb.bindUavBuffer(0, 3, GpuSceneArrays::Transform::getSingleton().getBufferOffsetRange());
-		cmdb.bindUavBuffer(0, 4, GpuSceneBuffer::getSingleton().getBufferOffsetRange());
+		cmdb.bindStorageBuffer(0, 0, aabbsBuffer);
+		cmdb.bindStorageBuffer(0, 1, GpuSceneArrays::Renderable::getSingleton().getBufferOffsetRange());
+		cmdb.bindStorageBuffer(0, 2, GpuSceneArrays::MeshLod::getSingleton().getBufferOffsetRange());
+		cmdb.bindStorageBuffer(0, 3, GpuSceneArrays::Transform::getSingleton().getBufferOffsetRange());
+		cmdb.bindStorageBuffer(0, 4, GpuSceneBuffer::getSingleton().getBufferOffsetRange());
 		if(gatherType & 1u)
 		{
-			cmdb.bindUavBuffer(0, 5, out.m_legacy.m_renderableInstancesBuffer);
-			cmdb.bindUavBuffer(0, 6, out.m_legacy.m_drawIndexedIndirectArgsBuffer);
-			cmdb.bindUavBuffer(0, 7, out.m_legacy.m_mdiDrawCountsBuffer);
+			cmdb.bindStorageBuffer(0, 5, out.m_legacy.m_renderableInstancesBuffer);
+			cmdb.bindStorageBuffer(0, 6, out.m_legacy.m_drawIndexedIndirectArgsBuffer);
+			cmdb.bindStorageBuffer(0, 7, out.m_legacy.m_mdiDrawCountsBuffer);
 		}
 		if(gatherType & 2u)
 		{
-			cmdb.bindUavBuffer(0, 8, out.m_mesh.m_taskShaderIndirectArgsBuffer);
-			cmdb.bindUavBuffer(0, 9, out.m_mesh.m_meshletGroupInstancesBuffer);
+			cmdb.bindStorageBuffer(0, 8, out.m_mesh.m_taskShaderIndirectArgsBuffer);
+			cmdb.bindStorageBuffer(0, 9, out.m_mesh.m_meshletGroupInstancesBuffer);
 		}
 
 		const U32 bucketCount = RenderStateBucketContainer::getSingleton().getBucketCount(technique);
-		UVec2* instanceRanges = allocateAndBindUav<UVec2>(cmdb, 0, 10, bucketCount);
+		UVec2* instanceRanges = allocateAndBindStorageBuffer<UVec2>(cmdb, 0, 10, bucketCount);
 		for(U32 i = 0; i < bucketCount; ++i)
 		{
 			const Bool legacyBucket = m_runCtx.m_renderableInstanceRanges[technique][i].m_instanceCount > 0;
@@ -455,7 +455,7 @@ void GpuVisibility::populateRenderGraphInternal(Bool distanceBased, BaseGpuVisib
 
 		if(frustumTestData)
 		{
-			FrustumGpuVisibilityConstants* unis = allocateAndBindConstants<FrustumGpuVisibilityConstants>(cmdb, 0, 11);
+			FrustumGpuVisibilityUniforms* unis = allocateAndBindConstants<FrustumGpuVisibilityUniforms>(cmdb, 0, 11);
 
 			Array<Plane, 6> planes;
 			extractClipPlanes(frustumTestData->m_viewProjMat, planes);
@@ -482,7 +482,7 @@ void GpuVisibility::populateRenderGraphInternal(Bool distanceBased, BaseGpuVisib
 		}
 		else
 		{
-			DistanceGpuVisibilityConstants unis;
+			DistanceGpuVisibilityUniforms unis;
 			unis.m_pointOfTest = distTestData->m_pointOfTest;
 			unis.m_testRadius = distTestData->m_testRadius;
 
@@ -498,12 +498,12 @@ void GpuVisibility::populateRenderGraphInternal(Bool distanceBased, BaseGpuVisib
 
 		if(gatherAabbIndices)
 		{
-			cmdb.bindUavBuffer(0, 14, out.m_visibleAaabbIndicesBuffer);
+			cmdb.bindStorageBuffer(0, 14, out.m_visibleAaabbIndicesBuffer);
 		}
 
 		if(genHash)
 		{
-			cmdb.bindUavBuffer(0, 15, out.m_visiblesHashBuffer);
+			cmdb.bindStorageBuffer(0, 15, out.m_visiblesHashBuffer);
 		}
 
 		dispatchPPCompute(cmdb, 64, 1, aabbCount, 1);
@@ -582,8 +582,8 @@ void GpuVisibility::populateRenderGraphMeshletInternal(Bool passthrough, BaseGpu
 
 	ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass(passName.getBegin());
 
-	pass.newBufferDependency(indirectArgsDep, BufferUsageBit::kUavComputeWrite);
-	pass.newBufferDependency(mem.m_bufferDepedency, BufferUsageBit::kUavComputeWrite);
+	pass.newBufferDependency(indirectArgsDep, BufferUsageBit::kStorageComputeWrite);
+	pass.newBufferDependency(mem.m_bufferDepedency, BufferUsageBit::kStorageComputeWrite);
 	pass.newBufferDependency(in.m_dependency, BufferUsageBit::kIndirectCompute);
 
 	pass.setWork([this, nonPassthroughData, computeIndirectArgs = in.m_taskShaderIndirectArgsBuffer, out,
@@ -605,13 +605,13 @@ void GpuVisibility::populateRenderGraphMeshletInternal(Bool passthrough, BaseGpu
 
 			cmdb.bindShaderProgram(m_meshletCullingGrProgs[hasHzb][isPassthrough].get());
 
-			cmdb.bindUavBuffer(0, 0, meshletGroupInstancesBuffer);
-			cmdb.bindUavBuffer(0, 1, GpuSceneArrays::Renderable::getSingleton().getBufferOffsetRange());
-			cmdb.bindUavBuffer(0, 2, GpuSceneArrays::MeshLod::getSingleton().getBufferOffsetRange());
-			cmdb.bindUavBuffer(0, 3, GpuSceneArrays::Transform::getSingleton().getBufferOffsetRange());
-			cmdb.bindUavBuffer(0, 4, UnifiedGeometryBuffer::getSingleton().getBufferOffsetRange());
-			cmdb.bindUavBuffer(0, 5, out.m_drawIndirectArgsBuffer);
-			cmdb.bindUavBuffer(0, 6, out.m_meshletInstancesBuffer);
+			cmdb.bindStorageBuffer(0, 0, meshletGroupInstancesBuffer);
+			cmdb.bindStorageBuffer(0, 1, GpuSceneArrays::Renderable::getSingleton().getBufferOffsetRange());
+			cmdb.bindStorageBuffer(0, 2, GpuSceneArrays::MeshLod::getSingleton().getBufferOffsetRange());
+			cmdb.bindStorageBuffer(0, 3, GpuSceneArrays::Transform::getSingleton().getBufferOffsetRange());
+			cmdb.bindStorageBuffer(0, 4, UnifiedGeometryBuffer::getSingleton().getBufferOffsetRange());
+			cmdb.bindStorageBuffer(0, 5, out.m_drawIndirectArgsBuffer);
+			cmdb.bindStorageBuffer(0, 6, out.m_meshletInstancesBuffer);
 			if(hasHzb)
 			{
 				rpass.bindColorTexture(0, 7, nonPassthroughData->m_hzbRt);
@@ -721,8 +721,8 @@ void GpuVisibilityNonRenderables::populateRenderGraph(GpuVisibilityNonRenderable
 	}
 
 	constexpr U32 kCountersPerDispatch = 3; // 1 for the threadgroup, 1 for the visbile object count and 1 for objects with feedback
-	const U32 counterBufferElementSize =
-		getAlignedRoundUp(GrManager::getSingleton().getDeviceCapabilities().m_uavBufferBindOffsetAlignment, U32(kCountersPerDispatch * sizeof(U32)));
+	const U32 counterBufferElementSize = getAlignedRoundUp(GrManager::getSingleton().getDeviceCapabilities().m_storageBufferBindOffsetAlignment,
+														   U32(kCountersPerDispatch * sizeof(U32)));
 	if(!m_counterBuffer.isCreated() || m_counterBufferOffset + counterBufferElementSize > m_counterBuffer->getSize()) [[unlikely]]
 	{
 		// Counter buffer not created or not big enough, create a new one
@@ -730,7 +730,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::kUavComputeWrite | BufferUsageBit::kUavComputeRead | BufferUsageBit::kTransferDestination;
+		buffInit.m_usage = BufferUsageBit::kStorageComputeWrite | BufferUsageBit::kStorageComputeRead | BufferUsageBit::kTransferDestination;
 		m_counterBuffer = GrManager::getSingleton().newBuffer(buffInit);
 
 		m_counterBufferZeroingHandle = rgraph.importBuffer(m_counterBuffer.get(), buffInit.m_usage, 0, kMaxPtrSize);
@@ -757,8 +757,8 @@ void GpuVisibilityNonRenderables::populateRenderGraph(GpuVisibilityNonRenderable
 	// Create the renderpass
 	ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass(in.m_passesName);
 
-	pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kUavComputeRead);
-	pass.newBufferDependency(out.m_visiblesBufferHandle, BufferUsageBit::kUavComputeWrite);
+	pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kStorageComputeRead);
+	pass.newBufferDependency(out.m_visiblesBufferHandle, BufferUsageBit::kStorageComputeWrite);
 
 	if(in.m_hzbRt)
 	{
@@ -767,7 +767,7 @@ void GpuVisibilityNonRenderables::populateRenderGraph(GpuVisibilityNonRenderable
 
 	if(m_counterBufferZeroingHandle.isValid()) [[unlikely]]
 	{
-		pass.newBufferDependency(m_counterBufferZeroingHandle, BufferUsageBit::kUavComputeRead | BufferUsageBit::kUavComputeWrite);
+		pass.newBufferDependency(m_counterBufferZeroingHandle, BufferUsageBit::kStorageComputeRead | BufferUsageBit::kStorageComputeWrite);
 	}
 
 	pass.setWork([this, objType = in.m_objectType, feedbackBuffer = in.m_cpuFeedbackBuffer, viewProjectionMat = in.m_viewProjectionMat,
@@ -800,9 +800,9 @@ void GpuVisibilityNonRenderables::populateRenderGraph(GpuVisibilityNonRenderable
 		default:
 			ANKI_ASSERT(0);
 		}
-		cmdb.bindUavBuffer(0, 0, objBuffer);
+		cmdb.bindStorageBuffer(0, 0, objBuffer);
 
-		GpuVisibilityNonRenderableConstants unis;
+		GpuVisibilityNonRenderableUniforms unis;
 		Array<Plane, 6> planes;
 		extractClipPlanes(viewProjectionMat, planes);
 		for(U32 i = 0; i < 6; ++i)
@@ -811,12 +811,12 @@ void GpuVisibilityNonRenderables::populateRenderGraph(GpuVisibilityNonRenderable
 		}
 		cmdb.setPushConstants(&unis, sizeof(unis));
 
-		rgraph.bindUavBuffer(0, 1, visibleIndicesBuffHandle);
-		cmdb.bindUavBuffer(0, 2, counterBuffer.get(), counterBufferOffset, sizeof(U32) * kCountersPerDispatch);
+		rgraph.bindStorageBuffer(0, 1, visibleIndicesBuffHandle);
+		cmdb.bindStorageBuffer(0, 2, counterBuffer.get(), counterBufferOffset, sizeof(U32) * kCountersPerDispatch);
 
 		if(needsFeedback)
 		{
-			cmdb.bindUavBuffer(0, 3, feedbackBuffer.m_buffer, feedbackBuffer.m_offset, feedbackBuffer.m_range);
+			cmdb.bindStorageBuffer(0, 3, feedbackBuffer.m_buffer, feedbackBuffer.m_offset, feedbackBuffer.m_range);
 		}
 
 		dispatchPPCompute(cmdb, 64, 1, objCount, 1);
@@ -831,7 +831,7 @@ Error GpuVisibilityAccelerationStructures::init()
 
 	BufferInitInfo inf("GpuVisibilityAccelerationStructuresCounters");
 	inf.m_size = sizeof(U32) * 2;
-	inf.m_usage = BufferUsageBit::kUavComputeWrite | BufferUsageBit::kUavComputeRead | BufferUsageBit::kTransferDestination;
+	inf.m_usage = BufferUsageBit::kStorageComputeWrite | BufferUsageBit::kStorageComputeRead | BufferUsageBit::kTransferDestination;
 	m_counterBuffer = GrManager::getSingleton().newBuffer(inf);
 
 	zeroBuffer(m_counterBuffer.get());
@@ -854,7 +854,7 @@ void GpuVisibilityAccelerationStructures::pupulateRenderGraph(GpuVisibilityAccel
 	const U32 aabbCount = GpuSceneArrays::RenderableBoundingVolumeRt::getSingleton().getElementCount();
 
 	out.m_instancesBuffer = allocateTransientGpuMem(aabbCount * sizeof(AccelerationStructureInstance));
-	out.m_someBufferHandle = rgraph.importBuffer(BufferUsageBit::kUavComputeWrite, out.m_instancesBuffer);
+	out.m_someBufferHandle = rgraph.importBuffer(BufferUsageBit::kStorageComputeWrite, out.m_instancesBuffer);
 
 	out.m_renderableIndicesBuffer = allocateTransientGpuMem((aabbCount + 1) * sizeof(U32));
 
@@ -864,8 +864,8 @@ void GpuVisibilityAccelerationStructures::pupulateRenderGraph(GpuVisibilityAccel
 	{
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass(in.m_passesName);
 
-		pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kUavComputeRead);
-		pass.newBufferDependency(out.m_someBufferHandle, BufferUsageBit::kUavComputeWrite);
+		pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kStorageComputeRead);
+		pass.newBufferDependency(out.m_someBufferHandle, BufferUsageBit::kStorageComputeWrite);
 
 		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,
@@ -874,7 +874,7 @@ void GpuVisibilityAccelerationStructures::pupulateRenderGraph(GpuVisibilityAccel
 
 			cmdb.bindShaderProgram(m_visibilityGrProg.get());
 
-			GpuVisibilityAccelerationStructuresConstants unis;
+			GpuVisibilityAccelerationStructuresUniforms unis;
 			Array<Plane, 6> planes;
 			extractClipPlanes(viewProjMat, planes);
 			for(U32 i = 0; i < 6; ++i)
@@ -893,14 +893,14 @@ void GpuVisibilityAccelerationStructures::pupulateRenderGraph(GpuVisibilityAccel
 
 			cmdb.setPushConstants(&unis, sizeof(unis));
 
-			cmdb.bindUavBuffer(0, 0, GpuSceneArrays::RenderableBoundingVolumeRt::getSingleton().getBufferOffsetRange());
-			cmdb.bindUavBuffer(0, 1, GpuSceneArrays::Renderable::getSingleton().getBufferOffsetRange());
-			cmdb.bindUavBuffer(0, 2, GpuSceneArrays::MeshLod::getSingleton().getBufferOffsetRange());
-			cmdb.bindUavBuffer(0, 3, GpuSceneArrays::Transform::getSingleton().getBufferOffsetRange());
-			cmdb.bindUavBuffer(0, 4, instancesBuff);
-			cmdb.bindUavBuffer(0, 5, indicesBuff);
-			cmdb.bindUavBuffer(0, 6, m_counterBuffer.get(), 0, sizeof(U32) * 2);
-			cmdb.bindUavBuffer(0, 7, zeroInstancesDispatchArgsBuff);
+			cmdb.bindStorageBuffer(0, 0, GpuSceneArrays::RenderableBoundingVolumeRt::getSingleton().getBufferOffsetRange());
+			cmdb.bindStorageBuffer(0, 1, GpuSceneArrays::Renderable::getSingleton().getBufferOffsetRange());
+			cmdb.bindStorageBuffer(0, 2, GpuSceneArrays::MeshLod::getSingleton().getBufferOffsetRange());
+			cmdb.bindStorageBuffer(0, 3, GpuSceneArrays::Transform::getSingleton().getBufferOffsetRange());
+			cmdb.bindStorageBuffer(0, 4, instancesBuff);
+			cmdb.bindStorageBuffer(0, 5, indicesBuff);
+			cmdb.bindStorageBuffer(0, 6, m_counterBuffer.get(), 0, sizeof(U32) * 2);
+			cmdb.bindStorageBuffer(0, 7, zeroInstancesDispatchArgsBuff);
 
 			const U32 aabbCount = GpuSceneArrays::RenderableBoundingVolumeRt::getSingleton().getElementCount();
 			dispatchPPCompute(cmdb, 64, 1, aabbCount, 1);
@@ -914,7 +914,7 @@ void GpuVisibilityAccelerationStructures::pupulateRenderGraph(GpuVisibilityAccel
 
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass(passName.getBegin());
 
-		pass.newBufferDependency(out.m_someBufferHandle, BufferUsageBit::kUavComputeWrite);
+		pass.newBufferDependency(out.m_someBufferHandle, BufferUsageBit::kStorageComputeWrite);
 
 		pass.setWork([this, zeroInstancesDispatchArgsBuff, instancesBuff = out.m_instancesBuffer,
 					  indicesBuff = out.m_renderableIndicesBuffer](RenderPassWorkContext& rgraph) {
@@ -922,8 +922,8 @@ void GpuVisibilityAccelerationStructures::pupulateRenderGraph(GpuVisibilityAccel
 
 			cmdb.bindShaderProgram(m_zeroRemainingInstancesGrProg.get());
 
-			cmdb.bindUavBuffer(0, 0, indicesBuff);
-			cmdb.bindUavBuffer(0, 1, instancesBuff);
+			cmdb.bindStorageBuffer(0, 0, indicesBuff);
+			cmdb.bindStorageBuffer(0, 1, instancesBuff);
 
 			cmdb.dispatchComputeIndirect(zeroInstancesDispatchArgsBuff.m_buffer, zeroInstancesDispatchArgsBuff.m_offset);
 		});

AnKi/Renderer/Utils/HzbGenerator.cpp

@@ -50,10 +50,10 @@ Error HzbGenerator::init()
 	ANKI_CHECK(loadShaderProgram("ShaderBinaries/HzbMaxDepth.ankiprogbin", m_maxDepthProg, m_maxDepthGrProg));
 	ANKI_CHECK(loadShaderProgram("ShaderBinaries/HzbMaxDepthProject.ankiprogbin", m_maxBoxProg, m_maxBoxGrProg));
 
-	m_counterBufferElementSize = max<U32>(sizeof(U32), GrManager::getSingleton().getDeviceCapabilities().m_uavBufferBindOffsetAlignment);
+	m_counterBufferElementSize = max<U32>(sizeof(U32), GrManager::getSingleton().getDeviceCapabilities().m_storageBufferBindOffsetAlignment);
 	BufferInitInfo buffInit("HzbCounterBuffer");
 	buffInit.m_size = m_counterBufferElementSize * kCounterBufferElementCount;
-	buffInit.m_usage = BufferUsageBit::kUavComputeWrite | BufferUsageBit::kTransferDestination;
+	buffInit.m_usage = BufferUsageBit::kStorageComputeWrite | BufferUsageBit::kTransferDestination;
 	m_counterBuffer = GrManager::getSingleton().newBuffer(buffInit);
 
 	// Zero counter buffer
@@ -115,7 +115,7 @@ void HzbGenerator::populateRenderGraphInternal(ConstWeakArray<DispatchInput> dis
 	{
 		TextureSubresourceInfo firstMipSubresource;
 		pass.newTextureDependency(dispatchInputs[i].m_srcDepthRt, TextureUsageBit::kSampledCompute, firstMipSubresource);
-		pass.newTextureDependency(dispatchInputs[i].m_dstHzbRt, TextureUsageBit::kUavComputeWrite);
+		pass.newTextureDependency(dispatchInputs[i].m_dstHzbRt, TextureUsageBit::kStorageComputeWrite);
 
 		dispatchInputsCopy[i] = dispatchInputs[i];
 	}
@@ -141,7 +141,7 @@ void HzbGenerator::populateRenderGraphInternal(ConstWeakArray<DispatchInput> dis
 			varAU4(rectInfo) = initAU4(0, 0, in.m_dstHzbRtSize.x() * 2, in.m_dstHzbRtSize.y() * 2);
 			SpdSetup(dispatchThreadGroupCountXY, workGroupOffset, numWorkGroupsAndMips, rectInfo, mipsToCompute);
 
-			struct Constants
+			struct Uniforms
 			{
 				Vec2 m_invSrcTexSize;
 				U32 m_threadGroupCount;
@@ -166,10 +166,10 @@ void HzbGenerator::populateRenderGraphInternal(ConstWeakArray<DispatchInput> dis
 					subresource.m_firstMipmap = 0; // Put something random
 				}
 
-				rgraphCtx.bindUavTexture(0, 0, in.m_dstHzbRt, subresource, mip);
+				rgraphCtx.bindStorageTexture(0, 0, in.m_dstHzbRt, subresource, mip);
 			}
 
-			cmdb.bindUavBuffer(0, 1, m_counterBuffer.get(), (firstCounterBufferElement + dispatch) * m_counterBufferElementSize, sizeof(U32));
+			cmdb.bindStorageBuffer(0, 1, m_counterBuffer.get(), (firstCounterBufferElement + dispatch) * m_counterBufferElementSize, sizeof(U32));
 			rgraphCtx.bindTexture(0, 2, in.m_srcDepthRt, TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
 			cmdb.dispatchCompute(dispatchThreadGroupCountXY[0], dispatchThreadGroupCountXY[1], 1);
@@ -208,14 +208,14 @@ void HzbGenerator::populateRenderGraphDirectionalLight(const HzbDirectionalLight
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("HZB max tile depth");
 
 		pass.newTextureDependency(in.m_depthBufferRt, TextureUsageBit::kSampledCompute, DepthStencilAspectBit::kDepth);
-		pass.newTextureDependency(maxDepthRt, TextureUsageBit::kUavComputeWrite);
+		pass.newTextureDependency(maxDepthRt, TextureUsageBit::kStorageComputeWrite);
 
 		pass.setWork([this, depthBufferRt = in.m_depthBufferRt, maxDepthRt, maxDepthRtSize](RenderPassWorkContext& rgraphCtx) {
 			CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
 			rgraphCtx.bindTexture(0, 0, depthBufferRt, TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 			cmdb.bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
-			rgraphCtx.bindUavTexture(0, 2, maxDepthRt);
+			rgraphCtx.bindStorageTexture(0, 2, maxDepthRt);
 
 			cmdb.bindShaderProgram(m_maxDepthGrProg.get());
 
@@ -285,7 +285,7 @@ void HzbGenerator::populateRenderGraphDirectionalLight(const HzbDirectionalLight
 
 			rgraphCtx.bindColorTexture(0, 0, maxDepthRt);
 
-			struct Constants
+			struct Uniforms
 			{
 				Mat4 m_reprojectionMat;
 

AnKi/Renderer/Utils/TraditionalDeferredShading.cpp

@@ -62,7 +62,7 @@ void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShading
 		cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
 		rgraphCtx.bindTexture(0, 1, info.m_gbufferDepthRenderTarget, TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
-		TraditionalDeferredSkyboxConstants unis = {};
+		TraditionalDeferredSkyboxUniforms unis = {};
 		unis.m_invertedViewProjectionMat = info.m_invViewProjectionMatrix;
 		unis.m_cameraPos = info.m_cameraPosWSpace.xyz();
 		unis.m_scale = skyc->getImageScale();
@@ -83,7 +83,7 @@ void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShading
 			rgraphCtx.bindColorTexture(0, 3, info.m_skyLutRenderTarget);
 		}
 
-		cmdb.bindConstantBuffer(0, 4, info.m_globalRendererConsts);
+		cmdb.bindUniformBuffer(0, 4, info.m_globalRendererConsts);
 
 		cmdb.setPushConstants(&unis, sizeof(unis));
 
@@ -92,7 +92,7 @@ void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShading
 
 	// Light shading
 	{
-		TraditionalDeferredShadingConstants* unis = allocateAndBindConstants<TraditionalDeferredShadingConstants>(cmdb, 0, 0);
+		TraditionalDeferredShadingUniforms* unis = allocateAndBindConstants<TraditionalDeferredShadingUniforms>(cmdb, 0, 0);
 
 		unis->m_invViewProjMat = info.m_invViewProjectionMatrix;
 		unis->m_cameraPos = info.m_cameraPosWSpace.xyz();
@@ -103,15 +103,15 @@ void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShading
 			unis->m_dirLight.m_lightMatrix = info.m_dirLightMatrix;
 		}
 
-		cmdb.bindUavBuffer(0, 1, info.m_visibleLightsBuffer);
+		cmdb.bindStorageBuffer(0, 1, info.m_visibleLightsBuffer);
 		if(GpuSceneArrays::Light::getSingleton().getElementCount() > 0)
 		{
-			cmdb.bindUavBuffer(0, 2, GpuSceneArrays::Light::getSingleton().getBufferOffsetRange());
+			cmdb.bindStorageBuffer(0, 2, GpuSceneArrays::Light::getSingleton().getBufferOffsetRange());
 		}
 		else
 		{
 			// Set something random
-			cmdb.bindUavBuffer(0, 2, GpuSceneBuffer::getSingleton().getBufferOffsetRange());
+			cmdb.bindStorageBuffer(0, 2, GpuSceneBuffer::getSingleton().getBufferOffsetRange());
 		}
 
 		// NOTE: Use nearest sampler because we don't want the result to sample the near tiles
@@ -134,7 +134,7 @@ void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShading
 			rgraphCtx.bindTexture(0, 9, info.m_gbufferDepthRenderTarget, info.m_gbufferDepthRenderTargetSubresourceInfo);
 		}
 
-		cmdb.bindConstantBuffer(0, 10, info.m_globalRendererConsts);
+		cmdb.bindUniformBuffer(0, 10, info.m_globalRendererConsts);
 
 		cmdb.bindShaderProgram(m_lightGrProg[info.m_computeSpecular].get());
 

AnKi/Renderer/VolumetricFog.cpp

@@ -49,7 +49,7 @@ void VolumetricFog::populateRenderGraph(RenderingContext& ctx)
 
 	ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("Vol fog");
 
-	pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kUavComputeWrite);
+	pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kStorageComputeWrite);
 	pass.newTextureDependency(getRenderer().getVolumetricLightingAccumulation().getRt(), TextureUsageBit::kSampledCompute);
 
 	pass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
@@ -61,11 +61,11 @@ void VolumetricFog::populateRenderGraph(RenderingContext& ctx)
 		cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp.get());
 		rgraphCtx.bindColorTexture(0, 1, getRenderer().getVolumetricLightingAccumulation().getRt());
 
-		rgraphCtx.bindUavTexture(0, 2, m_runCtx.m_rt, TextureSubresourceInfo());
+		rgraphCtx.bindStorageTexture(0, 2, m_runCtx.m_rt, TextureSubresourceInfo());
 
 		const SkyboxComponent* sky = SceneGraph::getSingleton().getSkybox();
 
-		VolumetricFogConstants regs;
+		VolumetricFogUniforms regs;
 		regs.m_fogDiffuse = (sky) ? sky->getFogDiffuseColor() : Vec3(0.0f);
 		regs.m_fogScatteringCoeff = (sky) ? sky->getFogScatteringCoefficient() : 0.0f;
 		regs.m_fogAbsorptionCoeff = (sky) ? sky->getFogAbsorptionCoefficient() : 0.0f;

AnKi/Renderer/VolumetricLightingAccumulation.cpp

@@ -48,7 +48,7 @@ Error VolumetricLightingAccumulation::init()
 
 	// Create RTs
 	TextureInitInfo texinit = getRenderer().create2DRenderTargetInitInfo(m_volumeSize[0], m_volumeSize[1], Format::kR16G16B16A16_Sfloat,
-																		 TextureUsageBit::kUavComputeRead | TextureUsageBit::kUavComputeWrite
+																		 TextureUsageBit::kStorageComputeRead | TextureUsageBit::kStorageComputeWrite
 																			 | TextureUsageBit::kSampledFragment | TextureUsageBit::kSampledCompute,
 																		 "VolLight");
 	texinit.m_depth = m_volumeSize[2];
@@ -72,17 +72,17 @@ void VolumetricLightingAccumulation::populateRenderGraph(RenderingContext& ctx)
 	ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("Vol light");
 
 	pass.newTextureDependency(m_runCtx.m_rts[0], TextureUsageBit::kSampledCompute);
-	pass.newTextureDependency(m_runCtx.m_rts[1], TextureUsageBit::kUavComputeWrite);
+	pass.newTextureDependency(m_runCtx.m_rts[1], TextureUsageBit::kStorageComputeWrite);
 	pass.newTextureDependency(getRenderer().getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledCompute);
 
-	pass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kUavComputeRead);
+	pass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kStorageComputeRead);
 	pass.newBufferDependency(getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kLight),
-							 BufferUsageBit::kUavComputeRead);
+							 BufferUsageBit::kStorageComputeRead);
 	pass.newBufferDependency(
 		getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kGlobalIlluminationProbe),
-		BufferUsageBit::kUavComputeRead);
+		BufferUsageBit::kStorageComputeRead);
 	pass.newBufferDependency(getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kFogDensityVolume),
-							 BufferUsageBit::kUavComputeRead);
+							 BufferUsageBit::kStorageComputeRead);
 
 	if(getRenderer().getIndirectDiffuseProbes().hasCurrentlyRefreshedVolumeRt())
 	{
@@ -100,24 +100,25 @@ void VolumetricLightingAccumulation::populateRenderGraph(RenderingContext& ctx)
 		cmdb.bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
 		cmdb.bindSampler(0, 2, getRenderer().getSamplers().m_trilinearClampShadow.get());
 
-		rgraphCtx.bindUavTexture(0, 3, m_runCtx.m_rts[1], TextureSubresourceInfo());
+		rgraphCtx.bindStorageTexture(0, 3, m_runCtx.m_rts[1], TextureSubresourceInfo());
 
 		cmdb.bindTexture(0, 4, &m_noiseImage->getTextureView());
 
 		rgraphCtx.bindColorTexture(0, 5, m_runCtx.m_rts[0]);
 
-		cmdb.bindConstantBuffer(0, 6, ctx.m_globalRenderingConstsBuffer);
-		cmdb.bindUavBuffer(0, 7, getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kLight));
+		cmdb.bindUniformBuffer(0, 6, ctx.m_globalRenderingUniformsBuffer);
+		cmdb.bindStorageBuffer(0, 7, getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kLight));
 		rgraphCtx.bindColorTexture(0, 8, getRenderer().getShadowMapping().getShadowmapRt());
-		cmdb.bindUavBuffer(0, 9, getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kGlobalIlluminationProbe));
-		cmdb.bindUavBuffer(0, 10, getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kFogDensityVolume));
-		cmdb.bindUavBuffer(0, 11, getRenderer().getClusterBinning().getClustersBuffer());
+		cmdb.bindStorageBuffer(0, 9,
+							   getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kGlobalIlluminationProbe));
+		cmdb.bindStorageBuffer(0, 10, getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kFogDensityVolume));
+		cmdb.bindStorageBuffer(0, 11, getRenderer().getClusterBinning().getClustersBuffer());
 
 		cmdb.bindAllBindless(1);
 
 		const SkyboxComponent* sky = SceneGraph::getSingleton().getSkybox();
 
-		VolumetricLightingConstants unis;
+		VolumetricLightingUniforms unis;
 		if(!sky)
 		{
 			unis.m_minHeight = 0.0f;

AnKi/Renderer/VrsSriGeneration.cpp

@@ -38,7 +38,7 @@ 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::kUavComputeWrite | TextureUsageBit::kAllSampled;
+	const TextureUsageBit texUsage = TextureUsageBit::kFramebufferShadingRate | TextureUsageBit::kStorageComputeWrite | TextureUsageBit::kAllSampled;
 	TextureInitInfo sriInitInfo = getRenderer().create2DRenderTargetInitInfo(rez.x(), rez.y(), Format::kR8_Uint, texUsage, "VrsSri");
 	m_sriTex = getRenderer().createAndClearRenderTarget(sriInitInfo, TextureUsageBit::kFramebufferShadingRate);
 
@@ -131,7 +131,7 @@ void VrsSriGeneration::populateRenderGraph(RenderingContext& ctx)
 	{
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("VRS SRI generation");
 
-		pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kUavComputeWrite);
+		pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kStorageComputeWrite);
 		pass.newTextureDependency(getRenderer().getLightShading().getRt(), TextureUsageBit::kSampledCompute);
 
 		pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
@@ -142,7 +142,7 @@ void VrsSriGeneration::populateRenderGraph(RenderingContext& ctx)
 
 			rgraphCtx.bindColorTexture(0, 0, getRenderer().getLightShading().getRt());
 			cmdb.bindSampler(0, 1, getRenderer().getSamplers().m_nearestNearestClamp.get());
-			rgraphCtx.bindUavTexture(0, 2, m_runCtx.m_rt);
+			rgraphCtx.bindStorageTexture(0, 2, m_runCtx.m_rt);
 			const Vec4 pc(1.0f / Vec2(getRenderer().getInternalResolution()), g_vrsThresholdCVar.get(), 0.0f);
 			cmdb.setPushConstants(&pc, sizeof(pc));
 
@@ -157,7 +157,7 @@ void VrsSriGeneration::populateRenderGraph(RenderingContext& ctx)
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("VRS SRI downscale");
 
 		pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kSampledCompute);
-		pass.newTextureDependency(m_runCtx.m_downscaledRt, TextureUsageBit::kUavComputeWrite);
+		pass.newTextureDependency(m_runCtx.m_downscaledRt, TextureUsageBit::kStorageComputeWrite);
 
 		pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 			ANKI_TRACE_SCOPED_EVENT(VrsSriGeneration);
@@ -169,7 +169,7 @@ void VrsSriGeneration::populateRenderGraph(RenderingContext& ctx)
 
 			rgraphCtx.bindColorTexture(0, 0, m_runCtx.m_rt);
 			cmdb.bindSampler(0, 1, getRenderer().getSamplers().m_nearestNearestClamp.get());
-			rgraphCtx.bindUavTexture(0, 2, m_runCtx.m_downscaledRt);
+			rgraphCtx.bindStorageTexture(0, 2, m_runCtx.m_downscaledRt);
 			const Vec4 pc(1.0f / Vec2(rezDownscaled), 0.0f, 0.0f);
 			cmdb.setPushConstants(&pc, sizeof(pc));
 

AnKi/Resource/MaterialResource.cpp

@@ -382,7 +382,7 @@ Error MaterialResource::createVars()
 	const ShaderProgramBinaryStruct* localUniformsStruct = nullptr;
 	for(const ShaderProgramBinaryStruct& strct : binary.m_structs)
 	{
-		if(CString(strct.m_name.getBegin()) == "AnKiLocalConstants")
+		if(CString(strct.m_name.getBegin()) == "AnKiLocalUniforms")
 		{
 			localUniformsStruct = &strct;
 			break;

AnKi/Resource/MaterialResource.h

@@ -175,7 +175,7 @@ private:
 ///		</shaderProgram>
 ///
 ///		[<inputs>
-///			<input name="name in AnKiMaterialConstants struct" value="value(s)"/>
+///			<input name="name in AnKiMaterialUniforms struct" value="value(s)"/>
 ///		</inputs>]
 ///	</material>
 /// @endcode

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::kUavComputeWrite | TextureUsageBit::kUavComputeRead;
+		texInit.m_usage = TextureUsageBit::kAllSampled | TextureUsageBit::kStorageComputeWrite | TextureUsageBit::kStorageComputeRead;
 
 		m_volTex = GrManager::getSingleton().newTexture(texInit);
 
@@ -72,12 +72,12 @@ Error GlobalIlluminationProbeComponent::update(SceneComponentUpdateInfo& info, B
 
 		TextureBarrierInfo texBarrier;
 		texBarrier.m_previousUsage = TextureUsageBit::kNone;
-		texBarrier.m_nextUsage = TextureUsageBit::kUavComputeWrite;
+		texBarrier.m_nextUsage = TextureUsageBit::kStorageComputeWrite;
 		texBarrier.m_texture = m_volTex.get();
 		cmdb->setPipelineBarrier({&texBarrier, 1}, {}, {});
 
 		cmdb->bindShaderProgram(&variant->getProgram());
-		cmdb->bindUavTexture(0, 0, m_volView.get());
+		cmdb->bindStorageTexture(0, 0, m_volView.get());
 
 		const Vec4 clearColor(0.0f);
 		cmdb->setPushConstants(&clearColor, sizeof(clearColor));
@@ -88,7 +88,7 @@ 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::kUavComputeWrite;
+		texBarrier.m_previousUsage = TextureUsageBit::kStorageComputeWrite;
 		texBarrier.m_nextUsage = m_volTex->getTextureUsage();
 		cmdb->setPipelineBarrier({&texBarrier, 1}, {}, {});
 

AnKi/Scene/Components/ModelComponent.cpp

@@ -206,7 +206,7 @@ Error ModelComponent::update(SceneComponentUpdateInfo& info, Bool& updated)
 			// Upload the GpuSceneRenderable
 			GpuSceneRenderable gpuRenderable = {};
 			gpuRenderable.m_worldTransformsIndex = m_gpuSceneTransforms.getIndex() * 2;
-			gpuRenderable.m_constantsOffset = m_patchInfos[i].m_gpuSceneUniformsOffset;
+			gpuRenderable.m_uniformsOffset = m_patchInfos[i].m_gpuSceneUniformsOffset;
 			gpuRenderable.m_meshLodsIndex = m_patchInfos[i].m_gpuSceneMeshLods.getIndex() * kMaxLodCount;
 			gpuRenderable.m_boneTransformsOffset = (hasSkin) ? m_skinComponent->getBoneTransformsGpuSceneOffset() : 0;
 			if(!!(mtl.getRenderingTechniques() & RenderingTechniqueBit::kRtShadow))

AnKi/Scene/Components/ParticleEmitterComponent.cpp

@@ -401,7 +401,7 @@ Error ParticleEmitterComponent::update(SceneComponentUpdateInfo& info, Bool& upd
 		// Upload the GpuSceneRenderable
 		GpuSceneRenderable renderable;
 		renderable.m_boneTransformsOffset = 0;
-		renderable.m_constantsOffset = m_gpuSceneUniforms.getOffset();
+		renderable.m_uniformsOffset = m_gpuSceneUniforms.getOffset();
 		renderable.m_meshLodsIndex = m_gpuSceneMeshLods.getIndex() * kMaxLodCount;
 		renderable.m_particleEmitterOffset = m_gpuSceneParticleEmitter.getGpuSceneOffset();
 		renderable.m_worldTransformsIndex = 0;

AnKi/Scene/Components/ReflectionProbeComponent.cpp

@@ -29,7 +29,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::kUavComputeWrite | TextureUsageBit::kUavComputeRead
+	texInit.m_usage = TextureUsageBit::kAllSampled | TextureUsageBit::kStorageComputeWrite | TextureUsageBit::kStorageComputeRead
 					  | TextureUsageBit::kAllFramebuffer | TextureUsageBit::kGenerateMipmaps;
 
 	m_reflectionTex = GrManager::getSingleton().newTexture(texInit);

AnKi/Scene/GpuSceneArray.inl.h

@@ -13,7 +13,7 @@ template<typename TGpuSceneObject, U32 kId>
 GpuSceneArray<TGpuSceneObject, kId>::GpuSceneArray(U32 maxArraySize)
 {
 	maxArraySize = getAlignedRoundUp(sizeof(SubMask), maxArraySize);
-	const U32 alignment = GrManager::getSingleton().getDeviceCapabilities().m_uavBufferBindOffsetAlignment;
+	const U32 alignment = GrManager::getSingleton().getDeviceCapabilities().m_storageBufferBindOffsetAlignment;
 	m_gpuSceneAllocation = GpuSceneBuffer::getSingleton().allocate(sizeof(TGpuSceneObject) * maxArraySize, alignment);
 
 	m_inUseIndicesMask.resize(maxArraySize / sizeof(SubMask), false);

AnKi/Shaders/Blit.ankiprog

@@ -16,15 +16,15 @@
 #	endif
 
 #	if USE_COMPUTE
-[[vk::binding(2)]] RWTexture2D<RVec4> g_outUav;
+[[vk::binding(2)]] RWTexture2D<RVec4> g_storageTex;
 
-struct Constants
+struct Uniforms
 {
 	Vec2 m_viewportSize;
 	UVec2 m_viewportSizeU;
 };
 
-[[vk::push_constant]] ConstantBuffer<Constants> g_pc;
+[[vk::push_constant]] ConstantBuffer<Uniforms> g_unis;
 #	endif
 
 #	if USE_COMPUTE
@@ -34,18 +34,18 @@ RVec3 main([[vk::location(0)]] Vec2 uv : TEXCOORD) : SV_TARGET0
 #	endif
 {
 #	if USE_COMPUTE
-	if(skipOutOfBoundsInvocations(UVec2(8, 8), g_pc.m_viewportSizeU, svDispatchThreadId.xy))
+	if(skipOutOfBoundsInvocations(UVec2(8, 8), g_unis.m_viewportSizeU, svDispatchThreadId.xy))
 	{
 		return;
 	}
 
-	const Vec2 uv = (Vec2(svDispatchThreadId.xy) + 0.5) / g_pc.m_viewportSize;
+	const Vec2 uv = (Vec2(svDispatchThreadId.xy) + 0.5) / g_unis.m_viewportSize;
 #	endif
 
 	const RVec3 color = g_inputTex.SampleLevel(g_linearAnyClampSampler, uv, 0.0).rgb;
 
 #	if USE_COMPUTE
-	g_outUav[svDispatchThreadId.xy] = RVec4(color, 0.0);
+	g_storageTex[svDispatchThreadId.xy] = RVec4(color, 0.0);
 #	else
 	return color;
 #	endif

AnKi/Shaders/Bloom.ankiprog

@@ -12,7 +12,7 @@ constexpr U32 kTonemappingBinding = 2u;
 [[vk::binding(0)]] SamplerState g_linearAnyClampSampler;
 [[vk::binding(1)]] Texture2D<RVec4> g_inTex;
 
-struct Constants
+struct Uniforms
 {
 	RF32 m_threshold;
 	F32 m_scale;
@@ -20,12 +20,12 @@ struct Constants
 	F32 m_padding1;
 };
 
-[[vk::push_constant]] ConstantBuffer<Constants> g_consts;
+[[vk::push_constant]] ConstantBuffer<Uniforms> g_unis;
 
 #	if ANKI_COMPUTE_SHADER
 #		define THREADGROUP_SIZE_X 8
 #		define THREADGROUP_SIZE_Y 8
-[[vk::binding(3)]] RWTexture2D<RVec4> g_outUav;
+[[vk::binding(3)]] RWTexture2D<RVec4> g_storageTex;
 #	endif
 
 #	if ANKI_COMPUTE_SHADER
@@ -35,10 +35,10 @@ RVec3 main([[vk::location(0)]] Vec2 uv : TEXCOORD) : SV_TARGET0
 #	endif
 {
 #	if ANKI_COMPUTE_SHADER
-	Vec2 outUavSize;
-	g_outUav.GetDimensions(outUavSize.x, outUavSize.y);
+	Vec2 imgSize;
+	g_storageTex.GetDimensions(imgSize.x, imgSize.y);
 
-	const Vec2 uv = (Vec2(svDispatchThreadId) + 0.5) / outUavSize;
+	const Vec2 uv = (Vec2(svDispatchThreadId) + 0.5) / imgSize;
 #	endif
 
 	const RF32 weight = 1.0 / 5.0;
@@ -48,10 +48,10 @@ RVec3 main([[vk::location(0)]] Vec2 uv : TEXCOORD) : SV_TARGET0
 	color += g_inTex.SampleLevel(g_linearAnyClampSampler, uv, 0.0, IVec2(-1, +1)).rgb * weight;
 	color += g_inTex.SampleLevel(g_linearAnyClampSampler, uv, 0.0, IVec2(+1, -1)).rgb * weight;
 
-	color = tonemap(color, readExposureAndAverageLuminance().y, g_consts.m_threshold) * g_consts.m_scale;
+	color = tonemap(color, readExposureAndAverageLuminance().y, g_unis.m_threshold) * g_unis.m_scale;
 
 #	if ANKI_COMPUTE_SHADER
-	g_outUav[svDispatchThreadId] = RVec4(color, 0.0);
+	g_storageTex[svDispatchThreadId] = RVec4(color, 0.0);
 #	else
 	return color;
 #	endif

AnKi/Shaders/BloomUpscale.ankiprog

@@ -21,7 +21,7 @@ constexpr F32 kHaloOpacity = 0.5;
 
 #	if ANKI_COMPUTE_SHADER
 #		define THREADGROUP_SIZE_XY 8
-[[vk::binding(3)]] RWTexture2D<RVec4> g_outUav;
+[[vk::binding(3)]] RWTexture2D<RVec4> g_storageTex;
 #	endif
 
 RVec3 textureDistorted(Texture2D<RVec4> tex, SamplerState sampl, Vec2 uv,
@@ -96,16 +96,16 @@ RVec3 main([[vk::location(0)]] Vec2 uv : TEXCOORD) : SV_TARGET0
 #	endif
 {
 #	if ANKI_COMPUTE_SHADER
-	Vec2 outUavTexSize;
-	g_outUav.GetDimensions(outUavTexSize.x, outUavTexSize.y);
+	Vec2 storageTexSize;
+	g_storageTex.GetDimensions(storageTexSize.x, storageTexSize.y);
 
-	const Vec2 uv = (Vec2(svDispatchThreadId) + 0.5) / outUavTexSize;
+	const Vec2 uv = (Vec2(svDispatchThreadId) + 0.5) / storageTexSize;
 #	endif
 
 	const RVec3 outColor = ssLensFlare(uv) + upscale(uv);
 
 #	if ANKI_COMPUTE_SHADER
-	g_outUav[svDispatchThreadId] = RVec4(outColor, 0.0);
+	g_storageTex[svDispatchThreadId] = RVec4(outColor, 0.0);
 #	else
 	return outColor;
 #	endif

AnKi/Shaders/ClearTextureCompute.ankiprog

@@ -11,7 +11,7 @@
 #pragma anki technique_start comp
 #include <AnKi/Shaders/Common.hlsl>
 
-struct Constants
+struct Uniforms
 {
 #if COMPONENT_TYPE == 0
 	Vec4 m_clearColor;
@@ -20,19 +20,19 @@ struct Constants
 #endif
 };
 
-[[vk::push_constant]] ConstantBuffer<Constants> g_pc;
+[[vk::push_constant]] ConstantBuffer<Uniforms> g_unis;
 
 #if TEXTURE_DIMENSIONS == 2
 #	if COMPONENT_TYPE == 0
-[[vk::binding(0)]] RWTexture2D<Vec4> g_outUav;
+[[vk::binding(0)]] RWTexture2D<Vec4> g_storageTex;
 #	else
-[[vk::binding(0)]] RWTexture2D<UVec4> g_outUav;
+[[vk::binding(0)]] RWTexture2D<UVec4> g_storageTex;
 #	endif
 #else
 #	if COMPONENT_TYPE == 0
-[[vk::binding(0)]] RWTexture3D<Vec4> g_outUav;
+[[vk::binding(0)]] RWTexture3D<Vec4> g_storageTex;
 #	else
-[[vk::binding(0)]] RWTexture3D<UVec4> g_outUav;
+[[vk::binding(0)]] RWTexture3D<UVec4> g_storageTex;
 #	endif
 #endif
 
@@ -40,24 +40,24 @@ struct Constants
 {
 #if TEXTURE_DIMENSIONS == 2
 	UVec2 texSize;
-	g_outUav.GetDimensions(texSize.x, texSize.y);
+	g_storageTex.GetDimensions(texSize.x, texSize.y);
 
 	if(svDispatchThreadId.x >= texSize.x || svDispatchThreadId.y >= texSize.y)
 	{
 		return;
 	}
 
-	g_outUav[svDispatchThreadId.xy] = g_pc.m_clearColor;
+	g_storageTex[svDispatchThreadId.xy] = g_unis.m_clearColor;
 #else
 	UVec3 texSize;
-	g_outUav.GetDimensions(texSize.x, texSize.y, texSize.z);
+	g_storageTex.GetDimensions(texSize.x, texSize.y, texSize.z);
 
 	if(svDispatchThreadId.x >= texSize.x || svDispatchThreadId.y >= texSize.y || svDispatchThreadId.z >= texSize.z)
 	{
 		return;
 	}
 
-	g_outUav[svDispatchThreadId] = g_pc.m_clearColor;
+	g_storageTex[svDispatchThreadId] = g_unis.m_clearColor;
 #endif
 }
 

AnKi/Shaders/ClusterBinning.ankiprog

@@ -26,7 +26,7 @@ typedef GpuSceneGlobalIlluminationProbe GpuSceneType;
 #	error See file
 #endif
 
-struct ClusterBinningConstants
+struct ClusterBinningUniforms
 {
 	Vec3 m_cameraOrigin;
 	F32 m_zSplitCountOverFrustumLength;
@@ -45,7 +45,7 @@ struct ClusterBinningConstants
 	Mat4 m_invertedViewProjMat;
 };
 
-[[vk::push_constant]] ConstantBuffer<ClusterBinningConstants> g_consts;
+[[vk::push_constant]] ConstantBuffer<ClusterBinningUniforms> g_unis;
 
 [[vk::binding(0)]] StructuredBuffer<U32> g_visibleObjectIds; // 1st index is the count and then the indices to the g_objects
 [[vk::binding(1)]] StructuredBuffer<GpuSceneType> g_objects;
@@ -63,25 +63,25 @@ constexpr UVec2 kSampleLocations[kSampleCount] = {LOCATION(1, -3), LOCATION(-1,
 
 [numthreads(THREADGROUP_SIZE, 1, 1)] void main(UVec2 svDispatchThreadId : SV_DISPATCHTHREADID)
 {
-	const U32 dispatchThreadIdX = min(svDispatchThreadId.x, g_consts.m_tileCount * kSampleCount);
+	const U32 dispatchThreadIdX = min(svDispatchThreadId.x, g_unis.m_tileCount * kSampleCount);
 	const U32 tileIdx = dispatchThreadIdX / kSampleCount;
 	const U32 sampleIdx = dispatchThreadIdX % kSampleCount;
 	const U32 visibleObjectIdx = svDispatchThreadId.y;
 	ANKI_ASSERT(visibleObjectIdx < kMaxVisibleClusteredObjects[OBJECT_TYPE]);
 
-	const UVec2 tileXY = UVec2(tileIdx % g_consts.m_tileCountX, tileIdx / g_consts.m_tileCountX);
+	const UVec2 tileXY = UVec2(tileIdx % g_unis.m_tileCountX, tileIdx / g_unis.m_tileCountX);
 
 	// This is a pixel in one of the main framebuffers of the renderer, eg the gbuffer's framebuffers
 	const UVec2 pixel = tileXY * kClusteredShadingTileSize + kSampleLocations[sampleIdx];
-	const Vec2 uv = Vec2(pixel) / g_consts.m_renderingSize;
+	const Vec2 uv = Vec2(pixel) / g_unis.m_renderingSize;
 	const Vec2 ndc = uvToNdc(uv);
 
 	// Unproject the sample in world space
-	const Vec4 farWorldPos4 = mul(g_consts.m_invertedViewProjMat, Vec4(ndc, 1.0, 1.0));
+	const Vec4 farWorldPos4 = mul(g_unis.m_invertedViewProjMat, Vec4(ndc, 1.0, 1.0));
 	const Vec3 farWorldPos = farWorldPos4.xyz / farWorldPos4.w;
 
 	// Create the ray that will test the clusterer objects
-	const Vec3 rayOrigin = g_consts.m_cameraOrigin;
+	const Vec3 rayOrigin = g_unis.m_cameraOrigin;
 	const Vec3 rayDir = normalize(farWorldPos - rayOrigin);
 
 	// Do collision
@@ -182,8 +182,8 @@ constexpr UVec2 kSampleLocations[kSampleCount] = {LOCATION(1, -3), LOCATION(-1,
 		// Compute and set the Z splits
 		const Vec3 hitpointA = rayDir * t0 + rayOrigin;
 		const Vec3 hitpointB = rayDir * t1 + rayOrigin;
-		const F32 distFromNearPlaneA = testPlanePoint(g_consts.m_nearPlaneWorld.xyz, g_consts.m_nearPlaneWorld.w, hitpointA);
-		const F32 distFromNearPlaneB = testPlanePoint(g_consts.m_nearPlaneWorld.xyz, g_consts.m_nearPlaneWorld.w, hitpointB);
+		const F32 distFromNearPlaneA = testPlanePoint(g_unis.m_nearPlaneWorld.xyz, g_unis.m_nearPlaneWorld.w, hitpointA);
+		const F32 distFromNearPlaneB = testPlanePoint(g_unis.m_nearPlaneWorld.xyz, g_unis.m_nearPlaneWorld.w, hitpointB);
 
 		F32 minDistFromNearPlane;
 		F32 maxDistFromNearPlane;
@@ -198,27 +198,27 @@ constexpr UVec2 kSampleLocations[kSampleCount] = {LOCATION(1, -3), LOCATION(-1,
 			maxDistFromNearPlane = distFromNearPlaneA;
 		}
 
-		const I32 startZSplit = max(I32(minDistFromNearPlane * g_consts.m_zSplitCountOverFrustumLength), 0);
-		const I32 endZSplit = clamp(I32(maxDistFromNearPlane * g_consts.m_zSplitCountOverFrustumLength), 0, g_consts.m_zSplitCountMinusOne);
+		const I32 startZSplit = max(I32(minDistFromNearPlane * g_unis.m_zSplitCountOverFrustumLength), 0);
+		const I32 endZSplit = clamp(I32(maxDistFromNearPlane * g_unis.m_zSplitCountOverFrustumLength), 0, g_unis.m_zSplitCountMinusOne);
 		for(I32 i = startZSplit; i <= endZSplit; ++i)
 		{
 #if OBJECT_TYPE == ANKI_GPU_SCENE_NON_RENDERABLE_OBJECT_TYPE_LIGHT
 			if((U32)obj.m_flags & (U32)GpuSceneLightFlag::kPointLight)
 			{
-				InterlockedOr(g_clusters[g_consts.m_tileCount + i].m_pointLightsMask[maskArrayIdx], mask);
+				InterlockedOr(g_clusters[g_unis.m_tileCount + i].m_pointLightsMask[maskArrayIdx], mask);
 			}
 			else
 			{
-				InterlockedOr(g_clusters[g_consts.m_tileCount + i].m_spotLightsMask[maskArrayIdx], mask);
+				InterlockedOr(g_clusters[g_unis.m_tileCount + i].m_spotLightsMask[maskArrayIdx], mask);
 			}
 #elif OBJECT_TYPE == ANKI_GPU_SCENE_NON_RENDERABLE_OBJECT_TYPE_DECAL
-			InterlockedOr(g_clusters[g_consts.m_tileCount + i].m_decalsMask[maskArrayIdx], mask);
+			InterlockedOr(g_clusters[g_unis.m_tileCount + i].m_decalsMask[maskArrayIdx], mask);
 #elif OBJECT_TYPE == ANKI_GPU_SCENE_NON_RENDERABLE_OBJECT_TYPE_FOG_DENSITY_VOLUME
-			InterlockedOr(g_clusters[g_consts.m_tileCount + i].m_fogDensityVolumesMask, mask);
+			InterlockedOr(g_clusters[g_unis.m_tileCount + i].m_fogDensityVolumesMask, mask);
 #elif OBJECT_TYPE == ANKI_GPU_SCENE_NON_RENDERABLE_OBJECT_TYPE_REFLECTION_PROBE
-			InterlockedOr(g_clusters[g_consts.m_tileCount + i].m_reflectionProbesMask, mask);
+			InterlockedOr(g_clusters[g_unis.m_tileCount + i].m_reflectionProbesMask, mask);
 #elif OBJECT_TYPE == ANKI_GPU_SCENE_NON_RENDERABLE_OBJECT_TYPE_GLOBAL_ILLUMINATION_PROBE
-			InterlockedOr(g_clusters[g_consts.m_tileCount + i].m_giProbesMask, mask);
+			InterlockedOr(g_clusters[g_unis.m_tileCount + i].m_giProbesMask, mask);
 #else
 #	error See file
 #endif

AnKi/Shaders/ClusterBinningSetup.ankiprog

@@ -16,14 +16,14 @@
 // binning dispatches and the rest GpuSceneNonRenderableObjectType::kCount for the packing dispatches
 [[vk::binding(1)]] RWStructuredBuffer<DispatchIndirectArgs> g_indirectArgs;
 
-struct Constants
+struct Uniforms
 {
 	U32 m_tileCount;
 	U32 m_padding1;
 	U32 m_padding2;
 	U32 m_padding3;
 };
-[[vk::push_constant]] ConstantBuffer<Constants> g_consts;
+[[vk::push_constant]] ConstantBuffer<Uniforms> g_unis;
 
 constexpr U32 kSampleCount = 8;
 constexpr U32 kClusterBinningThreadgroupSize = 64;
@@ -41,7 +41,7 @@ constexpr U32 kPackVisiblesThreadgroupSize = 64;
 		const U32 objCount = min(kMaxVisibleClusteredObjects[(U32)type], g_visibleIndices[(U32)type][0]);
 
 		DispatchIndirectArgs args;
-		args.m_threadGroupCountX = (g_consts.m_tileCount * kSampleCount + kClusterBinningThreadgroupSize - 1) / kClusterBinningThreadgroupSize;
+		args.m_threadGroupCountX = (g_unis.m_tileCount * kSampleCount + kClusterBinningThreadgroupSize - 1) / kClusterBinningThreadgroupSize;
 		args.m_threadGroupCountY = objCount;
 		args.m_threadGroupCountZ = 1;
 

AnKi/Shaders/ClusteredShadingFunctions.hlsl

@@ -97,7 +97,7 @@ Cluster mergeClusters(Cluster tileCluster, Cluster zCluster)
 }
 
 /// Get the final cluster after ORing and ANDing the masks.
-Cluster getClusterFragCoord(StructuredBuffer<Cluster> clusters, GlobalRendererConstants consts, Vec3 fragCoord)
+Cluster getClusterFragCoord(StructuredBuffer<Cluster> clusters, GlobalRendererUniforms consts, Vec3 fragCoord)
 {
 	const Cluster tileCluster = clusters[computeTileClusterIndexFragCoord(fragCoord.xy, consts.m_tileCounts.x)];
 	const Cluster zCluster = clusters[computeZSplitClusterIndex(fragCoord.z, consts.m_zSplitCount, consts.m_zSplitMagic.x, consts.m_zSplitMagic.y)

AnKi/Shaders/DbgBillboard.ankiprog

@@ -13,13 +13,13 @@
 constexpr F32 kAlpha = 1.0f;
 constexpr F32 kBillboardScale = 0.25f;
 
-struct Constants
+struct Uniforms
 {
 	Mat4 m_viewProjMat;
 	Mat3x4 m_camTrf;
 };
 
-[[vk::push_constant]] ConstantBuffer<Constants> g_consts;
+[[vk::push_constant]] ConstantBuffer<Uniforms> g_unis;
 
 #if OBJECT_TYPE == ANKI_GPU_SCENE_NON_RENDERABLE_OBJECT_TYPE_LIGHT
 typedef LightUnion ClusteredType;
@@ -85,9 +85,9 @@ VertOut main(VertIn input)
 #endif
 
 		// Rotate towards the camera and apply translation
-		const Vec3 worldPos = mul(g_consts.m_camTrf, Vec4((output.m_uv * 2.0 - 1.0) * kBillboardScale, 0.0, 0.0)) + localPos;
+		const Vec3 worldPos = mul(g_unis.m_camTrf, Vec4((output.m_uv * 2.0 - 1.0) * kBillboardScale, 0.0, 0.0)) + localPos;
 
-		output.m_svPosition = mul(g_consts.m_viewProjMat, Vec4(worldPos, 1.0));
+		output.m_svPosition = mul(g_unis.m_viewProjMat, Vec4(worldPos, 1.0));
 	}
 	else
 	{

AnKi/Shaders/DbgRenderables.ankiprog

@@ -8,13 +8,13 @@
 #include <AnKi/Shaders/Common.hlsl>
 #include <AnKi/Shaders/Include/GpuSceneTypes.h>
 
-struct Constants
+struct Uniforms
 {
 	Vec4 m_color;
 	Mat4 m_viewProjMat;
 };
 
-[[vk::push_constant]] ConstantBuffer<Constants> g_consts;
+[[vk::push_constant]] ConstantBuffer<Uniforms> g_unis;
 
 [[vk::binding(2)]] StructuredBuffer<GpuSceneRenderableBoundingVolume> g_renderableBoundingVolumes;
 [[vk::binding(3)]] StructuredBuffer<U32> g_visibleRenderableBoundingVolumeIndices;
@@ -42,7 +42,7 @@ VertOut main(VertIn input)
 		const GpuSceneRenderableBoundingVolume bvol = g_renderableBoundingVolumes[g_visibleRenderableBoundingVolumeIndices[input.m_svInstanceId + 1]];
 		const Vec3 boxCenter = (bvol.m_aabbMin + bvol.m_aabbMax) * 0.5f;
 		Vec3 localPos = input.m_position * (bvol.m_aabbMax - boxCenter) + boxCenter;
-		output.m_svPosition = mul(g_consts.m_viewProjMat, Vec4(localPos, 1.0));
+		output.m_svPosition = mul(g_unis.m_viewProjMat, Vec4(localPos, 1.0));
 	}
 	else
 	{
@@ -76,11 +76,11 @@ Vec4 main(VertOut input) : SV_TARGET0
 	const Bool depthTestFailed = input.m_svPosition.z >= depthRef;
 	if(depthTestFailed)
 	{
-		return g_consts.m_color * 0.5;
+		return g_unis.m_color * 0.5;
 	}
 #endif
 
 	// Write the color
-	return g_consts.m_color;
+	return g_unis.m_color;
 }
 #pragma anki technique_end frag

AnKi/Shaders/DepthDownscale.ankiprog

@@ -9,9 +9,9 @@
 #include <AnKi/Shaders/Common.hlsl>
 #include <AnKi/Shaders/Include/MiscRendererTypes.h>
 
-[[vk::push_constant]] ConstantBuffer<DepthDownscaleConstants> g_consts;
+[[vk::push_constant]] ConstantBuffer<DepthDownscaleUniforms> g_unis;
 
-[[vk::binding(0)]] RWTexture2D<Vec4> g_dstUavs[kMaxMipsSinglePassDownsamplerCanProduce];
+[[vk::binding(0)]] RWTexture2D<Vec4> g_dstStorageTextures[kMaxMipsSinglePassDownsamplerCanProduce];
 [[vk::binding(1)]] globallycoherent RWStructuredBuffer<U32> g_spdCounter;
 
 [[vk::binding(2)]] SamplerState u_linearAnyClampSampler;
@@ -28,20 +28,20 @@ groupshared AF1 s_spdIntermediateR[16][16];
 AF4 SpdLoadSourceImage(AU2 p, AU1 slice)
 {
 	ANKI_MAYBE_UNUSED(slice);
-	const AF2 textureCoord = Vec2(p) * g_consts.m_srcTexSizeOverOne + g_consts.m_srcTexSizeOverOne;
+	const AF2 textureCoord = Vec2(p) * g_unis.m_srcTexSizeOverOne + g_unis.m_srcTexSizeOverOne;
 	return AF4(g_srcTex.SampleLevel(u_linearAnyClampSampler, textureCoord, 0.0).r, 0.0, 0.0, 0.0);
 }
 
 AF4 SpdLoad(AU2 p, AU1 slice)
 {
 	ANKI_MAYBE_UNUSED(slice);
-	return AF4(g_dstUavs[5][p].r, 0.0, 0.0, 0.0);
+	return AF4(g_dstStorageTextures[5][p].r, 0.0, 0.0, 0.0);
 }
 
 void SpdStore(AU2 p, AF4 value, AU1 mip, AU1 slice)
 {
 	ANKI_MAYBE_UNUSED(slice);
-	g_dstUavs[mip][p] = Vec4(value.x, 0.0, 0.0, 0.0);
+	g_dstStorageTextures[mip][p] = Vec4(value.x, 0.0, 0.0, 0.0);
 }
 
 void SpdIncreaseAtomicCounter(AU1 slice)
@@ -89,7 +89,7 @@ AF4 SpdReduce4(AF4 v0, AF4 v1, AF4 v2, AF4 v3)
 {
 	const U32 slice = 0u;
 	const UVec2 offset = UVec2(0, 0);
-	SpdDownsample(AU2(svGroupId.xy), AU1(svGroupIndex), AU1(g_consts.m_mipmapCount), AU1(g_consts.m_threadgroupCount), slice, offset);
+	SpdDownsample(AU2(svGroupId.xy), AU1(svGroupIndex), AU1(g_unis.m_mipmapCount), AU1(g_unis.m_threadgroupCount), slice, offset);
 }
 
 #pragma anki technique_end comp

AnKi/Shaders/DownscaleBlur.ankiprog

@@ -13,15 +13,15 @@
 constexpr U32 kTonemappingBinding = 2u;
 #	include <AnKi/Shaders/TonemappingResources.hlsl>
 
-struct Constants
+struct Uniforms
 {
 	Vec2 m_fbSize;
 	UVec2 m_padding;
 };
-[[vk::push_constant]] ConstantBuffer<Constants> g_consts;
+[[vk::push_constant]] ConstantBuffer<Uniforms> g_unis;
 
 #	if ANKI_COMPUTE_SHADER
-[[vk::binding(3)]] RWTexture2D<RVec4> g_outUav;
+[[vk::binding(3)]] RWTexture2D<RVec4> g_storageTex;
 #	endif
 
 #	if ANKI_COMPUTE_SHADER
@@ -31,7 +31,7 @@ RVec3 main([[vk::location(0)]] Vec2 uv : TEXCOORD) : SV_TARGET0
 #	endif
 {
 #	if ANKI_COMPUTE_SHADER
-	const Vec2 uv = (Vec2(svDispatchThreadId) + 0.5) / g_consts.m_fbSize;
+	const Vec2 uv = (Vec2(svDispatchThreadId) + 0.5) / g_unis.m_fbSize;
 #	endif
 
 	RVec3 output;
@@ -43,7 +43,7 @@ RVec3 main([[vk::location(0)]] Vec2 uv : TEXCOORD) : SV_TARGET0
 	output += g_tex.SampleLevel(g_linearAnyClampSampler, uv, 0.0, IVec2(-1, +1)) * weight;
 
 #	if ANKI_COMPUTE_SHADER
-	g_outUav[svDispatchThreadId] = RVec4(output, 1.0);
+	g_storageTex[svDispatchThreadId] = RVec4(output, 1.0);
 #	else
 	return output;
 #	endif

AnKi/Shaders/DrawerStats.ankiprog

@@ -14,12 +14,12 @@
 constexpr U32 kQuadSizeXY = 4;
 constexpr U32 kThreadCount = kQuadSizeXY * kQuadSizeXY;
 
-struct Constants
+struct Uniforms
 {
 	UVec4 m_viewport;
 };
 
-[[vk::push_constant]] ConstantBuffer<Constants> g_consts;
+[[vk::push_constant]] ConstantBuffer<Uniforms> g_unis;
 
 #pragma anki technique_start vert
 
@@ -32,7 +32,7 @@ VertOut main(U32 vertId : SV_VERTEXID)
 {
 	Vec2 uv = Vec2(vertId & 1u, ((vertId + 1u) / 3u) & 1u);
 
-	uv *= 1.0f / Vec2(g_consts.m_viewport.zw) * F32(kQuadSizeXY);
+	uv *= 1.0f / Vec2(g_unis.m_viewport.zw) * F32(kQuadSizeXY);
 
 	VertOut output;
 	output.m_position = Vec4(uv * 2.0 - 1.0, 0.0, 1.0);
@@ -69,7 +69,7 @@ void
 #endif
 main(Vec4 svPosition : SV_POSITION)
 {
-	const UVec2 pos = UVec2(svPosition.xy - Vec2(g_consts.m_viewport.xy));
+	const UVec2 pos = UVec2(svPosition.xy - Vec2(g_unis.m_viewport.xy));
 	const U32 threadIdx = pos.y * kQuadSizeXY + pos.x;
 
 	U32 threadsExecuted;

AnKi/Shaders/FinalComposite.ankiprog

@@ -27,7 +27,7 @@
 [[vk::binding(8)]] Texture2D<RVec4> g_dbgOutlineRt;
 #endif
 
-struct PushConstants
+struct Uniforms
 {
 	U32 m_motionBlurSamples;
 	F32 m_filmGrainStrength;
@@ -35,7 +35,7 @@ struct PushConstants
 	U32 m_padding;
 };
 
-[[vk::push_constant]] ConstantBuffer<PushConstants> g_pc;
+[[vk::push_constant]] ConstantBuffer<Uniforms> g_unis;
 
 RVec3 colorGrading(RVec3 color)
 {
@@ -54,9 +54,9 @@ RVec3 main([[vk::location(0)]] Vec2 uv : TEXCOORD) : SV_TARGET0
 {
 	RVec3 outColor;
 
-	if(g_pc.m_motionBlurSamples > 0u)
+	if(g_unis.m_motionBlurSamples > 0u)
 	{
-		outColor = motionBlur(g_motionVectorsRt, g_nearestAnyClampSampler, g_lightShadingRt, g_linearAnyClampSampler, uv, g_pc.m_motionBlurSamples);
+		outColor = motionBlur(g_motionVectorsRt, g_nearestAnyClampSampler, g_lightShadingRt, g_linearAnyClampSampler, uv, g_unis.m_motionBlurSamples);
 	}
 	else
 	{
@@ -72,7 +72,7 @@ RVec3 main([[vk::location(0)]] Vec2 uv : TEXCOORD) : SV_TARGET0
 
 #if FILM_GRAIN
 	const F32 dt = 1.0;
-	outColor = filmGrain<F32>(outColor, uv, g_pc.m_filmGrainStrength, F32(g_pc.m_frameCount % 0xFFFFu) * dt);
+	outColor = filmGrain<F32>(outColor, uv, g_unis.m_filmGrainStrength, F32(g_unis.m_frameCount % 0xFFFFu) * dt);
 #endif
 
 #if DBG_ENABLED

AnKi/Shaders/ForwardShadingCommon.hlsl

@@ -45,7 +45,7 @@ Vec3 computeLightColorHigh(Vec3 diffCol, Vec3 worldPos, Vec4 svPosition)
 	Vec3 outColor = Vec3(0.0, 0.0, 0.0);
 
 	// Find the cluster and then the light counts
-	Cluster cluster = getClusterFragCoord(g_clusters, g_globalRendererConstants, svPosition.xyz);
+	Cluster cluster = getClusterFragCoord(g_clusters, g_globalRendererUniforms, svPosition.xyz);
 
 	// Point lights
 	U32 idx = 0;
@@ -98,9 +98,9 @@ RVec3 computeLightColorLow(RVec3 diffCol, RVec3 worldPos, Vec4 svPosition)
 {
 	ANKI_MAYBE_UNUSED(worldPos);
 
-	const Vec2 uv = svPosition.xy / g_globalRendererConstants.m_renderingSize;
-	const F32 linearDepth = linearizeDepth(svPosition.z, g_globalRendererConstants.m_near, g_globalRendererConstants.m_far);
-	const F32 w = linearDepth * (F32(g_globalRendererConstants.m_zSplitCount) / F32(g_globalRendererConstants.m_lightVolumeLastZSplit + 1u));
+	const Vec2 uv = svPosition.xy / g_globalRendererUniforms.m_renderingSize;
+	const F32 linearDepth = linearizeDepth(svPosition.z, g_globalRendererUniforms.m_near, g_globalRendererUniforms.m_far);
+	const F32 w = linearDepth * (F32(g_globalRendererUniforms.m_zSplitCount) / F32(g_globalRendererUniforms.m_lightVolumeLastZSplit + 1u));
 	const Vec3 uvw = Vec3(uv, w);
 
 	const RVec3 light = g_lightVol.SampleLevel(g_linearAnyClampSampler, uvw, 0.0).rgb;
@@ -114,13 +114,13 @@ void particleAlpha(RVec4 color, RVec4 scaleColor, RVec4 biasColor, out FragOut o
 
 void fog(RVec3 color, RF32 fogAlphaScale, RF32 fogDistanceOfMaxThikness, F32 zVSpace, Vec2 svPosition, out FragOut output)
 {
-	const Vec2 screenSize = 1.0 / g_globalRendererConstants.m_renderingSize;
+	const Vec2 screenSize = 1.0 / g_globalRendererUniforms.m_renderingSize;
 
 	const Vec2 texCoords = svPosition * screenSize;
 	const F32 depth = g_gbufferDepthTex.Sample(g_linearAnyClampSampler, texCoords, 0.0).r;
 	F32 zFeatherFactor;
 
-	const Vec4 fragPosVspace4 = mul(g_globalRendererConstants.m_matrices.m_invertedProjectionJitter, Vec4(Vec3(uvToNdc(texCoords), depth), 1.0));
+	const Vec4 fragPosVspace4 = mul(g_globalRendererUniforms.m_matrices.m_invertedProjectionJitter, Vec4(Vec3(uvToNdc(texCoords), depth), 1.0));
 	const F32 sceneZVspace = fragPosVspace4.z / fragPosVspace4.w;
 
 	const F32 diff = max(0.0, zVSpace - sceneZVspace);

AnKi/Shaders/ForwardShadingFog.ankiprog

@@ -6,7 +6,7 @@
 #include <AnKi/Shaders/ForwardShadingCommon.hlsl>
 #include <AnKi/Shaders/Functions.hlsl>
 
-#pragma anki struct AnKiLocalConstants
+#pragma anki struct AnKiLocalUniforms
 #pragma anki member RVec3 m_fogColor
 #pragma anki member RF32 m_fogAlphaScale
 #pragma anki member RF32 m_fogDistanceOfMaxThikness
@@ -22,7 +22,7 @@ struct VertOut
 {
 	Vec4 m_svPosition : SV_POSITION;
 	F32 m_zVSpace : ZVSPACE;
-	nointerpolation U32 m_constantsOffset : UNIFORMS;
+	nointerpolation U32 m_uniformsOffset : UNIFORMS;
 };
 
 #pragma anki technique_start vert Forward
@@ -37,12 +37,12 @@ VertOut main(VertIn input)
 	const UnpackedMeshVertex vertex = loadVertex(mesh, input.m_svVertexId, false);
 
 	const Vec3 worldPos = mul(worldTransform, Vec4(vertex.m_position, 1.0));
-	output.m_svPosition = mul(g_globalConstants.m_viewProjectionMatrix, Vec4(worldPos, 1.0));
+	output.m_svPosition = mul(g_globalUniforms.m_viewProjectionMatrix, Vec4(worldPos, 1.0));
 
-	const Vec3 viewPos = mul(g_globalConstants.m_viewTransform, Vec4(worldPos, 1.0));
+	const Vec3 viewPos = mul(g_globalUniforms.m_viewTransform, Vec4(worldPos, 1.0));
 	output.m_zVSpace = viewPos.z;
 
-	output.m_constantsOffset = renderable.m_constantsOffset;
+	output.m_uniformsOffset = renderable.m_uniformsOffset;
 
 	return output;
 }
@@ -54,9 +54,9 @@ VertOut main(VertIn input)
 FragOut main(VertOut input)
 {
 	FragOut output = (FragOut)0;
-	const AnKiLocalConstants localConstants = loadAnKiLocalConstants(g_gpuScene, input.m_constantsOffset);
+	const AnKiLocalUniforms localUniforms = loadAnKiLocalUniforms(g_gpuScene, input.m_uniformsOffset);
 
-	fog(localConstants.m_fogColor, localConstants.m_fogAlphaScale, localConstants.m_fogDistanceOfMaxThikness, input.m_svPosition, input.m_zVSpace,
+	fog(localUniforms.m_fogColor, localUniforms.m_fogAlphaScale, localUniforms.m_fogDistanceOfMaxThikness, input.m_svPosition, input.m_zVSpace,
 		output);
 
 	return output;

AnKi/Shaders/ForwardShadingGenericTransparent.ankiprog

@@ -8,7 +8,7 @@
 
 #include <AnKi/Shaders/ForwardShadingCommon.hlsl>
 
-#pragma anki struct AnKiLocalConstants
+#pragma anki struct AnKiLocalUniforms
 #pragma anki member U32 m_texture
 #pragma anki member RVec4 m_colorScale
 #pragma anki member RVec4 m_colorBias
@@ -25,7 +25,7 @@ struct VertOut
 	Vec2 m_uv : TEXCOORD;
 	Vec3 m_worldPosition : WORLD_POSITION;
 	Vec4 m_svPosition : SV_POSITION;
-	nointerpolation U32 m_constantsOffset : UNIFORMS_OFFSET;
+	nointerpolation U32 m_uniformsOffset : UNIFORMS_OFFSET;
 };
 
 #pragma anki technique_start vert Forward
@@ -41,10 +41,10 @@ VertOut main(VertIn input)
 
 	output.m_worldPosition = mul(worldTransform, Vec4(vertex.m_position, 1.0));
 
-	output.m_svPosition = mul(g_globalConstants.m_viewProjectionMatrix, Vec4(output.m_worldPosition, 1.0));
+	output.m_svPosition = mul(g_globalUniforms.m_viewProjectionMatrix, Vec4(output.m_worldPosition, 1.0));
 
 	output.m_uv = vertex.m_uv;
-	output.m_constantsOffset = renderable.m_constantsOffset;
+	output.m_uniformsOffset = renderable.m_uniformsOffset;
 
 	return output;
 }
@@ -57,19 +57,19 @@ FragOut main(VertOut input)
 	ANKI_MAYBE_UNUSED(input);
 	FragOut output;
 
-	const AnKiLocalConstants localConstants = loadAnKiLocalConstants(g_gpuScene, WaveReadLaneFirst(input.m_constantsOffset));
+	const AnKiLocalUniforms localUniforms = loadAnKiLocalUniforms(g_gpuScene, WaveReadLaneFirst(input.m_uniformsOffset));
 
 	output.m_color = RVec4(1.0, 1.0, 1.0, 1.0);
 
 #if TEXTURE == 1
-	output.m_color = g_bindlessTextures2dF32[localConstants.m_texture].Sample(g_globalSampler, input.m_uv);
+	output.m_color = g_bindlessTextures2dF32[localUniforms.m_texture].Sample(g_globalSampler, input.m_uv);
 #endif
 
 #if LIGHT == 1
 	output.m_color.rgb = computeLightColorLow(output.m_color.rgb, input.m_worldPosition, input.m_svPosition);
 #endif
 
-	output.m_color = output.m_color * localConstants.m_colorScale + localConstants.m_colorBias;
+	output.m_color = output.m_color * localUniforms.m_colorScale + localUniforms.m_colorBias;
 
 	return output;
 }

AnKi/Shaders/ForwardShadingParticles.ankiprog

@@ -16,14 +16,14 @@ struct VertIn
 
 struct VertOut
 {
-	nointerpolation U32 m_constantsOffset : UNIS_OFFSET;
+	nointerpolation U32 m_uniformsOffset : UNIS_OFFSET;
 	nointerpolation RF32 m_alpha : ALPHA;
 	Vec2 m_uv : TEXCOORD;
 	Vec3 m_worldPos : WORLD_POS;
 	Vec4 m_svPosition : SV_POSITION;
 };
 
-#pragma anki struct AnKiLocalConstants
+#pragma anki struct AnKiLocalUniforms
 #pragma anki member F32 m_animationPeriod
 #pragma anki member Vec4 m_colorScale
 #pragma anki member Vec4 m_colorBias
@@ -57,12 +57,12 @@ VertOut main(VertIn input)
 		+ meshLod.m_positionTranslation;
 
 	// Apply the particle scale, rotate the mesh to face the camera (billboard) and finally apply the particle position
-	output.m_worldPos = mul(g_globalConstants.m_cameraTransform, Vec4(localPos * particleScale, 0.0)) + particlePos;
+	output.m_worldPos = mul(g_globalUniforms.m_cameraTransform, Vec4(localPos * particleScale, 0.0)) + particlePos;
 
-	output.m_svPosition = mul(g_globalConstants.m_viewProjectionMatrix, Vec4(output.m_worldPos, 1.0));
+	output.m_svPosition = mul(g_globalUniforms.m_viewProjectionMatrix, Vec4(output.m_worldPos, 1.0));
 
 	output.m_alpha = particleAlpha;
-	output.m_constantsOffset = renderable.m_constantsOffset;
+	output.m_uniformsOffset = renderable.m_uniformsOffset;
 
 	return output;
 }
@@ -73,22 +73,22 @@ VertOut main(VertIn input)
 FragOut main(VertOut input)
 {
 	FragOut output = (FragOut)0;
-	const AnKiLocalConstants localConstants = loadAnKiLocalConstants(g_gpuScene, WaveReadLaneFirst(input.m_constantsOffset));
+	const AnKiLocalUniforms localUniforms = loadAnKiLocalUniforms(g_gpuScene, WaveReadLaneFirst(input.m_uniformsOffset));
 
 #if ANIMATED_TEXTURE == 1
-	RVec4 texCol = readAnimatedTextureRgba(g_bindlessTextures2dArrayF32[localConstants.m_diffuseMap], g_globalSampler,
-										   localConstants.m_animationPeriod, input.m_uv, g_globalRendererConstants.m_time);
+	RVec4 texCol = readAnimatedTextureRgba(g_bindlessTextures2dArrayF32[localUniforms.m_diffuseMap], g_globalSampler, localUniforms.m_animationPeriod,
+										   input.m_uv, g_globalRendererUniforms.m_time);
 #else
-	RVec4 texCol = g_bindlessTextures2dF32[localConstants.m_diffuseMap].Sample(g_globalSampler, input.m_uv);
+	RVec4 texCol = g_bindlessTextures2dF32[localUniforms.m_diffuseMap].Sample(g_globalSampler, input.m_uv);
 #endif
 
 #if LIGHT
 	texCol.rgb = computeLightColorLow(texCol.rgb, input.m_worldPos, input.m_svPosition);
 #endif
 
-	RVec4 colScale = localConstants.m_colorScale;
+	RVec4 colScale = localUniforms.m_colorScale;
 	colScale.a *= input.m_alpha;
-	particleAlpha(texCol, colScale, localConstants.m_colorBias, output);
+	particleAlpha(texCol, colScale, localUniforms.m_colorBias, output);
 
 	return output;
 }

AnKi/Shaders/Fsr.ankiprog

@@ -13,10 +13,10 @@
 [[vk::binding(0)]] SamplerState g_linearAnyClampSampler;
 [[vk::binding(1)]] Texture2D<Vec4> g_tex;
 #	if ANKI_COMPUTE_SHADER
-[[vk::binding(2)]] RWTexture2D<Vec4> g_outUav;
+[[vk::binding(2)]] RWTexture2D<Vec4> g_storageTex;
 #	endif
 
-struct Constants
+struct Uniforms
 {
 	UVec4 m_fsrConsts0;
 	UVec4 m_fsrConsts1;
@@ -26,7 +26,7 @@ struct Constants
 	UVec2 m_padding;
 };
 
-[[vk::push_constant]] ConstantBuffer<Constants> g_consts;
+[[vk::push_constant]] ConstantBuffer<Uniforms> g_unis;
 
 // FSR begin
 #	define A_GPU 1
@@ -83,7 +83,7 @@ Vec3 main(Vec4 svPosition : SV_POSITION) : SV_TARGET0
 #	endif
 {
 #	if ANKI_COMPUTE_SHADER
-	if(any(svDispatchThreadId >= g_consts.m_viewportSize))
+	if(any(svDispatchThreadId >= g_unis.m_viewportSize))
 	{
 		return;
 	}
@@ -95,15 +95,15 @@ Vec3 main(Vec4 svPosition : SV_POSITION) : SV_TARGET0
 
 	HVec3 color;
 #	if SHARPEN
-	FsrRcasH(color.r, color.g, color.b, uv, g_consts.m_fsrConsts0);
+	FsrRcasH(color.r, color.g, color.b, uv, g_unis.m_fsrConsts0);
 #	elif FSR_QUALITY == 0
-	FsrEasuL(color, uv, g_consts.m_fsrConsts0, g_consts.m_fsrConsts1, g_consts.m_fsrConsts2, g_consts.m_fsrConsts3);
+	FsrEasuL(color, uv, g_unis.m_fsrConsts0, g_unis.m_fsrConsts1, g_unis.m_fsrConsts2, g_unis.m_fsrConsts3);
 #	else
-	FsrEasuH(color, uv, g_consts.m_fsrConsts0, g_consts.m_fsrConsts1, g_consts.m_fsrConsts2, g_consts.m_fsrConsts3);
+	FsrEasuH(color, uv, g_unis.m_fsrConsts0, g_unis.m_fsrConsts1, g_unis.m_fsrConsts2, g_unis.m_fsrConsts3);
 #	endif
 
 #	if ANKI_COMPUTE_SHADER
-	g_outUav[svDispatchThreadId.xy] = Vec4(color, 0.0);
+	g_storageTex[svDispatchThreadId.xy] = Vec4(color, 0.0);
 #	else
 	return HVec3(color);
 #	endif

AnKi/Shaders/GBufferGeneric.ankiprog

@@ -67,7 +67,7 @@
 #define PRIMITIVE_NO_SAMPLING_POINTS_CULLING 1
 #define PRIMITIVE_ANY_CULLING (PRIMITIVE_BACKFACE_CULLING || PRIMITIVE_NO_SAMPLING_POINTS_CULLING)
 
-#pragma anki struct AnKiLocalConstants
+#pragma anki struct AnKiLocalUniforms
 
 #pragma anki member U32 m_diffuseTex
 #pragma anki member U32 m_normalTex
@@ -117,7 +117,7 @@ struct VertOut
 	nointerpolation U32 m_meshletIndex : MESHLET_INDEX;
 #endif
 
-	nointerpolation U32 m_constantsOffset : UNIS_OFFSET;
+	nointerpolation U32 m_uniformsOffset : UNIS_OFFSET;
 };
 
 struct MeshPerVertOut
@@ -144,7 +144,7 @@ struct MeshPerVertOut
 
 struct MeshPerPrimitiveOut
 {
-	U32 m_constantsOffset : UNIS_OFFSET;
+	U32 m_uniformsOffset : UNIS_OFFSET;
 
 #if VISUALIZE_MESHLETS
 	U32 m_meshletIndex : MESHLET_INDEX;
@@ -166,7 +166,7 @@ struct TaskOut
 	U32 m_firstMeshletGeometryDescriptor;
 	U32 m_visibleMeshletsRelativeIndices[kMeshletGroupSize / sizeof(U32)];
 	U32 m_worldTransformsIndex;
-	U32 m_constantsOffset;
+	U32 m_uniformsOffset;
 	U32 m_boneTransformsOrParticleEmitterOffset;
 };
 
@@ -226,7 +226,7 @@ void velocity(Mat3x4 worldTransform, Mat3x4 prevWorldTransform, Vec3 prevLocalPo
 #	endif
 
 	Vec4 v4 = Vec4(mul(trf, Vec4(prevLocalPos, 1.0)), 1.0);
-	v4 = mul(g_globalConstants.m_previousViewProjectionMatrix, v4);
+	v4 = mul(g_globalUniforms.m_previousViewProjectionMatrix, v4);
 
 	prevClipXyw = v4.xyw;
 	crntClipXyw = svPosition.xyw;
@@ -263,7 +263,7 @@ VertOut main(VertIn input)
 
 	UnpackedMeshVertex vert = loadVertex(meshlet, localIdx, ANKI_BONES);
 
-	const U32 constantsOffset = instance.m_constantsOffset;
+	const U32 uniformsOffset = instance.m_uniformsOffset;
 	const U32 worldTransformsIndex = instance.m_worldTransformsIndex_25bit_meshletPrimitiveCount_7bit >> 7u;
 	const U32 boneTransformsOrParticleEmitterOffset = instance.m_boneTransformsOrParticleEmitterOffset;
 
@@ -276,7 +276,7 @@ VertOut main(VertIn input)
 	const GpuSceneMeshLod mesh = g_meshLods[instance.m_meshLodIndex];
 	UnpackedMeshVertex vert = loadVertex(mesh, input.m_svVertexId, ANKI_BONES);
 
-	const U32 constantsOffset = instance.m_constantsOffset;
+	const U32 uniformsOffset = instance.m_uniformsOffset;
 	const U32 worldTransformsIndex = instance.m_worldTransformsIndex;
 	const U32 boneTransformsOrParticleEmitterOffset = instance.m_boneTransformsOrParticleEmitterOffset;
 #	endif // SW_MESHLETS
@@ -291,7 +291,7 @@ VertOut main(VertIn input)
 #	endif
 	Vec3 prevPos = vert.m_position;
 	ANKI_MAYBE_UNUSED(prevPos);
-	output.m_constantsOffset = constantsOffset;
+	output.m_uniformsOffset = uniformsOffset;
 
 	// Do stuff
 #	if ANKI_BONES
@@ -299,7 +299,7 @@ VertOut main(VertIn input)
 #	endif
 
 	const Vec3 worldPos = mul(worldTransform, Vec4(vert.m_position, 1.0));
-	output.m_svPosition = mul(g_globalConstants.m_viewProjectionMatrix, Vec4(worldPos, 1.0));
+	output.m_svPosition = mul(g_globalUniforms.m_viewProjectionMatrix, Vec4(worldPos, 1.0));
 
 #	if NORMAL_MAPPING
 	output.m_worldPos = worldPos;
@@ -350,7 +350,7 @@ struct FirstPayload
 	{
 		s_payload.m_firstMeshletGeometryDescriptor = firstMeshletGeometryDescriptor;
 		s_payload.m_worldTransformsIndex = renderable.m_worldTransformsIndex;
-		s_payload.m_constantsOffset = renderable.m_constantsOffset;
+		s_payload.m_uniformsOffset = renderable.m_uniformsOffset;
 		s_payload.m_boneTransformsOrParticleEmitterOffset = renderable.m_boneTransformsOffset;
 
 		s_visibleMeshletCount = 0;
@@ -371,11 +371,11 @@ struct FirstPayload
 		const Mat3x4 worldTransform = g_transforms[renderable.m_worldTransformsIndex];
 
 #	if MESHLET_BACKFACE_CULLING
-		cull = cullBackfaceMeshlet(meshletBoundingVol, worldTransform, g_globalConstants.m_cameraTransform.getTranslationPart());
+		cull = cullBackfaceMeshlet(meshletBoundingVol, worldTransform, g_globalUniforms.m_cameraTransform.getTranslationPart());
 #	endif
 
 		const Mat4 wordTransform4 = {worldTransform.m_row0, worldTransform.m_row1, worldTransform.m_row2, Vec4(0.0f, 0.0f, 0.0f, 1.0f)};
-		const Mat4 mvp = mul(g_globalConstants.m_viewProjectionMatrix, wordTransform4);
+		const Mat4 mvp = mul(g_globalUniforms.m_viewProjectionMatrix, wordTransform4);
 
 		Vec2 minNdc, maxNdc;
 		F32 aabbMinDepth;
@@ -388,13 +388,13 @@ struct FirstPayload
 
 #	if MESHLET_NO_SAMPLING_POINT_CULLING
 		// Sampling points test
-		const Vec2 windowCoordsMin = ndcToUv(minNdc) * g_globalConstants.m_viewport.zw;
-		const Vec2 windowCoordsMax = ndcToUv(maxNdc) * g_globalConstants.m_viewport.zw;
+		const Vec2 windowCoordsMin = ndcToUv(minNdc) * g_globalUniforms.m_viewport.zw;
+		const Vec2 windowCoordsMax = ndcToUv(maxNdc) * g_globalUniforms.m_viewport.zw;
 		cull = cull || any(round(windowCoordsMin) == round(windowCoordsMax));
 #	endif
 
 #	if MESHLET_HZB_CULLING
-		cull = cull || (g_globalConstants.m_enableHzbTesting == 1u && cullHzb(minNdc, maxNdc, aabbMinDepth, g_hzbTexture, g_nearestClampSampler));
+		cull = cull || (g_globalUniforms.m_enableHzbTesting == 1u && cullHzb(minNdc, maxNdc, aabbMinDepth, g_hzbTexture, g_nearestClampSampler));
 #	endif
 
 		if(!cull)
@@ -468,9 +468,9 @@ main(U32 svGroupId : SV_GROUPID, U32 svGroupIndex : SV_GROUPINDEX, in payload Ta
 #	endif
 
 			const Vec3 worldPos = mul(worldTransform, Vec4(vert.m_position, 1.0));
-			output.m_svPosition = mul(g_globalConstants.m_viewProjectionMatrix, Vec4(worldPos, 1.0f));
+			output.m_svPosition = mul(g_globalUniforms.m_viewProjectionMatrix, Vec4(worldPos, 1.0f));
 #	if PRIMITIVE_ANY_CULLING
-			s_windowCoords[idx] = ndcToUv(output.m_svPosition.xy / output.m_svPosition.w) * g_globalConstants.m_viewport.zw;
+			s_windowCoords[idx] = ndcToUv(output.m_svPosition.xy / output.m_svPosition.w) * g_globalUniforms.m_viewport.zw;
 			s_clipW[idx] = output.m_svPosition.w;
 #	endif
 
@@ -534,7 +534,7 @@ main(U32 svGroupId : SV_GROUPID, U32 svGroupIndex : SV_GROUPINDEX, in payload Ta
 			primitives[idx].m_cullPrimitive = cull;
 #	endif
 
-			primitives[idx].m_constantsOffset = payload.m_constantsOffset;
+			primitives[idx].m_uniformsOffset = payload.m_uniformsOffset;
 #	if VISUALIZE_MESHLETS
 			primitives[idx].m_meshletIndex = relativeMeshletIdx;
 #	endif
@@ -571,14 +571,14 @@ void main(
 )
 {
 #		if ANKI_TECHNIQUE_ShadowsMeshShaders
-	const U32 constantsOffset = primInput.m_constantsOffset;
+	const U32 uniformsOffset = primInput.m_uniformsOffset;
 #		else
-	const U32 constantsOffset = vertInput.m_constantsOffset;
+	const U32 uniformsOffset = vertInput.m_uniformsOffset;
 #		endif
 
-	const AnKiLocalConstants localConstants = loadAnKiLocalConstants(g_gpuScene, constantsOffset);
-	const RVec4 diffColorA = g_bindlessTextures2dF32[TEX_IDX(localConstants.m_diffuseTex)].Sample(g_globalSampler, vertInput.m_uv);
-	if(diffColorA.a * localConstants.m_diffuseScale.a < 0.5f)
+	const AnKiLocalUniforms localUniforms = loadAnKiLocalUniforms(g_gpuScene, uniformsOffset);
+	const RVec4 diffColorA = g_bindlessTextures2dF32[TEX_IDX(localUniforms.m_diffuseTex)].Sample(g_globalSampler, vertInput.m_uv);
+	if(diffColorA.a * localUniforms.m_diffuseScale.a < 0.5f)
 	{
 		discard;
 	}
@@ -595,12 +595,12 @@ FragOut main(
 )
 {
 #		if ANKI_TECHNIQUE_GBufferMeshShaders
-	const U32 constantsOffset = primInput.m_constantsOffset;
+	const U32 uniformsOffset = primInput.m_uniformsOffset;
 #		else
-	const U32 constantsOffset = vertInput.m_constantsOffset;
+	const U32 uniformsOffset = vertInput.m_uniformsOffset;
 #		endif
 
-	const AnKiLocalConstants localConstants = loadAnKiLocalConstants(g_gpuScene, constantsOffset);
+	const AnKiLocalUniforms localUniforms = loadAnKiLocalUniforms(g_gpuScene, uniformsOffset);
 
 #		if REALLY_USING_PARALLAX
 	// TODO
@@ -611,8 +611,7 @@ FragOut main(
 	ANKI_MAYBE_UNUSED(uv);
 
 #		if DIFFUSE_TEX
-	const RVec4 diffColorA =
-		g_bindlessTextures2dF32[TEX_IDX(localConstants.m_diffuseTex)].Sample(g_globalSampler, uv) * localConstants.m_diffuseScale;
+	const RVec4 diffColorA = g_bindlessTextures2dF32[TEX_IDX(localUniforms.m_diffuseTex)].Sample(g_globalSampler, uv) * localUniforms.m_diffuseScale;
 	const RVec3 diffColor = diffColorA.rgb;
 #			if REALLY_ALPHA_TEST
 	if(diffColorA.a < 0.5f)
@@ -621,29 +620,29 @@ FragOut main(
 	}
 #			endif
 #		else
-	const RVec3 diffColor = localConstants.m_diffuseScale;
+	const RVec3 diffColor = localUniforms.m_diffuseScale;
 #		endif
 
 #		if SPECULAR_TEX
 	const RVec3 specColor =
-		g_bindlessTextures2dF32[TEX_IDX(localConstants.m_specularTex)].Sample(g_globalSampler, uv).rgb * localConstants.m_specularScale;
+		g_bindlessTextures2dF32[TEX_IDX(localUniforms.m_specularTex)].Sample(g_globalSampler, uv).rgb * localUniforms.m_specularScale;
 #		else
-	const RVec3 specColor = localConstants.m_specularScale;
+	const RVec3 specColor = localUniforms.m_specularScale;
 #		endif
 
 #		if ROUGHNESS_METALNESS_TEX
-	const RVec3 comp = g_bindlessTextures2dF32[TEX_IDX(localConstants.m_roughnessMetalnessTex)].Sample(g_globalSampler, uv).rgb;
-	const RF32 roughness = comp.g * localConstants.m_roughnessScale;
-	const RF32 metallic = comp.b * localConstants.m_metalnessScale;
+	const RVec3 comp = g_bindlessTextures2dF32[TEX_IDX(localUniforms.m_roughnessMetalnessTex)].Sample(g_globalSampler, uv).rgb;
+	const RF32 roughness = comp.g * localUniforms.m_roughnessScale;
+	const RF32 metallic = comp.b * localUniforms.m_metalnessScale;
 #		else
-	const RF32 roughness = localConstants.m_roughnessScale;
-	const RF32 metallic = localConstants.m_metalnessScale;
+	const RF32 roughness = localUniforms.m_roughnessScale;
+	const RF32 metallic = localUniforms.m_metalnessScale;
 #		endif
 
 #		if NORMAL_TEX
 	const RVec3 nAtTangentspace =
-		normalize((g_bindlessTextures2dF32[TEX_IDX(localConstants.m_normalTex)].Sample(g_globalSampler, uv).rgb - 0.5) * 2.0);
-	const Vec3 viewDir = normalize(g_globalConstants.m_cameraTransform.getTranslationPart() - vertInput.m_worldPos);
+		normalize((g_bindlessTextures2dF32[TEX_IDX(localUniforms.m_normalTex)].Sample(g_globalSampler, uv).rgb - 0.5) * 2.0);
+	const Vec3 viewDir = normalize(g_globalUniforms.m_cameraTransform.getTranslationPart() - vertInput.m_worldPos);
 	const RVec3 normal = perturbNormal(nAtTangentspace, viewDir, uv, normalize(vertInput.m_normal));
 #		else
 	const RVec3 normal = normalize(vertInput.m_normal);
@@ -651,9 +650,9 @@ FragOut main(
 
 #		if EMISSIVE_TEX
 	const RVec3 emission =
-		g_bindlessTextures2dF32[TEX_IDX(localConstants.m_emissiveTex)].Sample(g_globalSampler, uv).rgb * localConstants.m_emissionScale;
+		g_bindlessTextures2dF32[TEX_IDX(localUniforms.m_emissiveTex)].Sample(g_globalSampler, uv).rgb * localUniforms.m_emissionScale;
 #		else
-	const RVec3 emission = localConstants.m_emissionScale;
+	const RVec3 emission = localUniforms.m_emissionScale;
 #		endif
 
 #		if ANKI_VELOCITY || ANKI_BONES
@@ -671,7 +670,7 @@ FragOut main(
 	g.m_normal = normal;
 	g.m_f0 = specColor;
 	g.m_roughness = roughness;
-	g.m_subsurface = localConstants.m_subsurface;
+	g.m_subsurface = localUniforms.m_subsurface;
 	g.m_emission = emission;
 	g.m_metallic = metallic;
 	g.m_velocity = velocity;
@@ -743,9 +742,8 @@ FragOut main(
 
 	const Vec2 uv = vert0.m_uv * bary.x + vert1.m_uv * bary.y + vert2.m_uv * bary.z;
 
-	const AnKiLocalConstants localConstants = loadAnKiLocalConstants(g_gpuScene, g_gpuSceneRenderable.m_constantsOffset);
-	const RVec4 diffColorA =
-		g_bindlessTextures2dF32[localConstants.m_diffuseTex].SampleLevel(g_globalSampler, uv, 0.0) * localConstants.m_diffuseScale;
+	const AnKiLocalUniforms localUniforms = loadAnKiLocalUniforms(g_gpuScene, g_gpuSceneRenderable.m_uniformsOffset);
+	const RVec4 diffColorA = g_bindlessTextures2dF32[localUniforms.m_diffuseTex].SampleLevel(g_globalSampler, uv, 0.0) * localUniforms.m_diffuseScale;
 
 	if(diffColorA.a < 1.0)
 	{

AnKi/Shaders/GBufferGpuParticles.ankiprog

@@ -5,7 +5,7 @@
 
 #include <AnKi/Shaders/MaterialShadersCommon.hlsl>
 
-#pragma anki struct AnKiLocalConstants
+#pragma anki struct AnKiLocalUniforms
 #pragma anki member RVec3 m_diffColor
 #pragma anki member RF32 m_roughness
 #pragma anki member RVec3 m_specColor
@@ -24,7 +24,7 @@ struct VertOut
 {
 	nointerpolation Vec2 m_velocity : VELOCITY;
 	nointerpolation RF32 m_lifeFactor : LIFE_FACTOR;
-	nointerpolation U32 m_constantsOffset : UNIFORMS_OFFSET;
+	nointerpolation U32 m_uniformsOffset : UNIFORMS_OFFSET;
 	Vec4 m_svPosition : SV_POSITION;
 };
 
@@ -60,8 +60,8 @@ VertOut main(VertIn input)
 	const F32 startingLife = g_gpuScene.Load<F32>(offset);
 
 	// Position
-	const Vec4 clipPos = mul(g_globalConstants.m_viewProjectionMatrix, Vec4(pos, 1.0));
-	const Vec4 prevClipPos = mul(g_globalConstants.m_viewProjectionMatrix, Vec4(prevPos, 1.0));
+	const Vec4 clipPos = mul(g_globalUniforms.m_viewProjectionMatrix, Vec4(pos, 1.0));
+	const Vec4 prevClipPos = mul(g_globalUniforms.m_viewProjectionMatrix, Vec4(prevPos, 1.0));
 
 	output.m_svPosition = clipPos;
 
@@ -72,7 +72,7 @@ VertOut main(VertIn input)
 
 	// Misc
 	output.m_lifeFactor = saturate(1.0 - (life / startingLife));
-	output.m_constantsOffset = renderable.m_constantsOffset;
+	output.m_uniformsOffset = renderable.m_uniformsOffset;
 
 	return output;
 }
@@ -84,19 +84,19 @@ VertOut main(VertIn input)
 FragOut main(VertOut input)
 {
 	FragOut output;
-	const AnKiLocalConstants localConstants = loadAnKiLocalConstants(g_gpuScene, input.m_constantsOffset);
+	const AnKiLocalUniforms localUniforms = loadAnKiLocalUniforms(g_gpuScene, input.m_uniformsOffset);
 
 	GbufferInfo g;
-	g.m_diffuse = localConstants.m_diffColor;
+	g.m_diffuse = localUniforms.m_diffColor;
 
-	const Mat3x4 camTrf = g_globalConstants.m_cameraTransform;
+	const Mat3x4 camTrf = g_globalUniforms.m_cameraTransform;
 	g.m_normal = normalize(Vec3(camTrf.m_row0[2], camTrf.m_row1[2], camTrf.m_row2[2]));
 
-	g.m_f0 = localConstants.m_specColor;
-	g.m_roughness = localConstants.m_roughness;
+	g.m_f0 = localUniforms.m_specColor;
+	g.m_roughness = localUniforms.m_roughness;
 	g.m_subsurface = 0.0;
-	g.m_emission = lerp(localConstants.m_initialEmission, localConstants.m_finalEmission, input.m_lifeFactor);
-	g.m_metallic = localConstants.m_metallic;
+	g.m_emission = lerp(localUniforms.m_initialEmission, localUniforms.m_finalEmission, input.m_lifeFactor);
+	g.m_metallic = localUniforms.m_metallic;
 	g.m_velocity = input.m_velocity;
 	packGBuffer(g, output.m_color0, output.m_color1, output.m_color2, output.m_color3);
 	return output;

AnKi/Shaders/GBufferPost.ankiprog

@@ -17,7 +17,7 @@
 [[vk::binding(1)]] Texture2D g_depthTex;
 [[vk::binding(2)]] SamplerState g_trilinearRepeatSampler;
 
-[[vk::binding(3)]] ConstantBuffer<GlobalRendererConstants> g_globalConsts;
+[[vk::binding(3)]] ConstantBuffer<GlobalRendererUniforms> g_globalUniforms;
 [[vk::binding(4)]] StructuredBuffer<Decal> g_decals;
 [[vk::binding(5)]] StructuredBuffer<Cluster> g_clusters;
 
@@ -44,11 +44,11 @@ FragOut main([[vk::location(0)]] Vec2 uv : TEXCOORD, Vec4 svPosition : SV_POSITI
 	// Get worldPos
 	const F32 depth = g_depthTex.SampleLevel(g_nearestAnyClampSampler, uv, 0.0).r;
 	const Vec2 ndc = uvToNdc(uv);
-	const Vec4 worldPos4 = mul(g_globalConsts.m_matrices.m_invertedViewProjectionJitter, Vec4(ndc, depth, 1.0));
+	const Vec4 worldPos4 = mul(g_globalUniforms.m_matrices.m_invertedViewProjectionJitter, Vec4(ndc, depth, 1.0));
 	const Vec3 worldPos = worldPos4.xyz / worldPos4.w;
 
 	// Get the cluster
-	Cluster cluster = getClusterFragCoord(g_clusters, g_globalConsts, Vec3(svPosition.xy, depth));
+	Cluster cluster = getClusterFragCoord(g_clusters, g_globalUniforms, Vec3(svPosition.xy, depth));
 
 	// Make the decalsMask uniform across the wave because we are accessing bindless textures later on
 	U32 decalsMask = cluster.m_decalsMask[0];

AnKi/Shaders/GpuVisibility.ankiprog

@@ -57,9 +57,9 @@ struct DrawIndirectArgsWithPadding
 [[vk::binding(10)]] StructuredBuffer<UVec2> g_instanceRanges;
 
 #if DISTANCE_TEST == 0
-[[vk::binding(11)]] ConstantBuffer<FrustumGpuVisibilityConstants> g_consts;
+[[vk::binding(11)]] ConstantBuffer<FrustumGpuVisibilityUniforms> g_unis;
 #else
-[[vk::push_constant]] ConstantBuffer<DistanceGpuVisibilityConstants> g_consts;
+[[vk::push_constant]] ConstantBuffer<DistanceGpuVisibilityUniforms> g_unis;
 #endif
 
 #if HZB_TEST
@@ -94,7 +94,7 @@ struct DrawIndirectArgsWithPadding
 #if DISTANCE_TEST == 0
 	// Frustum test
 	//
-	if(!frustumTest(g_consts.m_clipPlanes, sphereCenter, sphereRadius))
+	if(!frustumTest(g_unis.m_clipPlanes, sphereCenter, sphereRadius))
 	{
 		return;
 	}
@@ -103,7 +103,7 @@ struct DrawIndirectArgsWithPadding
 	//
 	Vec2 minNdc, maxNdc;
 	F32 aabbMinDepth;
-	projectAabb(bvolume.m_aabbMin, bvolume.m_aabbMax, g_consts.m_viewProjectionMat, minNdc, maxNdc, aabbMinDepth);
+	projectAabb(bvolume.m_aabbMin, bvolume.m_aabbMax, g_unis.m_viewProjectionMat, minNdc, maxNdc, aabbMinDepth);
 
 	if(any(minNdc > 1.0f) || any(maxNdc < -1.0f))
 	{
@@ -111,8 +111,8 @@ struct DrawIndirectArgsWithPadding
 		return;
 	}
 
-	const Vec2 windowCoordsMin = ndcToUv(minNdc) * g_consts.m_finalRenderTargetSize;
-	const Vec2 windowCoordsMax = ndcToUv(maxNdc) * g_consts.m_finalRenderTargetSize;
+	const Vec2 windowCoordsMin = ndcToUv(minNdc) * g_unis.m_finalRenderTargetSize;
+	const Vec2 windowCoordsMax = ndcToUv(maxNdc) * g_unis.m_finalRenderTargetSize;
 	if(any(round(windowCoordsMin) == round(windowCoordsMax)))
 	{
 		// Doesn't touch the sampling points
@@ -129,7 +129,7 @@ struct DrawIndirectArgsWithPadding
 #	endif // HZB_TEST
 
 #else // DISTANCE_TEST == 1
-	if(!testSphereSphereCollision(sphereCenter, sphereRadius, g_consts.m_pointOfTest, g_consts.m_testRadius))
+	if(!testSphereSphereCollision(sphereCenter, sphereRadius, g_unis.m_pointOfTest, g_unis.m_testRadius))
 	{
 		return;
 	}
@@ -137,14 +137,14 @@ struct DrawIndirectArgsWithPadding
 
 	// Compute the LOD
 	//
-	const F32 distFromLodPoint = length(sphereCenter - g_consts.m_lodReferencePoint) - sphereRadius;
+	const F32 distFromLodPoint = length(sphereCenter - g_unis.m_lodReferencePoint) - sphereRadius;
 
 	U32 lod;
-	if(distFromLodPoint < g_consts.m_maxLodDistances[0])
+	if(distFromLodPoint < g_unis.m_maxLodDistances[0])
 	{
 		lod = 0u;
 	}
-	else if(distFromLodPoint < g_consts.m_maxLodDistances[1])
+	else if(distFromLodPoint < g_unis.m_maxLodDistances[1])
 	{
 		lod = 1u;
 	}
@@ -231,7 +231,7 @@ struct DrawIndirectArgsWithPadding
 
 				UVec4 instanceVertex;
 				instanceVertex.x = renderable.m_worldTransformsIndex;
-				instanceVertex.y = renderable.m_constantsOffset;
+				instanceVertex.y = renderable.m_uniformsOffset;
 				instanceVertex.z = meshLodIndex;
 				instanceVertex.w = renderable.m_boneTransformsOffset;
 				g_instanceRateRenderables[indirectIdx] = instanceVertex;
@@ -249,7 +249,7 @@ struct DrawIndirectArgsWithPadding
 
 				UVec4 instanceVertex;
 				instanceVertex.x = renderable.m_worldTransformsIndex;
-				instanceVertex.y = renderable.m_constantsOffset;
+				instanceVertex.y = renderable.m_uniformsOffset;
 				instanceVertex.z = meshLodIndex;
 				instanceVertex.w = renderable.m_particleEmitterOffset;
 				g_instanceRateRenderables[indirectIdx] = instanceVertex;

AnKi/Shaders/GpuVisibilityAccelerationStructures.ankiprog

@@ -23,7 +23,7 @@
 
 [[vk::binding(7)]] RWStructuredBuffer<DispatchIndirectArgs> g_nextDispatchIndirectArgs;
 
-[[vk::push_constant]] ConstantBuffer<GpuVisibilityAccelerationStructuresConstants> g_consts;
+[[vk::push_constant]] ConstantBuffer<GpuVisibilityAccelerationStructuresUniforms> g_unis;
 
 #define NUMTHREADS 64
 
@@ -44,7 +44,7 @@
 		bvolume = g_renderableBoundingVolumes[bvolumeIdx];
 
 		sphereCenter = (bvolume.m_aabbMin + bvolume.m_aabbMax) * 0.5f;
-		visible = testSphereSphereCollision(sphereCenter, bvolume.m_sphereRadius, g_consts.m_pointOfTest, g_consts.m_testRadius);
+		visible = testSphereSphereCollision(sphereCenter, bvolume.m_sphereRadius, g_unis.m_pointOfTest, g_unis.m_testRadius);
 	}
 
 	// All good, write the instance
@@ -52,16 +52,16 @@
 	{
 		// LOD selection
 		U32 lod;
-		const Bool insideCameraFrustum = frustumTest(g_consts.m_clipPlanes, sphereCenter, bvolume.m_sphereRadius);
+		const Bool insideCameraFrustum = frustumTest(g_unis.m_clipPlanes, sphereCenter, bvolume.m_sphereRadius);
 		if(insideCameraFrustum)
 		{
 			// Visible by the camera, need to match the camera LODs
-			const F32 distFromLodPoint = length(sphereCenter - g_consts.m_pointOfTest) - bvolume.m_sphereRadius;
-			if(distFromLodPoint < g_consts.m_maxLodDistances[0])
+			const F32 distFromLodPoint = length(sphereCenter - g_unis.m_pointOfTest) - bvolume.m_sphereRadius;
+			if(distFromLodPoint < g_unis.m_maxLodDistances[0])
 			{
 				lod = 0u;
 			}
-			else if(distFromLodPoint < g_consts.m_maxLodDistances[1])
+			else if(distFromLodPoint < g_unis.m_maxLodDistances[1])
 			{
 				lod = 1u;
 			}

AnKi/Shaders/GpuVisibilityMeshlet.ankiprog

@@ -46,12 +46,12 @@ struct Consts
 	U32 m_padding2;
 	U32 m_padding3;
 };
-[[vk::push_constant]] ConstantBuffer<Consts> g_consts;
+[[vk::push_constant]] ConstantBuffer<Consts> g_unis;
 
 [numthreads(THREADGROUP_SIZE, 1, 1)] void main(U32 svDispatchThreadId : SV_DISPATCHTHREADID, U32 svGroupId : SV_GROUPID,
 											   U32 svGroupIndex : SV_GROUPINDEX)
 {
-	const GpuSceneMeshletGroupInstance groupInstance = g_meshletGroupInstances[g_consts.m_firstMeshletGroup + svGroupId];
+	const GpuSceneMeshletGroupInstance groupInstance = g_meshletGroupInstances[g_unis.m_firstMeshletGroup + svGroupId];
 
 	const U32 lod = groupInstance.m_lod_2bit_renderableIdx_21bit_meshletGroup_9bit >> 30u;
 	const U32 renderableIdx = (groupInstance.m_lod_2bit_renderableIdx_21bit_meshletGroup_9bit >> 9u) & ((1u << 21u) - 1u);
@@ -77,11 +77,11 @@ struct Consts
 
 #	if MESHLET_BACKFACE_CULLING
 		const Vec4 coneDirAndAng = unpackSnorm4x8(meshletBoundingVol.m_coneDirection_R8G8B8_Snorm_cosHalfAngle_R8_Snorm);
-		cull = cullBackfaceMeshlet(coneDirAndAng.xyz, coneDirAndAng.w, meshletBoundingVol.m_coneApex, worldTransform, g_consts.m_cameraPos);
+		cull = cullBackfaceMeshlet(coneDirAndAng.xyz, coneDirAndAng.w, meshletBoundingVol.m_coneApex, worldTransform, g_unis.m_cameraPos);
 #	endif
 
 		const Mat4 wordTransform4 = {worldTransform.m_row0, worldTransform.m_row1, worldTransform.m_row2, Vec4(0.0f, 0.0f, 0.0f, 1.0f)};
-		const Mat4 mvp = mul(g_consts.m_viewProjectionMatrix, wordTransform4);
+		const Mat4 mvp = mul(g_unis.m_viewProjectionMatrix, wordTransform4);
 
 		Vec2 minNdc, maxNdc;
 		F32 aabbMinDepth;
@@ -94,8 +94,8 @@ struct Consts
 
 #	if MESHLET_NO_SAMPLING_POINT_CULLING
 		// Sampling points test
-		const Vec2 windowCoordsMin = ndcToUv(minNdc) * g_consts.m_viewportSizef;
-		const Vec2 windowCoordsMax = ndcToUv(maxNdc) * g_consts.m_viewportSizef;
+		const Vec2 windowCoordsMin = ndcToUv(minNdc) * g_unis.m_viewportSizef;
+		const Vec2 windowCoordsMax = ndcToUv(maxNdc) * g_unis.m_viewportSizef;
 		cull = cull || any(round(windowCoordsMin) == round(windowCoordsMax));
 #	endif
 
@@ -108,27 +108,27 @@ struct Consts
 		if(!cull)
 		{
 			U32 instanceIdx;
-			InterlockedAdd(g_indirectDrawArgs[g_consts.m_firstDrawArg].m_instanceCount, 1u, instanceIdx);
+			InterlockedAdd(g_indirectDrawArgs[g_unis.m_firstDrawArg].m_instanceCount, 1u, instanceIdx);
 
-			if(instanceIdx >= g_consts.m_maxMeshlets)
+			if(instanceIdx >= g_unis.m_maxMeshlets)
 			{
 				// OoM, ignore
 				U32 orig;
-				InterlockedExchange(g_indirectDrawArgs[g_consts.m_firstDrawArg].m_instanceCount, g_consts.m_maxMeshlets, orig);
+				InterlockedExchange(g_indirectDrawArgs[g_unis.m_firstDrawArg].m_instanceCount, g_unis.m_maxMeshlets, orig);
 			}
 			else
 			{
-				InterlockedMax(g_indirectDrawArgs[g_consts.m_firstDrawArg].m_vertexCount, meshletBoundingVol.m_primitiveCount * 3u);
+				InterlockedMax(g_indirectDrawArgs[g_unis.m_firstDrawArg].m_vertexCount, meshletBoundingVol.m_primitiveCount * 3u);
 
 				GpuSceneMeshletInstance instance;
 				instance.m_meshletGeometryDescriptorIndex = firstMeshletGeometryDescriptor + svGroupIndex;
 				instance.m_worldTransformsIndex_25bit_meshletPrimitiveCount_7bit = renderable.m_worldTransformsIndex << 7u;
 				instance.m_worldTransformsIndex_25bit_meshletPrimitiveCount_7bit |= meshletBoundingVol.m_primitiveCount;
-				instance.m_constantsOffset = renderable.m_constantsOffset;
+				instance.m_uniformsOffset = renderable.m_uniformsOffset;
 				instance.m_boneTransformsOrParticleEmitterOffset =
 					(renderable.m_boneTransformsOffset) ? renderable.m_boneTransformsOffset : renderable.m_particleEmitterOffset;
 
-				g_meshletInstances[g_consts.m_firstMeshlet + instanceIdx] = instance;
+				g_meshletInstances[g_unis.m_firstMeshlet + instanceIdx] = instance;
 			}
 		}
 	}

AnKi/Shaders/GpuVisibilityNonRenderables.ankiprog

@@ -30,7 +30,7 @@ typedef GpuSceneGlobalIlluminationProbe ObjectType;
 #endif
 
 [[vk::binding(0)]] StructuredBuffer<ObjectType> g_objects;
-[[vk::push_constant]] ConstantBuffer<GpuVisibilityNonRenderableConstants> g_consts;
+[[vk::push_constant]] ConstantBuffer<GpuVisibilityNonRenderableUniforms> g_unis;
 [[vk::binding(1)]] RWStructuredBuffer<U32> g_visibleIndices; // 1st element is the count. What follows is indices
 
 constexpr U32 kVisibleObjCounterIdx = 1;
@@ -95,7 +95,7 @@ Vec4 getSphere(GpuSceneGlobalIlluminationProbe l)
 	if(!skip)
 	{
 		const Vec4 sphere = getSphere(g_objects[svDispatchThreadId]);
-		skip = !frustumTest(g_consts.m_clipPlanes, sphere.xyz, sphere.w);
+		skip = !frustumTest(g_unis.m_clipPlanes, sphere.xyz, sphere.w);
 	}
 
 	// Add the object

AnKi/Shaders/HzbGenPyramid.ankiprog

@@ -9,16 +9,16 @@
 #pragma anki technique_start comp
 #include <AnKi/Shaders/Common.hlsl>
 
-struct Constants
+struct Uniforms
 {
 	Vec2 m_invSrcTexSize;
 	U32 m_threadGroupCount;
 	U32 m_mipmapCount;
 };
 
-[[vk::push_constant]] ConstantBuffer<Constants> g_consts;
+[[vk::push_constant]] ConstantBuffer<Uniforms> g_unis;
 
-[[vk::binding(0)]] globallycoherent RWTexture2D<Vec4> g_dstUavs[kMaxMipsSinglePassDownsamplerCanProduce];
+[[vk::binding(0)]] globallycoherent RWTexture2D<Vec4> g_dstStorageTextures[kMaxMipsSinglePassDownsamplerCanProduce];
 [[vk::binding(1)]] globallycoherent RWStructuredBuffer<U32> g_spdCounter;
 [[vk::binding(2)]] Texture2D<Vec4> g_srcTex;
 
@@ -39,7 +39,7 @@ groupshared AF1 s_spdIntermediateR[16][16];
 AF4 SpdLoadSourceImage(AU2 p, AU1 slice)
 {
 	ANKI_MAYBE_UNUSED(slice);
-	const AF2 uv = p * g_consts.m_invSrcTexSize + g_consts.m_invSrcTexSize;
+	const AF2 uv = p * g_unis.m_invSrcTexSize + g_unis.m_invSrcTexSize;
 
 #if MIN_MAX_SAMPLER
 	const F32 f = g_srcTex.SampleLevel(g_minMaxAnyClampSampler, uv, 0.0).r;
@@ -59,13 +59,13 @@ AF4 SpdLoadSourceImage(AU2 p, AU1 slice)
 AF4 SpdLoad(AU2 p, AU1 slice)
 {
 	ANKI_MAYBE_UNUSED(slice);
-	return AF4(g_dstUavs[5][p].r, 0.0, 0.0, 0.0);
+	return AF4(g_dstStorageTextures[5][p].r, 0.0, 0.0, 0.0);
 }
 
 void SpdStore(AU2 p, AF4 value, AU1 mip, AU1 slice)
 {
 	ANKI_MAYBE_UNUSED(slice);
-	g_dstUavs[mip][p] = Vec4(value.x, 0.0, 0.0, 0.0);
+	g_dstStorageTextures[mip][p] = Vec4(value.x, 0.0, 0.0, 0.0);
 }
 
 void SpdIncreaseAtomicCounter(AU1 slice)
@@ -112,7 +112,7 @@ AF4 SpdReduce4(AF4 v0, AF4 v1, AF4 v2, AF4 v3)
 {
 	const U32 slice = 0u;
 	const UVec2 offset = UVec2(0, 0);
-	SpdDownsample(AU2(svGroupId.xy), AU1(svGroupIndex), AU1(g_consts.m_mipmapCount), AU1(g_consts.m_threadGroupCount), slice, offset);
+	SpdDownsample(AU2(svGroupId.xy), AU1(svGroupIndex), AU1(g_unis.m_mipmapCount), AU1(g_unis.m_threadGroupCount), slice, offset);
 }
 
 #pragma anki technique_end comp

AnKi/Shaders/HzbMaxDepth.ankiprog

@@ -9,7 +9,7 @@
 
 [[vk::binding(0)]] Texture2D<Vec4> g_depthRt;
 [[vk::binding(1)]] SamplerState g_linearAnyClampSampler;
-[[vk::binding(2)]] RWTexture2D<Vec4> g_maxDepthUav;
+[[vk::binding(2)]] RWTexture2D<Vec4> g_maxDepthStorageTex;
 
 #define TILE_SIZE 64
 #define THREADGROUP_SIZE_XY 32
@@ -43,7 +43,7 @@ groupshared U32 s_maxDepth;
 
 	if(svGroupIndex == 0)
 	{
-		g_maxDepthUav[svGroupId] = asfloat(s_maxDepth);
+		g_maxDepthStorageTex[svGroupId] = asfloat(s_maxDepth);
 	}
 }
 

AnKi/Shaders/HzbMaxDepthProject.ankiprog

@@ -11,7 +11,7 @@
 
 [[vk::binding(0)]] Texture2D<Vec4> g_maxDepthRt;
 
-struct Constants
+struct Uniforms
 {
 	Mat4 m_reprojectionMat;
 
@@ -21,7 +21,7 @@ struct Constants
 	F32 m_padding1;
 };
 
-[[vk::push_constant]] ConstantBuffer<Constants> g_consts;
+[[vk::push_constant]] ConstantBuffer<Uniforms> g_unis;
 
 Vec4 main(U32 svVertexId : SV_VERTEXID, U32 svInstanceId : SV_INSTANCEID) : SV_POSITION
 {
@@ -31,8 +31,8 @@ Vec4 main(U32 svVertexId : SV_VERTEXID, U32 svInstanceId : SV_INSTANCEID) : SV_P
 	const U32 tileX = svInstanceId % maxDepthRtSize.x;
 	const U32 tileY = svInstanceId / maxDepthRtSize.x;
 
-	const F32 maxDepth = min(g_maxDepthRt[UVec2(tileX, tileY)].x, g_consts.m_cascadeMaxDepth);
-	const F32 minDepth = g_consts.m_cascadeMinDepth;
+	const F32 maxDepth = min(g_maxDepthRt[UVec2(tileX, tileY)].x, g_unis.m_cascadeMaxDepth);
+	const F32 minDepth = g_unis.m_cascadeMinDepth;
 
 	if(maxDepth <= minDepth)
 	{
@@ -64,7 +64,7 @@ Vec4 main(U32 svVertexId : SV_VERTEXID, U32 svInstanceId : SV_INSTANCEID) : SV_P
 	ndc.xy = uvToNdc(saturate(ndc.xy));
 
 	// Unproject and project
-	return mul(g_consts.m_reprojectionMat, Vec4(ndc, 1.0));
+	return mul(g_unis.m_reprojectionMat, Vec4(ndc, 1.0));
 }
 
 #pragma anki technique_end vert

AnKi/Shaders/Include/GpuSceneFunctions.h

@@ -13,7 +13,7 @@ inline GpuSceneRenderableInstance unpackGpuSceneRenderableVertex(UVec4 x)
 {
 	GpuSceneRenderableInstance o;
 	o.m_worldTransformsIndex = x[0];
-	o.m_constantsOffset = x[1];
+	o.m_uniformsOffset = x[1];
 	o.m_meshLodIndex = x[2];
 	o.m_boneTransformsOrParticleEmitterOffset = x[3];
 	return o;
@@ -23,7 +23,7 @@ inline GpuSceneMeshletInstance unpackGpuSceneMeshletInstance(UVec4 x)
 {
 	GpuSceneMeshletInstance o;
 	o.m_worldTransformsIndex_25bit_meshletPrimitiveCount_7bit = x[0];
-	o.m_constantsOffset = x[1];
+	o.m_uniformsOffset = x[1];
 	o.m_meshletGeometryDescriptorIndex = x[2];
 	o.m_boneTransformsOrParticleEmitterOffset = x[3];
 	return o;

AnKi/Shaders/Include/GpuSceneTypes.h

@@ -20,7 +20,7 @@ constexpr F32 kSomeFarDistance = 100000.0f;
 struct GpuSceneRenderable
 {
 	U32 m_worldTransformsIndex; ///< First index points to the crnt transform and the 2nd to the previous.
-	U32 m_constantsOffset;
+	U32 m_uniformsOffset;
 	U32 m_meshLodsIndex; ///< Points to the array of GpuSceneMeshLod. kMaxLodCount are reserved for each renderable.
 	U32 m_boneTransformsOffset; ///< Array of Mat3x4 or 0 if its not a skin.
 	U32 m_particleEmitterOffset; ///< Offset to GpuSceneParticleEmitter or 0 if it's not an emitter.
@@ -32,7 +32,7 @@ struct GpuSceneRenderable
 struct GpuSceneRenderableInstance
 {
 	U32 m_worldTransformsIndex;
-	U32 m_constantsOffset;
+	U32 m_uniformsOffset;
 	U32 m_meshLodIndex; ///< Points to a single GpuSceneMeshLod in the mesh lods.
 	U32 m_boneTransformsOrParticleEmitterOffset;
 };
@@ -49,7 +49,7 @@ static_assert(kMaxLodCount == 3);
 struct GpuSceneMeshletInstance
 {
 	U32 m_worldTransformsIndex_25bit_meshletPrimitiveCount_7bit;
-	U32 m_constantsOffset;
+	U32 m_uniformsOffset;
 	U32 m_meshletGeometryDescriptorIndex; ///< Index in the UGB.
 	U32 m_boneTransformsOrParticleEmitterOffset;
 };

AnKi/Shaders/Include/GpuVisibilityTypes.h

@@ -9,7 +9,7 @@
 
 ANKI_BEGIN_NAMESPACE
 
-struct FrustumGpuVisibilityConstants
+struct FrustumGpuVisibilityUniforms
 {
 	Vec4 m_clipPlanes[6u];
 
@@ -23,7 +23,7 @@ struct FrustumGpuVisibilityConstants
 	Vec2 m_finalRenderTargetSize;
 };
 
-struct DistanceGpuVisibilityConstants
+struct DistanceGpuVisibilityUniforms
 {
 	Vec3 m_pointOfTest;
 	F32 m_testRadius;
@@ -34,12 +34,12 @@ struct DistanceGpuVisibilityConstants
 	F32 m_padding3;
 };
 
-struct GpuVisibilityNonRenderableConstants
+struct GpuVisibilityNonRenderableUniforms
 {
 	Vec4 m_clipPlanes[6u];
 };
 
-struct GpuVisibilityAccelerationStructuresConstants
+struct GpuVisibilityAccelerationStructuresUniforms
 {
 	Vec4 m_clipPlanes[6u];
 

AnKi/Shaders/Include/MaterialTypes.h

@@ -10,7 +10,7 @@
 ANKI_BEGIN_NAMESPACE
 
 /// Common data for all materials.
-struct MaterialGlobalConstants
+struct MaterialGlobalUniforms
 {
 	Mat4 m_viewProjectionMatrix;
 	Mat4 m_previousViewProjectionMatrix;
@@ -24,7 +24,7 @@ struct MaterialGlobalConstants
 	U32 m_padding1;
 	U32 m_padding2;
 };
-static_assert(sizeof(MaterialGlobalConstants) == 16 * sizeof(Vec4));
+static_assert(sizeof(MaterialGlobalUniforms) == 16 * sizeof(Vec4));
 
 /// @brief
 enum class MaterialSet : U32
@@ -37,7 +37,7 @@ enum class MaterialSet : U32
 enum class MaterialBinding : U32
 {
 	kTrilinearRepeatSampler,
-	kGlobalConstants,
+	kGlobalUniforms,
 	kGpuScene,
 
 	// Texture buffer bindings pointing to unified geom buffer:
@@ -58,7 +58,7 @@ enum class MaterialBinding : U32
 	kShadowSampler,
 	kDepthRt,
 	kLightVolume,
-	kClusterShadingConstants,
+	kClusterShadingUniforms,
 	kClusterShadingLights,
 	kClusters = kClusterShadingLights + 2,
 };

AnKi/Shaders/Include/MiscRendererTypes.h

@@ -59,7 +59,7 @@ struct CommonMatrices
 };
 
 /// Common constants for all passes.
-struct GlobalRendererConstants
+struct GlobalRendererUniforms
 {
 	Vec2 m_renderingSize;
 	F32 m_time;
@@ -89,7 +89,7 @@ struct GlobalRendererConstants
 };
 
 // RT shadows
-struct RtShadowsDenoiseConstants
+struct RtShadowsDenoiseUniforms
 {
 	Mat4 m_invViewProjMat;
 
@@ -99,7 +99,7 @@ struct RtShadowsDenoiseConstants
 	F32 m_padding2;
 };
 
-struct RtShadowsSbtBuildConstants
+struct RtShadowsSbtBuildUniforms
 {
 	U32 m_shaderHandleDwordSize;
 	U32 m_sbtRecordDwordSize;
@@ -116,7 +116,7 @@ struct LensFlareSprite
 };
 
 // Depth downscale
-struct DepthDownscaleConstants
+struct DepthDownscaleUniforms
 {
 	Vec2 m_srcTexSizeOverOne;
 	U32 m_threadgroupCount;
@@ -124,7 +124,7 @@ struct DepthDownscaleConstants
 };
 
 // Screen space reflections uniforms
-struct SsrConstants
+struct SsrUniforms
 {
 	Vec2 m_viewportSizef;
 	U32 m_frameCount;
@@ -143,7 +143,7 @@ struct SsrConstants
 };
 
 // Vol fog
-struct VolumetricFogConstants
+struct VolumetricFogUniforms
 {
 	RVec3 m_fogDiffuse;
 	RF32 m_fogScatteringCoeff;
@@ -158,7 +158,7 @@ struct VolumetricFogConstants
 };
 
 // Vol lighting
-struct VolumetricLightingConstants
+struct VolumetricLightingUniforms
 {
 	RF32 m_densityAtMinHeight;
 	RF32 m_densityAtMaxHeight;
@@ -170,7 +170,7 @@ struct VolumetricLightingConstants
 };
 
 // SSAO
-struct SsaoConstants
+struct SsaoUniforms
 {
 	RF32 m_radius; ///< In meters.
 	U32 m_sampleCount;
@@ -190,7 +190,7 @@ struct SsaoConstants
 	Mat3x4 m_viewMat;
 };
 
-struct SsaoSpatialDenoiseConstants
+struct SsaoSpatialDenoiseUniforms
 {
 	Mat3x4 m_viewToWorldMat;
 

AnKi/Shaders/Include/TraditionalDeferredShadingTypes.h

@@ -17,7 +17,7 @@ struct TraditionalDeferredShadingDirectionalLight
 	Mat4 m_lightMatrix;
 };
 
-struct TraditionalDeferredShadingConstants
+struct TraditionalDeferredShadingUniforms
 {
 	// Use these to get the correct face UVs
 	Vec2 m_inputTexUvScale;
@@ -31,7 +31,7 @@ struct TraditionalDeferredShadingConstants
 	TraditionalDeferredShadingDirectionalLight m_dirLight;
 };
 
-struct TraditionalDeferredSkyboxConstants
+struct TraditionalDeferredSkyboxUniforms
 {
 	RVec3 m_solidColor;
 	F32 m_padding1;

AnKi/Shaders/IrradianceDice.ankiprog

@@ -29,13 +29,13 @@ constexpr U32 kThreadgroupSize = U32(THREDGROUP_SIZE_SQRT) * U32(THREDGROUP_SIZE
 #if STORE_LOCATION == 0
 [[vk::binding(3)]] RWTexture3D<Vec4> g_irradianceVolume;
 
-struct Constants
+struct Uniforms
 {
 	IVec3 m_volumeTexel;
 	I32 m_nextTexelOffsetInU;
 };
 
-[[vk::push_constant]] ConstantBuffer<Constants> g_consts;
+[[vk::push_constant]] ConstantBuffer<Uniforms> g_unis;
 #else
 struct BufferOut
 {
@@ -197,14 +197,13 @@ RVec3 sampleLightShadingTexture(const U32 face, UVec3 svGroupThreadId)
 
 		const UVec3 subvolumeSize = UVec3(volumeSize.x / 6u, volumeSize.y, volumeSize.z);
 		const U32 cellIdx =
-			g_consts.m_volumeTexel.z * subvolumeSize.x * subvolumeSize.y + g_consts.m_volumeTexel.y * subvolumeSize.x + g_consts.m_volumeTexel.x;
+			g_unis.m_volumeTexel.z * subvolumeSize.x * subvolumeSize.y + g_unis.m_volumeTexel.y * subvolumeSize.x + g_unis.m_volumeTexel.x;
 		const RF32 headmapFactor = F32(cellIdx) / F32(subvolumeSize.x * subvolumeSize.y * subvolumeSize.z);
 		const RVec3 toStoreValue = heatmap(headmapFactor);
 #endif
 
 #if STORE_LOCATION == 0
-		const UVec3 storeUvw =
-			UVec3(g_consts.m_volumeTexel.x + I32(f) * g_consts.m_nextTexelOffsetInU, g_consts.m_volumeTexel.y, g_consts.m_volumeTexel.z);
+		const UVec3 storeUvw = UVec3(g_unis.m_volumeTexel.x + I32(f) * g_unis.m_nextTexelOffsetInU, g_unis.m_volumeTexel.y, g_unis.m_volumeTexel.z);
 		g_irradianceVolume[storeUvw] = Vec4(toStoreValue, 0.0);
 #else
 		g_irradianceDisceResults[0].m_val[f] = toStoreValue.xyzx;

AnKi/Shaders/LightShading.ankiprog

@@ -13,7 +13,7 @@
 #include <AnKi/Shaders/RtShadows.hlsl>
 #include <AnKi/Shaders/ClusteredShadingFunctions.hlsl>
 
-[[vk::binding(0)]] ConstantBuffer<GlobalRendererConstants> g_globalConsts;
+[[vk::binding(0)]] ConstantBuffer<GlobalRendererUniforms> g_globalUniforms;
 [[vk::binding(1)]] StructuredBuffer<PointLight> g_pointLights;
 [[vk::binding(1)]] StructuredBuffer<SpotLight> g_spotLights;
 [[vk::binding(2)]] StructuredBuffer<GlobalIlluminationProbe> g_giProbes;
@@ -55,13 +55,13 @@ RVec3 main(Vec4 svPosition : SV_POSITION, Vec2 uv : TEXCOORD) : SV_TARGET0
 	}
 
 	// Get world position
-	const Vec4 worldPos4 = mul(g_globalConsts.m_matrices.m_invertedViewProjectionJitter, Vec4(ndc, depth, 1.0));
+	const Vec4 worldPos4 = mul(g_globalUniforms.m_matrices.m_invertedViewProjectionJitter, Vec4(ndc, depth, 1.0));
 	const Vec3 worldPos = worldPos4.xyz / worldPos4.w;
 
-	const RVec3 viewDir = normalize(g_globalConsts.m_cameraPosition - worldPos);
+	const RVec3 viewDir = normalize(g_globalUniforms.m_cameraPosition - worldPos);
 
 	// Get the cluster
-	Cluster cluster = getClusterFragCoord(g_clusters, g_globalConsts, Vec3(svPosition.xy, depth));
+	Cluster cluster = getClusterFragCoord(g_clusters, g_globalUniforms, Vec3(svPosition.xy, depth));
 
 	// return clusterHeatmap(cluster, 1u << (U32)GpuSceneNonRenderableObjectType::kLight, 3);
 
@@ -134,7 +134,7 @@ RVec3 main(Vec4 svPosition : SV_POSITION, Vec2 uv : TEXCOORD) : SV_TARGET0
 		[branch] if(ssr.w < 0.9f)
 		{
 			const Vec3 reflDir = reflect(-viewDir, gbuffer.m_normal);
-			const RF32 reflLod = (g_globalConsts.m_reflectionProbesMipCount - 1.0f) * gbuffer.m_roughness;
+			const RF32 reflLod = (g_globalUniforms.m_reflectionProbesMipCount - 1.0f) * gbuffer.m_roughness;
 			RVec3 probeColor = 0.0f;
 
 			const U32 oneProbe = WaveActiveAllTrue(countbits(cluster.m_reflectionProbesMask) == 1);
@@ -193,7 +193,7 @@ RVec3 main(Vec4 svPosition : SV_POSITION, Vec2 uv : TEXCOORD) : SV_TARGET0
 	U32 resolvedSmIdx = 0u;
 
 	// Dir light
-	const DirectionalLight dirLight = g_globalConsts.m_directionalLight;
+	const DirectionalLight dirLight = g_globalUniforms.m_directionalLight;
 	if(dirLight.m_shadowCascadeCount_31bit_active_1bit & 1u)
 	{
 		RF32 shadowFactor;

AnKi/Shaders/LightShadingApplyFog.ankiprog

@@ -16,7 +16,7 @@
 [[vk::binding(2)]] Texture2D g_depthRt;
 [[vk::binding(3)]] Texture3D<RVec4> g_fogVolume;
 
-struct Constants
+struct Uniforms
 {
 	F32 m_zSplitCount;
 	F32 m_finalZSplit;
@@ -24,7 +24,7 @@ struct Constants
 	F32 m_far;
 };
 
-[[vk::push_constant]] ConstantBuffer<Constants> g_consts;
+[[vk::push_constant]] ConstantBuffer<Uniforms> g_unis;
 
 RVec4 main([[vk::location(0)]] Vec2 uv : TEXCOORD) : SV_TARGET0
 {
@@ -32,8 +32,8 @@ RVec4 main([[vk::location(0)]] Vec2 uv : TEXCOORD) : SV_TARGET0
 
 	// Compute W coordinate
 	const F32 depth = g_depthRt.SampleLevel(g_nearestAnyClampSampler, uv, 0.0).r;
-	const F32 linearDepth = linearizeDepth(depth, g_consts.m_near, g_consts.m_far);
-	uvw.z = linearDepth * (g_consts.m_zSplitCount / (g_consts.m_finalZSplit + 1.0f));
+	const F32 linearDepth = linearizeDepth(depth, g_unis.m_near, g_unis.m_far);
+	uvw.z = linearDepth * (g_unis.m_zSplitCount / (g_unis.m_finalZSplit + 1.0f));
 
 	// Compute UV coordinates
 	uvw.xy = uv;

AnKi/Shaders/LightShadingSkybox.ankiprog

@@ -35,18 +35,18 @@ VertOut main(U32 vertId : SV_VERTEXID)
 #include <AnKi/Shaders/Sky.hlsl>
 
 #if METHOD == 0
-struct Constants
+struct Uniforms
 {
 	RVec3 m_solidColor;
 	F32 m_padding;
 };
 
-[[vk::push_constant]] ConstantBuffer<Constants> g_consts;
+[[vk::push_constant]] ConstantBuffer<Uniforms> g_unis;
 #elif METHOD == 1
 [[vk::binding(0)]] SamplerState g_trilinearAnySampler;
 [[vk::binding(1)]] Texture2D<RVec4> g_envMapTex;
 
-struct Constants
+struct Uniforms
 {
 	Mat4 m_invertedViewProjectionJitterMat;
 
@@ -60,25 +60,25 @@ struct Constants
 	F32 m_padding2;
 };
 
-[[vk::push_constant]] ConstantBuffer<Constants> g_consts;
+[[vk::push_constant]] ConstantBuffer<Uniforms> g_unis;
 #else
 [[vk::binding(0)]] SamplerState g_linearAnyClampSampler;
 [[vk::binding(1)]] Texture2D<Vec4> g_skyLut;
-[[vk::binding(2)]] ConstantBuffer<GlobalRendererConstants> g_consts;
+[[vk::binding(2)]] ConstantBuffer<GlobalRendererUniforms> g_unis;
 #endif
 
 RVec3 main([[vk::location(0)]] Vec2 uv : TEXCOORD) : SV_TARGET0
 {
 #if METHOD == 0
 	ANKI_MAYBE_UNUSED(uv);
-	return g_consts.m_solidColor;
+	return g_unis.m_solidColor;
 #elif METHOD == 1
 	const F32 depth = 1.0;
 	const Vec2 ndc = uvToNdc(uv);
-	const Vec4 worldPos4 = mul(g_consts.m_invertedViewProjectionJitterMat, Vec4(ndc, depth, 1.0));
+	const Vec4 worldPos4 = mul(g_unis.m_invertedViewProjectionJitterMat, Vec4(ndc, depth, 1.0));
 	const Vec3 worldPos = worldPos4.xyz / worldPos4.w;
 
-	const Vec3 eyeToFrag = normalize(worldPos - g_consts.m_cameraPos);
+	const Vec3 eyeToFrag = normalize(worldPos - g_unis.m_cameraPos);
 
 	const Vec2 uv3 = equirectangularMapping(eyeToFrag);
 
@@ -90,17 +90,17 @@ RVec3 main([[vk::location(0)]] Vec2 uv : TEXCOORD) : SV_TARGET0
 
 	const F32 bias = (maxD > 0.9) ? -100.0f : 0.0f;
 
-	return g_envMapTex.SampleBias(g_trilinearAnySampler, uv3, bias).rgb * g_consts.m_scale + g_consts.m_bias;
+	return g_envMapTex.SampleBias(g_trilinearAnySampler, uv3, bias).rgb * g_unis.m_scale + g_unis.m_bias;
 #else
 	const F32 depth = 1.0;
 	const Vec2 ndc = uvToNdc(uv);
-	const Vec4 worldPos4 = mul(g_consts.m_matrices.m_invertedViewProjectionJitter, Vec4(ndc, depth, 1.0));
+	const Vec4 worldPos4 = mul(g_unis.m_matrices.m_invertedViewProjectionJitter, Vec4(ndc, depth, 1.0));
 	const Vec3 worldPos = worldPos4.xyz / worldPos4.w;
 
-	const Vec3 eyeToFrag = normalize(worldPos - g_consts.m_cameraPosition);
+	const Vec3 eyeToFrag = normalize(worldPos - g_unis.m_cameraPosition);
 
-	return computeSkyColor(g_skyLut, g_linearAnyClampSampler, eyeToFrag, -g_consts.m_directionalLight.m_direction,
-						   g_consts.m_directionalLight.m_power, true);
+	return computeSkyColor(g_skyLut, g_linearAnyClampSampler, eyeToFrag, -g_unis.m_directionalLight.m_direction, g_unis.m_directionalLight.m_power,
+						   true);
 #endif
 }
 

AnKi/Shaders/MaterialShadersCommon.hlsl

@@ -16,7 +16,7 @@
 ANKI_BINDLESS_SET(MaterialSet::kBindless)
 
 [[vk::binding(MaterialBinding::kTrilinearRepeatSampler, MaterialSet::kGlobal)]] SamplerState g_globalSampler;
-[[vk::binding(MaterialBinding::kGlobalConstants, MaterialSet::kGlobal)]] ConstantBuffer<MaterialGlobalConstants> g_globalConstants;
+[[vk::binding(MaterialBinding::kGlobalUniforms, MaterialSet::kGlobal)]] ConstantBuffer<MaterialGlobalUniforms> g_globalUniforms;
 [[vk::binding(MaterialBinding::kGpuScene, MaterialSet::kGlobal)]] ByteAddressBuffer g_gpuScene;
 
 // Unified geom:
@@ -43,7 +43,7 @@ ANKI_BINDLESS_SET(MaterialSet::kBindless)
 [[vk::binding(MaterialBinding::kLightVolume, MaterialSet::kGlobal)]] Texture3D<RVec4> g_lightVol;
 [[vk::binding(MaterialBinding::kShadowSampler, MaterialSet::kGlobal)]] SamplerComparisonState g_shadowSampler;
 
-[[vk::binding(MaterialBinding::kClusterShadingConstants, MaterialSet::kGlobal)]] ConstantBuffer<GlobalRendererConstants> g_globalRendererConstants;
+[[vk::binding(MaterialBinding::kClusterShadingUniforms, MaterialSet::kGlobal)]] ConstantBuffer<GlobalRendererUniforms> g_globalRendererUniforms;
 [[vk::binding(MaterialBinding::kClusters, MaterialSet::kGlobal)]] StructuredBuffer<Cluster> g_clusters;
 [[vk::binding(MaterialBinding::kClusterShadingLights, MaterialSet::kGlobal)]] StructuredBuffer<PointLight> g_pointLights;
 [[vk::binding(MaterialBinding::kClusterShadingLights, MaterialSet::kGlobal)]] StructuredBuffer<SpotLight> g_spotLights;

AnKi/Shaders/MotionVectors.ankiprog

@@ -14,17 +14,17 @@ constexpr F32 kMaxRejectionDistance = 0.1; // In meters
 [[vk::binding(1)]] Texture2D g_currentDepthTex;
 [[vk::binding(2)]] Texture2D g_velocityTex;
 
-struct Constants
+struct Uniforms
 {
 	Mat4 m_currentViewProjMat;
 	Mat4 m_currentInvViewProjMat;
 	Mat4 m_prevViewProjMat;
 };
 
-[[vk::binding(3)]] ConstantBuffer<Constants> g_consts;
+[[vk::binding(3)]] ConstantBuffer<Uniforms> g_unis;
 
 #	if ANKI_COMPUTE_SHADER
-[[vk::binding(4)]] RWTexture2D<Vec2> g_motionVectorsUav;
+[[vk::binding(4)]] RWTexture2D<Vec2> g_motionVectorsStorageTex;
 #	endif
 
 #	if ANKI_COMPUTE_SHADER
@@ -39,9 +39,9 @@ FragOut main(Vec2 uv : TEXCOORD)
 #	endif
 {
 #	if ANKI_COMPUTE_SHADER
-	Vec2 uavSize;
-	g_motionVectorsUav.GetDimensions(uavSize.x, uavSize.y);
-	const Vec2 uv = (Vec2(svDispatchThreadId) + 0.5f) / uavSize;
+	Vec2 texSize;
+	g_motionVectorsStorageTex.GetDimensions(texSize.x, texSize.y);
+	const Vec2 uv = (Vec2(svDispatchThreadId) + 0.5f) / texSize;
 #	endif
 
 	const Vec2 velocity = g_velocityTex.SampleLevel(g_nearesetAnyClampSampler, uv, 0.0).rg;
@@ -56,13 +56,13 @@ FragOut main(Vec2 uv : TEXCOORD)
 		// Don't use a reprojection matrix or other kind of optimizations. Due to numerical precision it produces slightly off result. Big enough to
 		// create slight visual issues. Do it the hard way.
 		const F32 depth = g_currentDepthTex.SampleLevel(g_nearesetAnyClampSampler, uv, 0.0).r;
-		const Vec4 v4 = mul(g_consts.m_currentInvViewProjMat, Vec4(uvToNdc(uv), depth, 1.0));
+		const Vec4 v4 = mul(g_unis.m_currentInvViewProjMat, Vec4(uvToNdc(uv), depth, 1.0));
 		const Vec3 worldPos = v4.xyz / v4.w;
 
-		Vec4 clipPos = mul(g_consts.m_currentViewProjMat, Vec4(worldPos, 1.0));
+		Vec4 clipPos = mul(g_unis.m_currentViewProjMat, Vec4(worldPos, 1.0));
 		clipPos.xy /= clipPos.w;
 
-		Vec4 prevClipPos = mul(g_consts.m_prevViewProjMat, Vec4(worldPos, 1.0));
+		Vec4 prevClipPos = mul(g_unis.m_prevViewProjMat, Vec4(worldPos, 1.0));
 		prevClipPos.xy /= prevClipPos.w;
 
 		const Vec2 diff = (prevClipPos.xy - clipPos.xy) * 0.5f; // aka uvToNdc(prevClipPos.xy) - uvToNdc(clipPos.xy)
@@ -71,7 +71,7 @@ FragOut main(Vec2 uv : TEXCOORD)
 
 	// Write out
 #	if ANKI_COMPUTE_SHADER
-	g_motionVectorsUav[svDispatchThreadId] = historyUv - uv;
+	g_motionVectorsStorageTex[svDispatchThreadId] = historyUv - uv;
 #	else
 	FragOut output;
 	output.m_motionVectors = historyUv - uv;

AnKi/Shaders/RtShadows.ankiprog

@@ -15,7 +15,7 @@
 
 #define SET 2u
 
-[[vk::binding(0, SET)]] ConstantBuffer<GlobalRendererConstants> g_globalConsts;
+[[vk::binding(0, SET)]] ConstantBuffer<GlobalRendererUniforms> g_globalRendererUniforms;
 [[vk::binding(1, SET)]] StructuredBuffer<Cluster> g_clusters; // TODO: rm
 
 [[vk::binding(2, SET)]] SamplerState g_trilinearRepeatSampler;
@@ -54,7 +54,7 @@ F32 trace(const Vec3 rayOrigin, const Vec3 rayDir, F32 tMax)
 
 Vec3 genRandomDirection(U32 rayIdx, Vec2 uv)
 {
-	const U32 frameIdx = g_globalConsts.m_frame * RAYS_PER_PIXEL + rayIdx;
+	const U32 frameIdx = g_globalRendererUniforms.m_frame * RAYS_PER_PIXEL + rayIdx;
 
 	Vec2 noiseTexSize;
 	g_blueNoiseTex.GetDimensions(noiseTexSize.x, noiseTexSize.y);
@@ -72,7 +72,7 @@ Vec3 genRandomDirection(U32 rayIdx, Vec2 uv)
 	const Vec2 uv = (Vec2(DispatchRaysIndex().xy) + 0.5) / Vec2(DispatchRaysDimensions().xy);
 	const Vec2 ndc = uvToNdc(uv);
 	const F32 depth = g_depthRt.SampleLevel(g_linearAnyClampSampler, uv, 0.0).r;
-	const Vec4 worldPos4 = mul(g_globalConsts.m_matrices.m_invertedViewProjectionJitter, Vec4(ndc, depth, 1.0));
+	const Vec4 worldPos4 = mul(g_globalRendererUniforms.m_matrices.m_invertedViewProjectionJitter, Vec4(ndc, depth, 1.0));
 	const Vec3 worldPos = worldPos4.xyz / worldPos4.w;
 
 	if(depth == 1.0)
@@ -87,7 +87,7 @@ Vec3 genRandomDirection(U32 rayIdx, Vec2 uv)
 
 	// Dir light
 	F32 shadowFactor = 0.0f;
-	const DirectionalLight dirLight = g_globalConsts.m_directionalLight;
+	const DirectionalLight dirLight = g_globalRendererUniforms.m_directionalLight;
 	for(U32 i = 0; i < RAYS_PER_PIXEL; ++i)
 	{
 		const Vec3 dirLightPos = worldPos + -dirLight.m_direction * 10.0 + genRandomDirection(i, uv);

AnKi/Shaders/RtShadowsDenoise.ankiprog

@@ -18,13 +18,13 @@
 [[vk::binding(3)]] Texture2D<Vec4> g_gbuffer2Tex;
 [[vk::binding(4)]] Texture2D<Vec4> g_momentsTex;
 [[vk::binding(5)]] Texture2D<Vec4> g_historyLengthTex;
-[[vk::binding(6)]] RWTexture2D<Vec4> g_outUav;
+[[vk::binding(6)]] RWTexture2D<Vec4> g_storageTex;
 
-[[vk::push_constant]] ConstantBuffer<RtShadowsDenoiseConstants> g_consts;
+[[vk::push_constant]] ConstantBuffer<RtShadowsDenoiseUniforms> g_unis;
 
 Vec3 unproject(Vec2 ndc, F32 depth)
 {
-	const Vec4 worldPos4 = mul(g_consts.m_invViewProjMat, Vec4(ndc, depth, 1.0));
+	const Vec4 worldPos4 = mul(g_unis.m_invViewProjMat, Vec4(ndc, depth, 1.0));
 	const Vec3 worldPos = worldPos4.xyz / worldPos4.w;
 	return worldPos;
 }
@@ -55,7 +55,7 @@ F32 computeVarianceCenter(Vec2 uv)
 [numthreads(8, 8, 1)] void main(UVec3 svDispatchThreadId : SV_DISPATCHTHREADID)
 {
 	Vec2 outImageSize;
-	g_outUav.GetDimensions(outImageSize.x, outImageSize.y);
+	g_storageTex.GetDimensions(outImageSize.x, outImageSize.y);
 	if(any(svDispatchThreadId.xy >= UVec2(outImageSize)))
 	{
 		return;
@@ -67,7 +67,7 @@ F32 computeVarianceCenter(Vec2 uv)
 	const F32 depthCenter = g_depthTex.SampleLevel(g_linearAnyClampSampler, uv, 0.0).r;
 	if(depthCenter == 1.0)
 	{
-		g_outUav[svDispatchThreadId.xy] = 0.0;
+		g_storageTex[svDispatchThreadId.xy] = 0.0;
 		return;
 	}
 
@@ -82,12 +82,12 @@ F32 computeVarianceCenter(Vec2 uv)
 	if(historyLength < 2.0)
 	{
 		// Worst case
-		sampleCount = g_consts.m_maxSampleCount;
+		sampleCount = g_unis.m_maxSampleCount;
 	}
 	else if(historyLength > 4.0 && varianceCenter < 0.0001)
 	{
 		// Best case
-		sampleCount = g_consts.m_minSampleCount;
+		sampleCount = g_unis.m_minSampleCount;
 	}
 	else
 	{
@@ -96,7 +96,7 @@ F32 computeVarianceCenter(Vec2 uv)
 		F32 blur = varianceCenter * 100.0;
 		blur = min(1.0, blur);
 
-		const F32 sampleCountf = lerp(F32(g_consts.m_minSampleCount), F32(g_consts.m_maxSampleCount), blur);
+		const F32 sampleCountf = lerp(F32(g_unis.m_minSampleCount), F32(g_unis.m_maxSampleCount), blur);
 
 		sampleCount = U32(sampleCountf);
 	}
@@ -133,7 +133,7 @@ F32 computeVarianceCenter(Vec2 uv)
 
 	// Normalize and write
 	shadowFactor /= weight;
-	g_outUav[svDispatchThreadId.xy] = shadowFactor;
+	g_storageTex[svDispatchThreadId.xy] = shadowFactor;
 }
 
 #pragma anki technique_end comp

AnKi/Shaders/RtShadowsHit.ankiprog

@@ -9,7 +9,7 @@
 #include <AnKi/Shaders/RtShadows.hlsl>
 #include <AnKi/Shaders/MaterialShadersCommon.hlsl>
 
-#pragma anki struct AnKiLocalConstants
+#pragma anki struct AnKiLocalUniforms
 #pragma anki member U32 m_diffTex
 #pragma anki struct_end
 
@@ -41,8 +41,8 @@
 
 	const Vec2 uv = vert0.m_uv * bary.x + vert1.m_uv * bary.y + vert2.m_uv * bary.z;
 
-	const AnKiLocalConstants localConstants = loadAnKiLocalConstants(g_gpuScene, g_gpuSceneRenderable.m_constantsOffset);
-	const RVec4 diffColorA = g_bindlessTextures2dF32[localConstants.m_diffTex].SampleLevel(g_globalSampler, uv, 0.0);
+	const AnKiLocalUniforms localUniforms = loadAnKiLocalUniforms(g_gpuScene, g_gpuSceneRenderable.m_uniformsOffset);
+	const RVec4 diffColorA = g_bindlessTextures2dF32[localUniforms.m_diffTex].SampleLevel(g_globalSampler, uv, 0.0);
 
 	if(diffColorA.a < 1.0)
 	{

AnKi/Shaders/RtShadowsSbtBuild.ankiprog

@@ -17,7 +17,7 @@
 
 [[vk::binding(4)]] RWStructuredBuffer<U32> g_sbtBuffer;
 
-[[vk::push_constant]] ConstantBuffer<RtShadowsSbtBuildConstants> g_consts;
+[[vk::push_constant]] ConstantBuffer<RtShadowsSbtBuildUniforms> g_unis;
 
 #define NUMTHREADS 64
 
@@ -31,19 +31,19 @@
 
 	const GpuSceneRenderable renderable = g_renderables[g_visibleRenderableIndices[svDispatchThreadId + 1]];
 
-	U32 sbtDwordOffset = g_consts.m_sbtRecordDwordSize * 2; // Skip raygen and miss shaders which are first
-	sbtDwordOffset += g_consts.m_sbtRecordDwordSize * svDispatchThreadId;
+	U32 sbtDwordOffset = g_unis.m_sbtRecordDwordSize * 2; // Skip raygen and miss shaders which are first
+	sbtDwordOffset += g_unis.m_sbtRecordDwordSize * svDispatchThreadId;
 
 	// Copy the handle
-	for(U32 i = 0; i < g_consts.m_shaderHandleDwordSize; ++i)
+	for(U32 i = 0; i < g_unis.m_shaderHandleDwordSize; ++i)
 	{
-		g_sbtBuffer[sbtDwordOffset] = g_shaderHandles[renderable.m_rtShadowsShaderHandleIndex * g_consts.m_shaderHandleDwordSize + i];
+		g_sbtBuffer[sbtDwordOffset] = g_shaderHandles[renderable.m_rtShadowsShaderHandleIndex * g_unis.m_shaderHandleDwordSize + i];
 		++sbtDwordOffset;
 	}
 
 	// Copy the GpuSceneRenderableInstance
 	g_sbtBuffer[sbtDwordOffset++] = renderable.m_worldTransformsIndex;
-	g_sbtBuffer[sbtDwordOffset++] = renderable.m_constantsOffset;
+	g_sbtBuffer[sbtDwordOffset++] = renderable.m_uniformsOffset;
 	g_sbtBuffer[sbtDwordOffset++] = renderable.m_meshLodsIndex;
 	g_sbtBuffer[sbtDwordOffset] = 0;
 }