Some re-naming

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::kAllStorage;
+	const BufferUsageBit buffUsage = BufferUsageBit::kAllUav;
 	const BufferMapAccessBit mapAccess = BufferMapAccessBit::kRead;
 
 	m_pool.init(buffUsage, classes, classes.getBack(), "GpuReadback", false, mapAccess);
 
-	m_alignment = GrManager::getSingleton().getDeviceCapabilities().m_storageBufferBindOffsetAlignment;
+	m_alignment = GrManager::getSingleton().getDeviceCapabilities().m_uavBufferBindOffsetAlignment;
 }
 
 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::kAllStorage | BufferUsageBit::kTransferDestination;
+	BufferUsageBit buffUsage = BufferUsageBit::kAllUav | BufferUsageBit::kTransferDestination;
 
 	m_pool.init(buffUsage, classes, poolSize, "GpuScene", true);
 
@@ -136,9 +136,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.bindStorageBuffer(0, 0, headersToken);
-	cmdb.bindStorageBuffer(0, 1, dataToken);
-	cmdb.bindStorageBuffer(0, 2, &GpuSceneBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize);
+	cmdb.bindUavBuffer(0, 0, headersToken);
+	cmdb.bindUavBuffer(0, 1, dataToken);
+	cmdb.bindUavBuffer(0, 2, &GpuSceneBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize);
 
 	cmdb.bindShaderProgram(m_grProgram.get());
 

AnKi/Core/GpuMemory/GpuVisibleTransientMemoryPool.h

@@ -82,12 +82,12 @@ private:
 
 	GpuVisibleTransientMemoryPool()
 	{
-		U32 alignment = GrManager::getSingleton().getDeviceCapabilities().m_uniformBufferBindOffsetAlignment;
-		alignment = max(alignment, GrManager::getSingleton().getDeviceCapabilities().m_storageBufferBindOffsetAlignment);
+		U32 alignment = GrManager::getSingleton().getDeviceCapabilities().m_constantBufferBindOffsetAlignment;
+		alignment = max(alignment, GrManager::getSingleton().getDeviceCapabilities().m_uavBufferBindOffsetAlignment);
 		alignment = max(alignment, GrManager::getSingleton().getDeviceCapabilities().m_sbtRecordAlignment);
 		alignment = max(alignment, GrManager::getSingleton().getDeviceCapabilities().m_accelerationStructureBuildScratchOffsetAlignment);
 
-		BufferUsageBit buffUsage = BufferUsageBit::kAllUniform | BufferUsageBit::kAllStorage | BufferUsageBit::kIndirectDraw
+		BufferUsageBit buffUsage = BufferUsageBit::kAllConstant | BufferUsageBit::kAllUav | 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::kAllUniform | BufferUsageBit::kAllStorage | BufferUsageBit::kVertex | BufferUsageBit::kIndex
+	buffInit.m_usage = BufferUsageBit::kAllConstant | BufferUsageBit::kAllUav | 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_uniformBufferBindOffsetAlignment;
-	m_alignment = max(m_alignment, GrManager::getSingleton().getDeviceCapabilities().m_storageBufferBindOffsetAlignment);
+	m_alignment = GrManager::getSingleton().getDeviceCapabilities().m_constantBufferBindOffsetAlignment;
+	m_alignment = max(m_alignment, GrManager::getSingleton().getDeviceCapabilities().m_uavBufferBindOffsetAlignment);
 	m_alignment = max(m_alignment, GrManager::getSingleton().getDeviceCapabilities().m_sbtRecordAlignment);
 
 	m_mappedMem = static_cast<U8*>(m_buffer->map(0, kMaxPtrSize, BufferMapAccessBit::kWrite));

AnKi/Gr/CommandBuffer.h

@@ -212,19 +212,18 @@ public:
 	/// @param binding The binding to bind to.
 	/// @param[in,out] buff The buffer to bind.
 	/// @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 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 bindUniformBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, U32 arrayIdx = 0);
+	void bindConstantBuffer(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 bindUniformBuffer(U32 set, U32 binding, const BufferOffsetRange& buff, U32 arrayIdx = 0)
+	void bindConstantBuffer(U32 set, U32 binding, const BufferOffsetRange& buff, U32 arrayIdx = 0)
 	{
-		bindUniformBuffer(set, binding, buff.m_buffer, buff.m_offset, buff.m_range, arrayIdx);
+		bindConstantBuffer(set, binding, buff.m_buffer, buff.m_offset, buff.m_range, arrayIdx);
 	}
 
 	/// Bind storage buffer.
@@ -235,16 +234,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 bindStorageBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, U32 arrayIdx = 0);
+	void bindUavBuffer(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 bindStorageBuffer(U32 set, U32 binding, const BufferOffsetRange& buff, U32 arrayIdx = 0)
+	void bindUavBuffer(U32 set, U32 binding, const BufferOffsetRange& buff, U32 arrayIdx = 0)
 	{
-		bindStorageBuffer(set, binding, buff.m_buffer, buff.m_offset, buff.m_range, arrayIdx);
+		bindUavBuffer(set, binding, buff.m_buffer, buff.m_offset, buff.m_range, arrayIdx);
 	}
 
 	/// Bind load/store image.
@@ -252,15 +251,14 @@ 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 bindImage(U32 set, U32 binding, TextureView* img, U32 arrayIdx = 0);
+	void bindUavTexture(U32 set, U32 binding, TextureView* img, U32 arrayIdx = 0);
 
 	/// Bind texture buffer.
 	/// @param set The set to bind to.
 	/// @param binding The binding to bind to.
 	/// @param[in,out] buff The buffer to bind.
 	/// @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 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);
@@ -282,8 +280,8 @@ public:
 	void bindShaderProgram(ShaderProgram* prog);
 
 	/// Begin renderpass.
-	/// The minx, miny, width, height control the area that the load and store operations will happen. If the scissor is
-	/// bigger than the render area the results are undefined.
+	/// The minx, miny, width, height control the area that the load and store operations will happen. If the scissor is bigger than the render area
+	/// the results are undefined.
 	void beginRenderPass(Framebuffer* fb, const Array<TextureUsageBit, kMaxColorRenderTargets>& colorAttachmentUsages,
 						 TextureUsageBit depthStencilAttachmentUsage, U32 minx = 0, U32 miny = 0, U32 width = kMaxU32, U32 height = kMaxU32);
 

AnKi/Gr/Common.h

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

AnKi/Gr/Gl/CommandBuffer.cpp

@@ -636,7 +636,7 @@ void CommandBuffer::bindTextureAndSampler(U32 set, U32 binding, TextureViewPtr t
 	}
 }
 
-void CommandBuffer::bindUniformBuffer(U32 set, U32 binding, BufferPtr buff, PtrSize offset, PtrSize range)
+void CommandBuffer::bindConstantBuffer(U32 set, U32 binding, BufferPtr buff, PtrSize offset, PtrSize range)
 {
 	class Cmd final : public GlCommand
 	{
@@ -665,14 +665,14 @@ void CommandBuffer::bindUniformBuffer(U32 set, U32 binding, BufferPtr buff, PtrS
 	ANKI_ASSERT(range > 0);
 	ANKI_GL_SELF(CommandBufferImpl);
 
-	if(self.m_state.bindUniformBuffer(set, binding, buff, offset, range))
+	if(self.m_state.bindConstantBuffer(set, binding, buff, offset, range))
 	{
 		binding = binding + MAX_UNIFORM_BUFFER_BINDINGS * set;
 		self.pushBackNewCommand<Cmd>(binding, buff, offset, range);
 	}
 }
 
-void CommandBuffer::bindStorageBuffer(U32 set, U32 binding, BufferPtr buff, PtrSize offset, PtrSize range)
+void CommandBuffer::bindUavBuffer(U32 set, U32 binding, BufferPtr buff, PtrSize offset, PtrSize range)
 {
 	class Cmd final : public GlCommand
 	{
@@ -701,14 +701,14 @@ void CommandBuffer::bindStorageBuffer(U32 set, U32 binding, BufferPtr buff, PtrS
 	ANKI_ASSERT(range > 0);
 	ANKI_GL_SELF(CommandBufferImpl);
 
-	if(self.m_state.bindStorageBuffer(set, binding, buff, offset, range))
+	if(self.m_state.bindUavBuffer(set, binding, buff, offset, range))
 	{
 		binding = binding + MAX_STORAGE_BUFFER_BINDINGS * set;
 		self.pushBackNewCommand<Cmd>(binding, buff, offset, range);
 	}
 }
 
-void CommandBuffer::bindImage(U32 set, U32 binding, TextureViewPtr img)
+void CommandBuffer::bindUavTexture(U32 set, U32 binding, TextureViewPtr img)
 {
 	class Cmd final : public GlCommand
 	{
@@ -737,7 +737,7 @@ void CommandBuffer::bindImage(U32 set, U32 binding, TextureViewPtr img)
 	ANKI_ASSERT(static_cast<const TextureViewImpl&>(*img).m_tex->isSubresourceGoodForImageLoadStore(
 		static_cast<const TextureViewImpl&>(*img).getSubresource()));
 
-	if(self.m_state.bindImage(set, binding, img))
+	if(self.m_state.bindUavTexture(set, binding, img))
 	{
 		binding = binding + set * MAX_IMAGE_BINDINGS;
 		self.pushBackNewCommand<Cmd>(binding, img);

AnKi/Gr/Gl/GrManagerImpl.cpp

@@ -59,10 +59,10 @@ Error GrManagerImpl::init(GrManagerInitInfo& init, GrAllocator<U8> alloc)
 
 	// Misc
 	m_capabilities.m_gpuVendor = m_state->m_gpu;
-	m_capabilities.m_uniformBufferBindOffsetAlignment = m_state->m_uboAlignment;
-	m_capabilities.m_uniformBufferMaxRange = m_state->m_uniBlockMaxSize;
-	m_capabilities.m_storageBufferBindOffsetAlignment = m_state->m_ssboAlignment;
-	m_capabilities.m_storageBufferMaxRange = m_state->m_storageBlockMaxSize;
+	m_capabilities.m_constantBufferBindOffsetAlignment = m_state->m_uboAlignment;
+	m_capabilities.m_constantBufferMaxRange = m_state->m_uniBlockMaxSize;
+	m_capabilities.m_uavBufferBindOffsetAlignment = m_state->m_ssboAlignment;
+	m_capabilities.m_uavBufferMaxRange = m_state->m_storageBlockMaxSize;
 	m_capabilities.m_textureBufferBindOffsetAlignment = m_state->m_tboAlignment;
 	m_capabilities.m_textureBufferMaxRange = m_state->m_tboMaxRange;
 	m_capabilities.m_majorApiVersion = U(init.m_config->getNumber("gr.glmajor"));
@@ -82,7 +82,7 @@ void GrManagerImpl::initFakeDefaultFb(GrManagerInitInfo& init)
 	texinit.m_width = defaultFbWidth;
 	texinit.m_height = defaultFbHeight;
 	texinit.m_format = Format::kR8G8B8A8_Unorm;
-	texinit.m_usage = TextureUsageBit::kFramebufferWrite | TextureUsageBit::kImageComputeWrite | TextureUsageBit::kPresent;
+	texinit.m_usage = TextureUsageBit::kFramebufferWrite | TextureUsageBit::kUavComputeWrite | TextureUsageBit::kPresent;
 	m_fakeFbTex = newTexture(texinit);
 
 	TextureViewPtr view = newTextureView(TextureViewInitInfo(m_fakeFbTex, "FB view"));

AnKi/Gr/Gl/StateTracker.h

@@ -470,7 +470,7 @@ public:
 
 	Array2d<ShaderBufferBinding, kMaxDescriptorSets, MAX_UNIFORM_BUFFER_BINDINGS> m_ubos;
 
-	Bool bindUniformBuffer(U32 set, U32 binding, BufferPtr buff, PtrSize offset, PtrSize range)
+	Bool bindConstantBuffer(U32 set, U32 binding, BufferPtr buff, PtrSize offset, PtrSize range)
 	{
 		ShaderBufferBinding& b = m_ubos[set][binding];
 		b.m_buff = static_cast<BufferImpl*>(buff.get());
@@ -481,7 +481,7 @@ public:
 
 	Array2d<ShaderBufferBinding, kMaxDescriptorSets, MAX_STORAGE_BUFFER_BINDINGS> m_ssbos;
 
-	Bool bindStorageBuffer(U32 set, U32 binding, BufferPtr buff, PtrSize offset, PtrSize range)
+	Bool bindUavBuffer(U32 set, U32 binding, BufferPtr buff, PtrSize offset, PtrSize range)
 	{
 		ShaderBufferBinding& b = m_ssbos[set][binding];
 		b.m_buff = static_cast<BufferImpl*>(buff.get());
@@ -498,7 +498,7 @@ public:
 
 	Array2d<ImageBinding, kMaxDescriptorSets, MAX_IMAGE_BINDINGS> m_images;
 
-	Bool bindImage(U32 set, U32 binding, const TextureViewPtr& img)
+	Bool bindUavTexture(U32 set, U32 binding, const TextureViewPtr& img)
 	{
 		ImageBinding& b = m_images[set][binding];
 		b.m_texViewUuid = img->getUuid();

AnKi/Gr/RenderGraph.cpp

@@ -1514,14 +1514,14 @@ StringRaii RenderGraph::textureUsageToStr(StackMemoryPool& pool, TextureUsageBit
 	ANKI_TEX_USAGE(kSampledFragment);
 	ANKI_TEX_USAGE(kSampledCompute);
 	ANKI_TEX_USAGE(kSampledTraceRays);
-	ANKI_TEX_USAGE(kImageGeometryRead);
-	ANKI_TEX_USAGE(kImageGeometryWrite);
-	ANKI_TEX_USAGE(kImageFragmentRead);
-	ANKI_TEX_USAGE(kImageFragmentWrite);
-	ANKI_TEX_USAGE(kImageComputeRead);
-	ANKI_TEX_USAGE(kImageComputeWrite);
-	ANKI_TEX_USAGE(kImageTraceRaysRead);
-	ANKI_TEX_USAGE(kImageTraceRaysWrite);
+	ANKI_TEX_USAGE(kUavGeometryRead);
+	ANKI_TEX_USAGE(kUavGeometryWrite);
+	ANKI_TEX_USAGE(kUavFragmentRead);
+	ANKI_TEX_USAGE(kUavFragmentWrite);
+	ANKI_TEX_USAGE(kUavComputeRead);
+	ANKI_TEX_USAGE(kUavComputeWrite);
+	ANKI_TEX_USAGE(kUavTraceRaysRead);
+	ANKI_TEX_USAGE(kUavTraceRaysWrite);
 	ANKI_TEX_USAGE(kFramebufferRead);
 	ANKI_TEX_USAGE(kFramebufferWrite);
 	ANKI_TEX_USAGE(kTransferDestination);
@@ -1552,10 +1552,10 @@ StringRaii RenderGraph::bufferUsageToStr(StackMemoryPool& pool, BufferUsageBit u
 			slist.pushBackSprintf("%s", #u); \
 		}
 
-	ANKI_BUFF_USAGE(kUniformGeometry);
-	ANKI_BUFF_USAGE(kUniformFragment);
-	ANKI_BUFF_USAGE(kUniformCompute);
-	ANKI_BUFF_USAGE(kUniformTraceRays);
+	ANKI_BUFF_USAGE(kConstantGeometry);
+	ANKI_BUFF_USAGE(kConstantFragment);
+	ANKI_BUFF_USAGE(kConstantCompute);
+	ANKI_BUFF_USAGE(kConstantTraceRays);
 	ANKI_BUFF_USAGE(kStorageGeometryRead);
 	ANKI_BUFF_USAGE(kStorageGeometryWrite);
 	ANKI_BUFF_USAGE(kStorageFragmentRead);

AnKi/Gr/RenderGraph.h

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

AnKi/Gr/Vulkan/BufferImpl.cpp

@@ -298,17 +298,17 @@ VkAccessFlags BufferImpl::computeAccessMask(BufferUsageBit usage)
 {
 	VkAccessFlags mask = 0;
 
-	constexpr BufferUsageBit kShaderRead = BufferUsageBit::kStorageGeometryRead | BufferUsageBit::kStorageFragmentRead
-										   | BufferUsageBit::kStorageComputeRead | BufferUsageBit::kStorageTraceRaysRead
-										   | BufferUsageBit::kTextureGeometryRead | BufferUsageBit::kTextureFragmentRead
-										   | BufferUsageBit::kTextureComputeRead | BufferUsageBit::kTextureTraceRaysRead;
+	constexpr BufferUsageBit kShaderRead = BufferUsageBit::kUavGeometryRead | BufferUsageBit::kUavFragmentRead | BufferUsageBit::kUavComputeRead
+										   | BufferUsageBit::kUavTraceRaysRead | BufferUsageBit::kTextureGeometryRead
+										   | BufferUsageBit::kTextureFragmentRead | BufferUsageBit::kTextureComputeRead
+										   | BufferUsageBit::kTextureTraceRaysRead;
 
-	constexpr BufferUsageBit kShaderWrite = BufferUsageBit::kStorageGeometryWrite | BufferUsageBit::kStorageFragmentWrite
-											| BufferUsageBit::kStorageComputeWrite | BufferUsageBit::kStorageTraceRaysWrite
-											| BufferUsageBit::kTextureGeometryWrite | BufferUsageBit::kTextureFragmentWrite
-											| BufferUsageBit::kTextureComputeWrite | BufferUsageBit::kTextureTraceRaysWrite;
+	constexpr BufferUsageBit kShaderWrite = BufferUsageBit::kUavGeometryWrite | BufferUsageBit::kUavFragmentWrite | BufferUsageBit::kUavComputeWrite
+											| BufferUsageBit::kUavTraceRaysWrite | BufferUsageBit::kTextureGeometryWrite
+											| BufferUsageBit::kTextureFragmentWrite | BufferUsageBit::kTextureComputeWrite
+											| BufferUsageBit::kTextureTraceRaysWrite;
 
-	if(!!(usage & BufferUsageBit::kAllUniform))
+	if(!!(usage & BufferUsageBit::kAllConstant))
 	{
 		mask |= VK_ACCESS_UNIFORM_READ_BIT;
 	}

AnKi/Gr/Vulkan/CommandBuffer.cpp

@@ -195,22 +195,22 @@ void CommandBuffer::bindSampler(U32 set, U32 binding, Sampler* sampler, U32 arra
 	self.bindSamplerInternal(set, binding, sampler, arrayIdx);
 }
 
-void CommandBuffer::bindUniformBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, U32 arrayIdx)
+void CommandBuffer::bindConstantBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, U32 arrayIdx)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
-	self.bindUniformBufferInternal(set, binding, buff, offset, range, arrayIdx);
+	self.bindConstantBufferInternal(set, binding, buff, offset, range, arrayIdx);
 }
 
-void CommandBuffer::bindStorageBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, U32 arrayIdx)
+void CommandBuffer::bindUavBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, U32 arrayIdx)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
-	self.bindStorageBufferInternal(set, binding, buff, offset, range, arrayIdx);
+	self.bindUavBufferInternal(set, binding, buff, offset, range, arrayIdx);
 }
 
-void CommandBuffer::bindImage(U32 set, U32 binding, TextureView* img, U32 arrayIdx)
+void CommandBuffer::bindUavTexture(U32 set, U32 binding, TextureView* img, U32 arrayIdx)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
-	self.bindImageInternal(set, binding, img, arrayIdx);
+	self.bindUavTextureInternal(set, binding, img, arrayIdx);
 }
 
 void CommandBuffer::bindAccelerationStructure(U32 set, U32 binding, AccelerationStructure* as, U32 arrayIdx)

AnKi/Gr/Vulkan/CommandBufferImpl.h

@@ -235,10 +235,10 @@ public:
 		m_microCmdb->pushObjectRef(sampler);
 	}
 
-	ANKI_FORCE_INLINE void bindImageInternal(U32 set, U32 binding, TextureView* img, U32 arrayIdx)
+	ANKI_FORCE_INLINE void bindUavTextureInternal(U32 set, U32 binding, TextureView* img, U32 arrayIdx)
 	{
 		commandCommon();
-		m_dsetState[set].bindImage(binding, arrayIdx, img);
+		m_dsetState[set].bindUavTexture(binding, arrayIdx, img);
 
 		const Bool isPresentable = !!(static_cast<const TextureViewImpl&>(*img).getTextureImpl().getTextureUsage() & TextureUsageBit::kPresent);
 		if(isPresentable)
@@ -408,16 +408,16 @@ public:
 
 	void bindShaderProgramInternal(ShaderProgram* prog);
 
-	ANKI_FORCE_INLINE void bindUniformBufferInternal(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, U32 arrayIdx)
+	ANKI_FORCE_INLINE void bindConstantBufferInternal(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, U32 arrayIdx)
 	{
 		commandCommon();
-		m_dsetState[set].bindUniformBuffer(binding, arrayIdx, buff, offset, range);
+		m_dsetState[set].bindConstantBuffer(binding, arrayIdx, buff, offset, range);
 	}
 
-	ANKI_FORCE_INLINE void bindStorageBufferInternal(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, U32 arrayIdx)
+	ANKI_FORCE_INLINE void bindUavBufferInternal(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, U32 arrayIdx)
 	{
 		commandCommon();
-		m_dsetState[set].bindStorageBuffer(binding, arrayIdx, buff, offset, range);
+		m_dsetState[set].bindUavBuffer(binding, arrayIdx, buff, offset, range);
 	}
 
 	ANKI_FORCE_INLINE void bindReadOnlyTextureBufferInternal(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, Format fmt,

AnKi/Gr/Vulkan/Common.cpp

@@ -274,12 +274,12 @@ VkBufferUsageFlags convertBufferUsageBit(BufferUsageBit usageMask)
 {
 	VkBufferUsageFlags out = 0;
 
-	if(!!(usageMask & BufferUsageBit::kAllUniform))
+	if(!!(usageMask & BufferUsageBit::kAllConstant))
 	{
 		out |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
 	}
 
-	if(!!(usageMask & BufferUsageBit::kAllStorage))
+	if(!!(usageMask & BufferUsageBit::kAllUav))
 	{
 		out |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
 	}
@@ -407,7 +407,7 @@ VkImageUsageFlags convertTextureUsage(const TextureUsageBit ak, const Format for
 		out |= VK_IMAGE_USAGE_SAMPLED_BIT;
 	}
 
-	if(!!(ak & TextureUsageBit::kAllImage))
+	if(!!(ak & TextureUsageBit::kAllUav))
 	{
 		out |= VK_IMAGE_USAGE_STORAGE_BIT;
 	}

AnKi/Gr/Vulkan/DescriptorSet.h

@@ -241,7 +241,7 @@ public:
 		unbindBindlessDSet();
 	}
 
-	void bindUniformBuffer(U32 binding, U32 arrayIdx, const Buffer* buff, PtrSize offset, PtrSize range)
+	void bindConstantBuffer(U32 binding, U32 arrayIdx, const Buffer* buff, PtrSize offset, PtrSize range)
 	{
 		AnyBinding& b = getBindingToPopulate(binding, arrayIdx);
 		b = {};
@@ -256,7 +256,7 @@ public:
 		unbindBindlessDSet();
 	}
 
-	void bindStorageBuffer(U32 binding, U32 arrayIdx, const Buffer* buff, PtrSize offset, PtrSize range)
+	void bindUavBuffer(U32 binding, U32 arrayIdx, const Buffer* buff, PtrSize offset, PtrSize range)
 	{
 		AnyBinding& b = getBindingToPopulate(binding, arrayIdx);
 		b = {};
@@ -286,7 +286,7 @@ public:
 		unbindBindlessDSet();
 	}
 
-	void bindImage(U32 binding, U32 arrayIdx, const TextureView* texView)
+	void bindUavTexture(U32 binding, U32 arrayIdx, const TextureView* texView)
 	{
 		ANKI_ASSERT(texView);
 		const TextureViewImpl* impl = static_cast<const TextureViewImpl*>(texView);

AnKi/Gr/Vulkan/GrManagerImpl.cpp

@@ -545,12 +545,11 @@ 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_uniformBufferBindOffsetAlignment =
+	m_capabilities.m_constantBufferBindOffsetAlignment =
 		max<U32>(ANKI_SAFE_ALIGNMENT, U32(m_devProps.properties.limits.minUniformBufferOffsetAlignment));
-	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_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_textureBufferMaxRange = kMaxU32;

AnKi/Gr/Vulkan/SwapchainFactory.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::kImageComputeWrite | TextureUsageBit::kImageTraceRaysWrite | TextureUsageBit::kFramebufferRead
+			init.m_usage = TextureUsageBit::kUavComputeWrite | TextureUsageBit::kUavTraceRaysWrite | TextureUsageBit::kFramebufferRead
 						   | TextureUsageBit::kFramebufferWrite | TextureUsageBit::kPresent;
 			init.m_type = TextureType::k2D;
 

AnKi/Gr/Vulkan/TextureImpl.cpp

@@ -340,51 +340,51 @@ void TextureImpl::computeBarrierInfo(TextureUsageBit usage, Bool src, U32 level,
 	accesses = 0;
 	const Bool depthStencil = !!m_aspect;
 
-	if(!!(usage & (TextureUsageBit::kSampledGeometry | TextureUsageBit::kImageGeometryRead)))
+	if(!!(usage & (TextureUsageBit::kSampledGeometry | TextureUsageBit::kUavGeometryRead)))
 	{
 		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::kImageGeometryWrite))
+	if(!!(usage & TextureUsageBit::kUavGeometryWrite))
 	{
 		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::kImageFragmentRead)))
+	if(!!(usage & (TextureUsageBit::kSampledFragment | TextureUsageBit::kUavFragmentRead)))
 	{
 		stages |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
 		accesses |= VK_ACCESS_SHADER_READ_BIT;
 	}
 
-	if(!!(usage & TextureUsageBit::kImageFragmentWrite))
+	if(!!(usage & TextureUsageBit::kUavFragmentWrite))
 	{
 		stages |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
 		accesses |= VK_ACCESS_SHADER_WRITE_BIT;
 	}
 
-	if(!!(usage & (TextureUsageBit::kSampledCompute | TextureUsageBit::kImageComputeRead)))
+	if(!!(usage & (TextureUsageBit::kSampledCompute | TextureUsageBit::kUavComputeRead)))
 	{
 		stages |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
 		accesses |= VK_ACCESS_SHADER_READ_BIT;
 	}
 
-	if(!!(usage & TextureUsageBit::kImageComputeWrite))
+	if(!!(usage & TextureUsageBit::kUavComputeWrite))
 	{
 		stages |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
 		accesses |= VK_ACCESS_SHADER_WRITE_BIT;
 	}
 
-	if(!!(usage & (TextureUsageBit::kSampledTraceRays | TextureUsageBit::kImageTraceRaysRead)))
+	if(!!(usage & (TextureUsageBit::kSampledTraceRays | TextureUsageBit::kUavTraceRaysRead)))
 	{
 		stages |= VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
 		accesses |= VK_ACCESS_SHADER_READ_BIT;
 	}
 
-	if(!!(usage & TextureUsageBit::kImageTraceRaysWrite))
+	if(!!(usage & TextureUsageBit::kUavTraceRaysWrite))
 	{
 		stages |= VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
 		accesses |= VK_ACCESS_SHADER_WRITE_BIT;
@@ -512,7 +512,7 @@ VkImageLayout TextureImpl::computeLayout(TextureUsageBit usage, U level) const
 		// SRI
 		out = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR;
 	}
-	else if(!(usage & ~TextureUsageBit::kAllImage))
+	else if(!(usage & ~TextureUsageBit::kAllUav))
 	{
 		// Only image load/store
 		out = VK_IMAGE_LAYOUT_GENERAL;

AnKi/Renderer/Bloom.cpp

@@ -115,7 +115,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::kImageComputeWrite);
+			rpass.newTextureDependency(m_runCtx.m_exposureRt, TextureUsageBit::kUavComputeWrite);
 
 			prpass = &rpass;
 		}
@@ -144,11 +144,11 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 			const Vec4 uniforms(g_bloomThresholdCVar.get(), g_bloomScaleCVar.get(), 0.0f, 0.0f);
 			cmdb.setPushConstants(&uniforms, sizeof(uniforms));
 
-			rgraphCtx.bindImage(0, 2, getRenderer().getTonemapping().getRt());
+			rgraphCtx.bindUavTexture(0, 2, getRenderer().getTonemapping().getRt());
 
 			if(g_preferComputeCVar.get())
 			{
-				rgraphCtx.bindImage(0, 3, m_runCtx.m_exposureRt, TextureSubresourceInfo());
+				rgraphCtx.bindUavTexture(0, 3, m_runCtx.m_exposureRt, TextureSubresourceInfo());
 
 				dispatchPPCompute(cmdb, 8, 8, m_exposure.m_width, m_exposure.m_height);
 			}
@@ -173,7 +173,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::kImageComputeWrite);
+			rpass.newTextureDependency(m_runCtx.m_upscaleRt, TextureUsageBit::kUavComputeWrite);
 
 			prpass = &rpass;
 		}
@@ -199,7 +199,7 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 
 			if(g_preferComputeCVar.get())
 			{
-				rgraphCtx.bindImage(0, 3, m_runCtx.m_upscaleRt, TextureSubresourceInfo());
+				rgraphCtx.bindUavTexture(0, 3, m_runCtx.m_upscaleRt, TextureSubresourceInfo());
 
 				dispatchPPCompute(cmdb, 8, 8, m_upscale.m_width, m_upscale.m_height);
 			}

AnKi/Renderer/ClusterBinning.cpp

@@ -53,11 +53,11 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 
 	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
 
-	// Fire an async job to fill the general uniforms
+	// Fire an async job to fill the general consts
 	{
 		m_runCtx.m_rctx = &ctx;
-		m_runCtx.m_clusterUniformsBuffer = RebarTransientMemoryPool::getSingleton().allocateFrame(1, m_runCtx.m_uniformsCpu);
-		writeClusterUniformsInternal();
+		m_runCtx.m_clusterConstBuffer = RebarTransientMemoryPool::getSingleton().allocateFrame(1, m_runCtx.m_constsCpu);
+		writeClusterConstsInternal();
 	}
 
 	// Allocate the clusters buffer
@@ -82,9 +82,9 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 		for(GpuSceneNonRenderableObjectType type : EnumIterable<GpuSceneNonRenderableObjectType>())
 		{
 			rpass.newBufferDependency(getRenderer().getPrimaryNonRenderableVisibility().getVisibleIndicesBufferHandle(type),
-									  BufferUsageBit::kStorageComputeRead);
+									  BufferUsageBit::kUavComputeRead);
 		}
-		rpass.newBufferDependency(indirectArgsHandle, BufferUsageBit::kStorageComputeWrite);
+		rpass.newBufferDependency(indirectArgsHandle, BufferUsageBit::kUavComputeWrite);
 		rpass.newBufferDependency(m_runCtx.m_clustersHandle, BufferUsageBit::kTransferDestination);
 
 		rpass.setWork([this, indirectArgsBuff](RenderPassWorkContext& rgraphCtx) {
@@ -92,16 +92,16 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 
 			cmdb.bindShaderProgram(m_jobSetupGrProg.get());
 
-			const UVec4 uniforms(getRenderer().getTileCounts().x() * getRenderer().getTileCounts().y());
-			cmdb.setPushConstants(&uniforms, sizeof(uniforms));
+			const UVec4 consts(getRenderer().getTileCounts().x() * getRenderer().getTileCounts().y());
+			cmdb.setPushConstants(&consts, sizeof(consts));
 
 			for(GpuSceneNonRenderableObjectType type : EnumIterable<GpuSceneNonRenderableObjectType>())
 			{
 				const BufferOffsetRange& buff = getRenderer().getPrimaryNonRenderableVisibility().getVisibleIndicesBuffer(type);
-				cmdb.bindStorageBuffer(0, 0, buff.m_buffer, buff.m_offset, buff.m_range, U32(type));
+				cmdb.bindUavBuffer(0, 0, buff.m_buffer, buff.m_offset, buff.m_range, U32(type));
 			}
 
-			cmdb.bindStorageBuffer(0, 1, indirectArgsBuff.m_buffer, indirectArgsBuff.m_offset, indirectArgsBuff.m_range);
+			cmdb.bindUavBuffer(0, 1, indirectArgsBuff.m_buffer, indirectArgsBuff.m_offset, indirectArgsBuff.m_range);
 
 			cmdb.dispatchCompute(1, 1, 1);
 
@@ -116,7 +116,7 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 		ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("Cluster binning");
 
 		rpass.newBufferDependency(indirectArgsHandle, BufferUsageBit::kIndirectCompute);
-		rpass.newBufferDependency(m_runCtx.m_clustersHandle, BufferUsageBit::kStorageComputeWrite);
+		rpass.newBufferDependency(m_runCtx.m_clustersHandle, BufferUsageBit::kUavComputeWrite);
 
 		rpass.setWork([this, &ctx, indirectArgsBuff](RenderPassWorkContext& rgraphCtx) {
 			CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
@@ -127,7 +127,7 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 				cmdb.bindShaderProgram(m_binningGrProgs[type].get());
 
 				const BufferOffsetRange& idsBuff = getRenderer().getPrimaryNonRenderableVisibility().getVisibleIndicesBuffer(type);
-				cmdb.bindStorageBuffer(0, 0, idsBuff.m_buffer, idsBuff.m_offset, idsBuff.m_range);
+				cmdb.bindUavBuffer(0, 0, idsBuff.m_buffer, idsBuff.m_offset, idsBuff.m_range);
 
 				PtrSize objBufferOffset = 0;
 				PtrSize objBufferRange = 0;
@@ -163,11 +163,10 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 					objBufferRange = kMaxPtrSize;
 				}
 
-				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);
+				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);
 
-				struct ClusterBinningUniforms
+				struct ClusterBinningConstants
 				{
 					Vec3 m_cameraOrigin;
 					F32 m_zSplitCountOverFrustumLength;
@@ -179,21 +178,21 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 					Vec4 m_nearPlaneWorld;
 
 					Mat4 m_invertedViewProjMat;
-				} uniforms;
+				} consts;
 
-				uniforms.m_cameraOrigin = ctx.m_matrices.m_cameraTransform.getTranslationPart().xyz();
-				uniforms.m_zSplitCountOverFrustumLength = F32(getRenderer().getZSplitCount()) / (ctx.m_cameraFar - ctx.m_cameraNear);
-				uniforms.m_renderingSize = Vec2(getRenderer().getInternalResolution());
-				uniforms.m_tileCountX = getRenderer().getTileCounts().x();
-				uniforms.m_tileCount = getRenderer().getTileCounts().x() * getRenderer().getTileCounts().y();
+				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();
 
 				Plane nearPlane;
 				extractClipPlane(ctx.m_matrices.m_viewProjection, FrustumPlaneType::kNear, nearPlane);
-				uniforms.m_nearPlaneWorld = Vec4(nearPlane.getNormal().xyz(), nearPlane.getOffset());
+				consts.m_nearPlaneWorld = Vec4(nearPlane.getNormal().xyz(), nearPlane.getOffset());
 
-				uniforms.m_invertedViewProjMat = ctx.m_matrices.m_invertedViewProjectionJitter;
+				consts.m_invertedViewProjMat = ctx.m_matrices.m_invertedViewProjectionJitter;
 
-				cmdb.setPushConstants(&uniforms, sizeof(uniforms));
+				cmdb.setPushConstants(&consts, sizeof(consts));
 
 				cmdb.dispatchComputeIndirect(indirectArgsBuff.m_buffer, indirectArgsBuffOffset);
 				indirectArgsBuffOffset += sizeof(DispatchIndirectArgs);
@@ -216,7 +215,7 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 		rpass.newBufferDependency(indirectArgsHandle, BufferUsageBit::kIndirectCompute);
 		for(GpuSceneNonRenderableObjectType type : EnumIterable<GpuSceneNonRenderableObjectType>())
 		{
-			rpass.newBufferDependency(m_runCtx.m_packedObjectsHandles[type], BufferUsageBit::kStorageComputeWrite);
+			rpass.newBufferDependency(m_runCtx.m_packedObjectsHandles[type], BufferUsageBit::kUavComputeWrite);
 		}
 
 		rpass.setWork([this, indirectArgsBuff](RenderPassWorkContext& rgraphCtx) {
@@ -261,12 +260,12 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 					objBufferRange = kMaxPtrSize;
 				}
 
-				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);
+				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);
 
 				const BufferOffsetRange& idsBuff = getRenderer().getPrimaryNonRenderableVisibility().getVisibleIndicesBuffer(type);
-				cmdb.bindStorageBuffer(0, 2, idsBuff.m_buffer, idsBuff.m_offset, idsBuff.m_range);
+				cmdb.bindUavBuffer(0, 2, idsBuff.m_buffer, idsBuff.m_offset, idsBuff.m_range);
 
 				cmdb.dispatchComputeIndirect(indirectArgsBuff.m_buffer, indirectArgsBuffOffset);
 				indirectArgsBuffOffset += sizeof(DispatchIndirectArgs);
@@ -275,12 +274,12 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 	}
 }
 
-void ClusterBinning::writeClusterUniformsInternal()
+void ClusterBinning::writeClusterConstsInternal()
 {
 	ANKI_TRACE_SCOPED_EVENT(RWriteClusterShadingObjects);
 
 	RenderingContext& ctx = *m_runCtx.m_rctx;
-	ClusteredShadingUniforms& unis = *m_runCtx.m_uniformsCpu;
+	ClusteredShadingConstants& unis = *m_runCtx.m_constsCpu;
 
 	unis.m_renderingSize = Vec2(F32(getRenderer().getInternalResolution().x()), F32(getRenderer().getInternalResolution().y()));
 

AnKi/Renderer/ClusterBinning.h

@@ -25,9 +25,9 @@ public:
 	/// Populate the rendergraph.
 	void populateRenderGraph(RenderingContext& ctx);
 
-	const BufferOffsetRange& getClusteredShadingUniforms() const
+	const BufferOffsetRange& getClusteredShadingConstants() const
 	{
-		return m_runCtx.m_clusterUniformsBuffer;
+		return m_runCtx.m_clusterConstBuffer;
 	}
 
 	const BufferOffsetRange& getPackedObjectsBuffer(GpuSceneNonRenderableObjectType type) const
@@ -69,12 +69,12 @@ private:
 		Array<BufferHandle, U32(GpuSceneNonRenderableObjectType::kCount)> m_packedObjectsHandles;
 		Array<BufferOffsetRange, U32(GpuSceneNonRenderableObjectType::kCount)> m_packedObjectsBuffers;
 
-		BufferOffsetRange m_clusterUniformsBuffer;
-		ClusteredShadingUniforms* m_uniformsCpu = nullptr;
+		BufferOffsetRange m_clusterConstBuffer;
+		ClusteredShadingConstants* m_constsCpu = nullptr;
 		RenderingContext* m_rctx = nullptr;
 	} m_runCtx;
 
-	void writeClusterUniformsInternal();
+	void writeClusterConstsInternal();
 };
 /// @}
 

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 Uniforms
+	class Constants
 	{
 	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.bindStorageBuffer(0, 2, getRenderer().getClusterBinning().getPackedObjectsBuffer(type));
-	cmdb.bindStorageBuffer(0, 3, getRenderer().getPrimaryNonRenderableVisibility().getVisibleIndicesBuffer(type));
+	cmdb.bindUavBuffer(0, 2, getRenderer().getClusterBinning().getPackedObjectsBuffer(type));
+	cmdb.bindUavBuffer(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 Uniforms
+		class Constants
 		{
 		public:
 			Vec4 m_color;
@@ -195,8 +195,8 @@ void Dbg::run(RenderPassWorkContext& rgraphCtx, const RenderingContext& ctx)
 		cmdb.setVertexAttribute(0, 0, Format::kR32G32B32_Sfloat, 0);
 		cmdb.bindIndexBuffer(m_cubeIndicesBuffer.get(), 0, IndexType::kU16);
 
-		cmdb.bindStorageBuffer(0, 2, GpuSceneArrays::RenderableBoundingVolumeGBuffer::getSingleton().getBufferOffsetRange());
-		cmdb.bindStorageBuffer(0, 3, getRenderer().getGBuffer().getVisibleAabbsBuffer());
+		cmdb.bindUavBuffer(0, 2, GpuSceneArrays::RenderableBoundingVolumeGBuffer::getSingleton().getBufferOffsetRange());
+		cmdb.bindUavBuffer(0, 3, getRenderer().getGBuffer().getVisibleAabbsBuffer());
 
 		cmdb.drawIndexed(PrimitiveTopology::kLines, 12 * 2, allAabbCount);
 	}
@@ -205,8 +205,8 @@ void Dbg::run(RenderPassWorkContext& rgraphCtx, const RenderingContext& ctx)
 	{
 		const U32 allAabbCount = GpuSceneArrays::RenderableBoundingVolumeForward::getSingleton().getElementCount();
 
-		cmdb.bindStorageBuffer(0, 2, GpuSceneArrays::RenderableBoundingVolumeForward::getSingleton().getBufferOffsetRange());
-		cmdb.bindStorageBuffer(0, 3, getRenderer().getForwardShading().getVisibleAabbsBuffer());
+		cmdb.bindUavBuffer(0, 2, GpuSceneArrays::RenderableBoundingVolumeForward::getSingleton().getBufferOffsetRange());
+		cmdb.bindUavBuffer(0, 3, getRenderer().getForwardShading().getVisibleAabbsBuffer());
 
 		cmdb.drawIndexed(PrimitiveTopology::kLines, 12 * 2, allAabbCount);
 	}

AnKi/Renderer/DepthDownscale.cpp

@@ -68,7 +68,7 @@ Error DepthDownscale::initInternal()
 	{
 		BufferInitInfo buffInit("Depth downscale counter buffer");
 		buffInit.m_size = sizeof(U32);
-		buffInit.m_usage = BufferUsageBit::kStorageComputeWrite | BufferUsageBit::kTransferDestination;
+		buffInit.m_usage = BufferUsageBit::kUavComputeWrite | BufferUsageBit::kTransferDestination;
 		m_counterBuffer = GrManager::getSingleton().newBuffer(buffInit);
 
 		// Zero it
@@ -130,7 +130,7 @@ void DepthDownscale::populateRenderGraph(RenderingContext& ctx)
 		{
 			TextureSubresourceInfo subresource;
 			subresource.m_firstMipmap = mip;
-			pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kImageComputeWrite, subresource);
+			pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kUavComputeWrite, subresource);
 		}
 
 		pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
@@ -144,7 +144,7 @@ void DepthDownscale::populateRenderGraph(RenderingContext& ctx)
 			varAU4(rectInfo) = initAU4(0, 0, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
 			SpdSetup(dispatchThreadGroupCountXY, workGroupOffset, numWorkGroupsAndMips, rectInfo, m_mipCount);
 
-			DepthDownscaleUniforms pc;
+			DepthDownscaleConstants pc;
 			pc.m_threadgroupCount = numWorkGroupsAndMips[0];
 			pc.m_mipmapCount = numWorkGroupsAndMips[1];
 			pc.m_srcTexSizeOverOne = 1.0f / Vec2(getRenderer().getInternalResolution());
@@ -163,10 +163,10 @@ void DepthDownscale::populateRenderGraph(RenderingContext& ctx)
 					subresource.m_firstMipmap = 0; // Put something random
 				}
 
-				rgraphCtx.bindImage(0, 0, m_runCtx.m_rt, subresource, mip);
+				rgraphCtx.bindUavTexture(0, 0, m_runCtx.m_rt, subresource, mip);
 			}
 
-			cmdb.bindStorageBuffer(0, 1, m_counterBuffer.get(), 0, sizeof(U32));
+			cmdb.bindUavBuffer(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::kSampledCompute | TextureUsageBit::kImageComputeWrite;
+		texinit.m_usage |= TextureUsageBit::kSampledCompute | TextureUsageBit::kUavComputeWrite;
 	}
 	else
 	{
@@ -102,14 +102,14 @@ void DownscaleBlur::populateRenderGraph(RenderingContext& ctx)
 				sampleSubresource.m_firstMipmap = i - 1;
 				renderSubresource.m_firstMipmap = i;
 
-				pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kImageComputeWrite, renderSubresource);
+				pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kUavComputeWrite, renderSubresource);
 				pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kSampledCompute, sampleSubresource);
 			}
 			else
 			{
 				TextureSubresourceInfo renderSubresource;
 
-				pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kImageComputeWrite, renderSubresource);
+				pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kUavComputeWrite, renderSubresource);
 				pass.newTextureDependency(inRt, TextureUsageBit::kSampledCompute);
 			}
 		}
@@ -170,7 +170,7 @@ void DownscaleBlur::run(U32 passIdx, RenderPassWorkContext& rgraphCtx)
 		rgraphCtx.bindColorTexture(0, 1, inRt);
 	}
 
-	rgraphCtx.bindImage(0, 2, getRenderer().getTonemapping().getRt());
+	rgraphCtx.bindUavTexture(0, 2, getRenderer().getTonemapping().getRt());
 
 	const Bool revertTonemap = passIdx == 0 && !getRenderer().getScale().hasUpscaledHdrRt();
 	const UVec4 fbSize(vpWidth, vpHeight, revertTonemap, 0);
@@ -180,7 +180,7 @@ void DownscaleBlur::run(U32 passIdx, RenderPassWorkContext& rgraphCtx)
 	{
 		TextureSubresourceInfo sampleSubresource;
 		sampleSubresource.m_firstMipmap = passIdx;
-		rgraphCtx.bindImage(0, 3, m_runCtx.m_rt, sampleSubresource);
+		rgraphCtx.bindUavTexture(0, 3, m_runCtx.m_rt, sampleSubresource);
 
 		dispatchPPCompute(cmdb, 8, 8, vpWidth, vpHeight);
 	}

AnKi/Renderer/ForwardShading.cpp

@@ -58,14 +58,14 @@ void ForwardShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgr
 	rgraphCtx.bindTexture(set, U32(MaterialBinding::kDepthRt), getRenderer().getDepthDownscale().getRt(), DepthDownscale::kQuarterInternalResolution);
 	rgraphCtx.bindColorTexture(set, U32(MaterialBinding::kLightVolume), getRenderer().getVolumetricLightingAccumulation().getRt());
 
-	cmdb.bindUniformBuffer(set, U32(MaterialBinding::kClusterShadingUniforms), getRenderer().getClusterBinning().getClusteredShadingUniforms());
+	cmdb.bindConstantBuffer(set, U32(MaterialBinding::kClusterShadingConstants), getRenderer().getClusterBinning().getClusteredShadingConstants());
 
-	cmdb.bindStorageBuffer(set, U32(MaterialBinding::kClusterShadingLights),
-						   getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kLight));
+	cmdb.bindUavBuffer(set, U32(MaterialBinding::kClusterShadingLights),
+					   getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kLight));
 
 	rgraphCtx.bindColorTexture(set, U32(MaterialBinding::kClusterShadingLights) + 1, getRenderer().getShadowMapping().getShadowmapRt());
 
-	cmdb.bindStorageBuffer(set, U32(MaterialBinding::kClusters), getRenderer().getClusterBinning().getClustersBuffer());
+	cmdb.bindUavBuffer(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::kImageComputeWrite;
+		const TextureUsageBit usage = TextureUsageBit::kSampledCompute | TextureUsageBit::kUavComputeWrite;
 
 		TextureInitInfo texinit =
 			getRenderer().create2DRenderTargetInitInfo(g_hzbWidthCVar.get(), g_hzbHeightCVar.get(), Format::kR32_Sfloat, usage, "GBuffer HZB");
@@ -237,7 +237,7 @@ void GBuffer::populateRenderGraph(RenderingContext& ctx)
 		pass.newTextureDependency(sriRt, TextureUsageBit::kFramebufferShadingRate);
 	}
 
-	pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kStorageGeometryRead | BufferUsageBit::kStorageFragmentRead);
+	pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kUavGeometryRead | BufferUsageBit::kUavFragmentRead);
 
 	// Only add one depedency to the GPU visibility. No need to track all buffers
 	pass.newBufferDependency(visOut.m_someBufferHandle, BufferUsageBit::kIndirectDraw);

AnKi/Renderer/GBufferPost.cpp

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

AnKi/Renderer/IndirectDiffuse.cpp

@@ -50,7 +50,7 @@ Error IndirectDiffuse::initInternal()
 	// Init textures
 	TextureUsageBit usage = TextureUsageBit::kAllSampled;
 
-	usage |= (preferCompute) ? TextureUsageBit::kImageComputeWrite : TextureUsageBit::kFramebufferWrite;
+	usage |= (preferCompute) ? TextureUsageBit::kUavComputeWrite : TextureUsageBit::kFramebufferWrite;
 	TextureInitInfo texInit =
 		getRenderer().create2DRenderTargetInitInfo(size.x(), size.y(), getRenderer().getHdrFormat(), usage, "IndirectDiffuse #1");
 	m_rts[0] = getRenderer().createAndClearRenderTarget(texInit, TextureUsageBit::kAllSampled);
@@ -174,7 +174,7 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("IndirectDiffuse VRS SRI gen");
 
-		pass.newTextureDependency(m_runCtx.m_sriRt, TextureUsageBit::kImageComputeWrite);
+		pass.newTextureDependency(m_runCtx.m_sriRt, TextureUsageBit::kUavComputeWrite);
 		pass.newTextureDependency(getRenderer().getDepthDownscale().getRt(), TextureUsageBit::kSampledCompute,
 								  DepthDownscale::kQuarterInternalResolution);
 
@@ -187,7 +187,7 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 
 			rgraphCtx.bindTexture(0, 0, getRenderer().getDepthDownscale().getRt(), DepthDownscale::kQuarterInternalResolution);
 			cmdb.bindSampler(0, 1, getRenderer().getSamplers().m_nearestNearestClamp.get());
-			rgraphCtx.bindImage(0, 2, m_runCtx.m_sriRt);
+			rgraphCtx.bindUavTexture(0, 2, m_runCtx.m_sriRt);
 
 			class
 			{
@@ -231,8 +231,8 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 		{
 			ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("IndirectDiffuse");
 			readUsage = TextureUsageBit::kSampledCompute;
-			writeUsage = TextureUsageBit::kImageComputeWrite;
-			readBufferUsage = BufferUsageBit::kStorageComputeRead;
+			writeUsage = TextureUsageBit::kUavComputeWrite;
+			readBufferUsage = BufferUsageBit::kUavComputeRead;
 			prpass = &rpass;
 		}
 		else
@@ -241,7 +241,7 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 			rpass.setFramebufferInfo(m_main.m_fbDescr, {m_runCtx.m_mainRtHandles[kWrite]}, {}, (enableVrs) ? m_runCtx.m_sriRt : RenderTargetHandle());
 			readUsage = TextureUsageBit::kSampledFragment;
 			writeUsage = TextureUsageBit::kFramebufferWrite;
-			readBufferUsage = BufferUsageBit::kStorageFragmentRead;
+			readBufferUsage = BufferUsageBit::kUavFragmentRead;
 			prpass = &rpass;
 
 			if(enableVrs)
@@ -273,14 +273,14 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 			CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 			cmdb.bindShaderProgram(m_main.m_grProg.get());
 
-			BufferOffsetRange buff = getRenderer().getClusterBinning().getClusteredShadingUniforms();
-			cmdb.bindUniformBuffer(0, 0, buff.m_buffer, buff.m_offset, buff.m_range);
+			BufferOffsetRange buff = getRenderer().getClusterBinning().getClusteredShadingConstants();
+			cmdb.bindConstantBuffer(0, 0, buff.m_buffer, buff.m_offset, buff.m_range);
 
 			buff = getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kGlobalIlluminationProbe);
-			cmdb.bindStorageBuffer(0, 1, buff.m_buffer, buff.m_offset, buff.m_range);
+			cmdb.bindUavBuffer(0, 1, buff.m_buffer, buff.m_offset, buff.m_range);
 
 			buff = getRenderer().getClusterBinning().getClustersBuffer();
-			cmdb.bindStorageBuffer(0, 2, buff.m_buffer, buff.m_offset, buff.m_range);
+			cmdb.bindUavBuffer(0, 2, buff.m_buffer, buff.m_offset, buff.m_range);
 
 			cmdb.bindSampler(0, 3, getRenderer().getSamplers().m_trilinearClamp.get());
 			rgraphCtx.bindColorTexture(0, 4, getRenderer().getGBuffer().getColorRt(2));
@@ -292,13 +292,13 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 
 			if(g_preferComputeCVar.get())
 			{
-				rgraphCtx.bindImage(0, 10, m_runCtx.m_mainRtHandles[kWrite]);
+				rgraphCtx.bindUavTexture(0, 10, m_runCtx.m_mainRtHandles[kWrite]);
 			}
 
 			cmdb.bindAllBindless(1);
 
 			// Bind uniforms
-			IndirectDiffuseUniforms unis;
+			IndirectDiffuseConstants unis;
 			unis.m_viewportSize = getRenderer().getInternalResolution() / 2u;
 			unis.m_viewportSizef = Vec2(unis.m_viewportSize);
 			const Mat4& pmat = ctx.m_matrices.m_projection;
@@ -340,7 +340,7 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 		{
 			ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass((dir == 0) ? "IndirectDiffuseDenoiseH" : "IndirectDiffuseDenoiseV");
 			readUsage = TextureUsageBit::kSampledCompute;
-			writeUsage = TextureUsageBit::kImageComputeWrite;
+			writeUsage = TextureUsageBit::kUavComputeWrite;
 			prpass = &rpass;
 		}
 		else
@@ -366,10 +366,10 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 
 			if(g_preferComputeCVar.get())
 			{
-				rgraphCtx.bindImage(0, 3, m_runCtx.m_mainRtHandles[!readIdx]);
+				rgraphCtx.bindUavTexture(0, 3, m_runCtx.m_mainRtHandles[!readIdx]);
 			}
 
-			IndirectDiffuseDenoiseUniforms unis;
+			IndirectDiffuseDenoiseConstants unis;
 			unis.m_invertedViewProjectionJitterMat = ctx.m_matrices.m_invertedViewProjectionJitter;
 			unis.m_viewportSize = getRenderer().getInternalResolution() / 2u;
 			unis.m_viewportSizef = Vec2(unis.m_viewportSize);

AnKi/Renderer/IndirectDiffuseProbes.cpp

@@ -388,7 +388,7 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 			for(U32 f = 0; f < 6; ++f)
 			{
 				visibleLightsBuffers[f] = lightVis[f].m_visiblesBuffer;
-				pass.newBufferDependency(lightVis[f].m_visiblesBufferHandle, BufferUsageBit::kStorageFragmentRead);
+				pass.newBufferDependency(lightVis[f].m_visiblesBufferHandle, BufferUsageBit::kUavFragmentRead);
 			}
 
 			pass.newTextureDependency(lightShadingRt, TextureUsageBit::kFramebufferWrite);
@@ -466,7 +466,7 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 			ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("GI irradiance");
 
 			pass.newTextureDependency(lightShadingRt, TextureUsageBit::kSampledCompute);
-			pass.newTextureDependency(irradianceVolume, TextureUsageBit::kImageComputeWrite);
+			pass.newTextureDependency(irradianceVolume, TextureUsageBit::kUavComputeWrite);
 			for(U32 i = 0; i < kGBufferColorRenderTargetCount - 1; ++i)
 			{
 				pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kSampledCompute);
@@ -488,7 +488,7 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 					rgraphCtx.bindColorTexture(0, 2, gbufferColorRts[i], i);
 				}
 
-				rgraphCtx.bindImage(0, 3, irradianceVolume, TextureSubresourceInfo());
+				rgraphCtx.bindUavTexture(0, 3, irradianceVolume, TextureSubresourceInfo());
 
 				class
 				{

AnKi/Renderer/IndirectSpecular.cpp

@@ -47,7 +47,7 @@ Error IndirectSpecular::initInternal()
 	// Create RT
 	TextureUsageBit usage = TextureUsageBit::kAllSampled;
 
-	usage |= (preferCompute) ? TextureUsageBit::kImageComputeWrite : TextureUsageBit::kFramebufferWrite;
+	usage |= (preferCompute) ? TextureUsageBit::kUavComputeWrite : TextureUsageBit::kFramebufferWrite;
 
 	TextureInitInfo texInit = getRenderer().create2DRenderTargetInitInfo(size.x(), size.y(), getRenderer().getHdrFormat(), usage, "SSR #1");
 	m_rts[0] = getRenderer().createAndClearRenderTarget(texInit, TextureUsageBit::kAllSampled);
@@ -126,8 +126,8 @@ void IndirectSpecular::populateRenderGraph(RenderingContext& ctx)
 
 			ppass = &pass;
 			readUsage = TextureUsageBit::kSampledCompute;
-			writeUsage = TextureUsageBit::kImageComputeWrite;
-			readBufferUsage = BufferUsageBit::kStorageComputeRead;
+			writeUsage = TextureUsageBit::kUavComputeWrite;
+			readBufferUsage = BufferUsageBit::kUavComputeRead;
 		}
 		else
 		{
@@ -138,7 +138,7 @@ void IndirectSpecular::populateRenderGraph(RenderingContext& ctx)
 			ppass = &pass;
 			readUsage = TextureUsageBit::kSampledFragment;
 			writeUsage = TextureUsageBit::kFramebufferWrite;
-			readBufferUsage = BufferUsageBit::kStorageFragmentRead;
+			readBufferUsage = BufferUsageBit::kUavFragmentRead;
 
 			if(enableVrs)
 			{
@@ -178,7 +178,7 @@ void IndirectSpecular::run(const RenderingContext& ctx, RenderPassWorkContext& r
 	const U32 depthLod = min(g_ssrDepthLodCVar.get(), getRenderer().getDepthDownscale().getMipmapCount() - 1);
 
 	// Bind uniforms
-	SsrUniforms* unis = allocateAndBindUniforms<SsrUniforms>(cmdb, 0, 0);
+	SsrConstants* unis = allocateAndBindConstants<SsrConstants>(cmdb, 0, 0);
 	unis->m_depthBufferSize = getRenderer().getInternalResolution() >> (depthLod + 1);
 	unis->m_framebufferSize = UVec2(getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y()) / 2;
 	unis->m_frameCount = getRenderer().getFrameCount() & kMaxU32;
@@ -211,20 +211,20 @@ void IndirectSpecular::run(const RenderingContext& ctx, RenderPassWorkContext& r
 	cmdb.bindSampler(0, 9, getRenderer().getSamplers().m_trilinearRepeat.get());
 	cmdb.bindTexture(0, 10, &m_noiseImage->getTextureView());
 
-	BufferOffsetRange buff = getRenderer().getClusterBinning().getClusteredShadingUniforms();
-	cmdb.bindUniformBuffer(0, 11, buff.m_buffer, buff.m_offset, buff.m_range);
+	BufferOffsetRange buff = getRenderer().getClusterBinning().getClusteredShadingConstants();
+	cmdb.bindConstantBuffer(0, 11, buff.m_buffer, buff.m_offset, buff.m_range);
 
 	buff = getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kReflectionProbe);
-	cmdb.bindStorageBuffer(0, 12, buff.m_buffer, buff.m_offset, buff.m_range);
+	cmdb.bindUavBuffer(0, 12, buff.m_buffer, buff.m_offset, buff.m_range);
 
 	buff = getRenderer().getClusterBinning().getClustersBuffer();
-	cmdb.bindStorageBuffer(0, 13, buff.m_buffer, buff.m_offset, buff.m_range);
+	cmdb.bindUavBuffer(0, 13, buff.m_buffer, buff.m_offset, buff.m_range);
 
 	cmdb.bindAllBindless(1);
 
 	if(g_preferComputeCVar.get())
 	{
-		rgraphCtx.bindImage(0, 14, m_runCtx.m_rts[kWrite], TextureSubresourceInfo());
+		rgraphCtx.bindUavTexture(0, 14, m_runCtx.m_rts[kWrite], TextureSubresourceInfo());
 
 		dispatchPPCompute(cmdb, 8, 8, getRenderer().getInternalResolution().x() / 2, getRenderer().getInternalResolution().y() / 2);
 	}

AnKi/Renderer/LensFlare.cpp

@@ -80,7 +80,7 @@ void LensFlare::populateRenderGraph(RenderingContext& ctx)
 	// Create the pass
 	ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("Lens flare indirect");
 
-	rpass.newBufferDependency(m_runCtx.m_indirectBuffHandle, BufferUsageBit::kStorageComputeWrite);
+	rpass.newBufferDependency(m_runCtx.m_indirectBuffHandle, BufferUsageBit::kUavComputeWrite);
 	rpass.newTextureDependency(getRenderer().getDepthDownscale().getRt(), TextureUsageBit::kSampledCompute,
 							   DepthDownscale::kEighthInternalResolution);
 
@@ -96,14 +96,14 @@ void LensFlare::populateRenderGraph(RenderingContext& ctx)
 		cmdb.setPushConstants(&ctx.m_matrices.m_viewProjectionJitter, sizeof(ctx.m_matrices.m_viewProjectionJitter));
 
 		// Write flare info
-		Vec4* flarePositions = allocateAndBindStorage<Vec4>(cmdb, 0, 0, flareCount);
+		Vec4* flarePositions = allocateAndBindUav<Vec4>(cmdb, 0, 0, flareCount);
 		for(const LensFlareComponent& comp : SceneGraph::getSingleton().getComponentArrays().getLensFlares())
 		{
 			*flarePositions = Vec4(comp.getWorldPosition(), 1.0f);
 			++flarePositions;
 		}
 
-		rgraphCtx.bindStorageBuffer(0, 1, m_runCtx.m_indirectBuffHandle);
+		rgraphCtx.bindUavBuffer(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);
@@ -143,7 +143,7 @@ void LensFlare::runDrawFlares(const RenderingContext& ctx, CommandBuffer& cmdb)
 		U32 spritesCount = max<U32>(1, m_maxSpritesPerFlare);
 
 		// Get uniform memory
-		LensFlareSprite* tmpSprites = allocateAndBindStorage<LensFlareSprite>(cmdb, 0, 0, spritesCount);
+		LensFlareSprite* tmpSprites = allocateAndBindUav<LensFlareSprite>(cmdb, 0, 0, spritesCount);
 		WeakArray<LensFlareSprite> sprites(tmpSprites, spritesCount);
 
 		// misc

AnKi/Renderer/LightShading.cpp

@@ -151,10 +151,10 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 		cmdb.setDepthWrite(false);
 
 		// Bind all
-		cmdb.bindUniformBuffer(0, 0, getRenderer().getClusterBinning().getClusteredShadingUniforms());
-		cmdb.bindStorageBuffer(0, 1, getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kLight));
+		cmdb.bindConstantBuffer(0, 0, getRenderer().getClusterBinning().getClusteredShadingConstants());
+		cmdb.bindUavBuffer(0, 1, getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kLight));
 		rgraphCtx.bindColorTexture(0, 2, getRenderer().getShadowMapping().getShadowmapRt());
-		cmdb.bindStorageBuffer(0, 3, getRenderer().getClusterBinning().getClustersBuffer());
+		cmdb.bindUavBuffer(0, 3, getRenderer().getClusterBinning().getClustersBuffer());
 
 		cmdb.bindSampler(0, 4, getRenderer().getSamplers().m_nearestNearestClamp.get());
 		cmdb.bindSampler(0, 5, getRenderer().getSamplers().m_trilinearClamp.get());
@@ -184,7 +184,7 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 		rgraphCtx.bindColorTexture(0, 8, getRenderer().getGBuffer().getColorRt(2));
 		cmdb.bindTexture(0, 9, &getRenderer().getProbeReflections().getIntegrationLut());
 
-		cmdb.bindUniformBuffer(0, 10, getRenderer().getClusterBinning().getClusteredShadingUniforms());
+		cmdb.bindConstantBuffer(0, 10, getRenderer().getClusterBinning().getClusteredShadingConstants());
 
 		const Vec4 pc(ctx.m_cameraNear, ctx.m_cameraFar, 0.0f, 0.0f);
 		cmdb.setPushConstants(&pc, sizeof(pc));
@@ -348,9 +348,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::kStorageFragmentRead);
+	pass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kUavFragmentRead);
 	pass.newBufferDependency(getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kLight),
-							 BufferUsageBit::kStorageFragmentRead);
+							 BufferUsageBit::kUavFragmentRead);
 
 	// Apply indirect
 	pass.newTextureDependency(getRenderer().getIndirectDiffuse().getRt(), readUsage);

AnKi/Renderer/MotionVectors.cpp

@@ -43,7 +43,7 @@ Error MotionVectors::initInternal()
 	TextureUsageBit historyLengthUsage = TextureUsageBit::kAllSampled;
 	if(g_preferComputeCVar.get())
 	{
-		historyLengthUsage |= TextureUsageBit::kImageComputeWrite;
+		historyLengthUsage |= TextureUsageBit::kUavComputeWrite;
 	}
 	else
 	{
@@ -96,7 +96,7 @@ void MotionVectors::populateRenderGraph(RenderingContext& ctx)
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("MotionVectors");
 
 		readUsage = TextureUsageBit::kSampledCompute;
-		writeUsage = TextureUsageBit::kImageComputeWrite;
+		writeUsage = TextureUsageBit::kUavComputeWrite;
 		ppass = &pass;
 	}
 	else
@@ -121,14 +121,14 @@ void MotionVectors::populateRenderGraph(RenderingContext& ctx)
 		rgraphCtx.bindColorTexture(0, 3, getRenderer().getGBuffer().getColorRt(3));
 		rgraphCtx.bindColorTexture(0, 4, m_runCtx.m_historyLengthReadRtHandle);
 
-		class Uniforms
+		class Constants
 		{
 		public:
 			Mat4 m_reprojectionMat;
 			Mat4 m_viewProjectionInvMat;
 			Mat4 m_prevViewProjectionInvMat;
 		} * pc;
-		pc = allocateAndBindUniforms<Uniforms>(cmdb, 0, 5);
+		pc = allocateAndBindConstants<Constants>(cmdb, 0, 5);
 
 		pc->m_reprojectionMat = ctx.m_matrices.m_reprojection;
 		pc->m_viewProjectionInvMat = ctx.m_matrices.m_invertedViewProjectionJitter;
@@ -136,8 +136,8 @@ void MotionVectors::populateRenderGraph(RenderingContext& ctx)
 
 		if(g_preferComputeCVar.get())
 		{
-			rgraphCtx.bindImage(0, 6, m_runCtx.m_motionVectorsRtHandle, TextureSubresourceInfo());
-			rgraphCtx.bindImage(0, 7, m_runCtx.m_historyLengthWriteRtHandle, TextureSubresourceInfo());
+			rgraphCtx.bindUavTexture(0, 6, m_runCtx.m_motionVectorsRtHandle, TextureSubresourceInfo());
+			rgraphCtx.bindUavTexture(0, 7, m_runCtx.m_historyLengthWriteRtHandle, TextureSubresourceInfo());
 		}
 
 		if(g_preferComputeCVar.get())

AnKi/Renderer/ProbeReflections.cpp

@@ -150,7 +150,7 @@ Error ProbeReflections::initIrradiance()
 	// Create buff
 	{
 		BufferInitInfo init;
-		init.m_usage = BufferUsageBit::kAllStorage;
+		init.m_usage = BufferUsageBit::kAllUav;
 		init.m_size = 6 * sizeof(Vec4);
 		m_irradiance.m_diceValuesBuff = GrManager::getSingleton().newBuffer(init);
 	}
@@ -280,7 +280,7 @@ void ProbeReflections::runIrradiance(RenderPassWorkContext& rgraphCtx)
 	subresource.m_faceCount = 6;
 	rgraphCtx.bindTexture(0, 1, m_ctx.m_lightShadingRt, subresource);
 
-	cmdb.bindStorageBuffer(0, 3, m_irradiance.m_diceValuesBuff.get(), 0, m_irradiance.m_diceValuesBuff->getSize());
+	cmdb.bindUavBuffer(0, 3, m_irradiance.m_diceValuesBuff.get(), 0, m_irradiance.m_diceValuesBuff->getSize());
 
 	// Draw
 	cmdb.dispatchCompute(1, 1, 1);
@@ -301,14 +301,14 @@ void ProbeReflections::runIrradianceToRefl(RenderPassWorkContext& rgraphCtx)
 	rgraphCtx.bindColorTexture(0, 1, m_ctx.m_gbufferColorRts[1], 1);
 	rgraphCtx.bindColorTexture(0, 1, m_ctx.m_gbufferColorRts[2], 2);
 
-	cmdb.bindStorageBuffer(0, 2, m_irradiance.m_diceValuesBuff.get(), 0, m_irradiance.m_diceValuesBuff->getSize());
+	cmdb.bindUavBuffer(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.bindImage(0, 3, m_ctx.m_lightShadingRt, subresource, f);
+		rgraphCtx.bindUavTexture(0, 3, m_ctx.m_lightShadingRt, subresource, f);
 	}
 
 	dispatchPPCompute(cmdb, 8, 8, m_lightShading.m_tileSize, m_lightShading.m_tileSize);
@@ -499,7 +499,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 				runLightShading(faceIdx, visResult, viewProjMat, cascadeViewProjMat, *probeToRefresh, rgraphCtx);
 			});
 
-			pass.newBufferDependency(lightVis[faceIdx].m_visiblesBufferHandle, BufferUsageBit::kStorageFragmentRead);
+			pass.newBufferDependency(lightVis[faceIdx].m_visiblesBufferHandle, BufferUsageBit::kUavFragmentRead);
 
 			TextureSubresourceInfo subresource(TextureSurfaceInfo(0, 0, faceIdx, 0));
 			pass.newTextureDependency(m_ctx.m_lightShadingRt, TextureUsageBit::kFramebufferWrite, subresource);
@@ -533,7 +533,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 		readSubresource.m_faceCount = 6;
 		pass.newTextureDependency(m_ctx.m_lightShadingRt, TextureUsageBit::kSampledCompute, readSubresource);
 
-		pass.newBufferDependency(m_ctx.m_irradianceDiceValuesBuffHandle, BufferUsageBit::kStorageComputeWrite);
+		pass.newBufferDependency(m_ctx.m_irradianceDiceValuesBuffHandle, BufferUsageBit::kUavComputeWrite);
 	}
 
 	// Write irradiance back to refl
@@ -551,9 +551,9 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 
 		TextureSubresourceInfo subresource;
 		subresource.m_faceCount = 6;
-		pass.newTextureDependency(m_ctx.m_lightShadingRt, TextureUsageBit::kImageComputeRead | TextureUsageBit::kImageComputeWrite, subresource);
+		pass.newTextureDependency(m_ctx.m_lightShadingRt, TextureUsageBit::kUavComputeRead | TextureUsageBit::kUavComputeWrite, subresource);
 
-		pass.newBufferDependency(m_ctx.m_irradianceDiceValuesBuffHandle, BufferUsageBit::kStorageComputeRead);
+		pass.newBufferDependency(m_ctx.m_irradianceDiceValuesBuffHandle, BufferUsageBit::kUavComputeRead);
 	}
 
 	// Mipmapping "passes"

AnKi/Renderer/Renderer.cpp

@@ -163,7 +163,7 @@ Error Renderer::initInternal(UVec2 swapchainResolution)
 	{
 		TextureInitInfo texinit("RendererDummy");
 		texinit.m_width = texinit.m_height = 4;
-		texinit.m_usage = TextureUsageBit::kAllSampled | TextureUsageBit::kImageComputeWrite;
+		texinit.m_usage = TextureUsageBit::kAllSampled | TextureUsageBit::kUavComputeWrite;
 		texinit.m_format = Format::kR8G8B8A8_Unorm;
 		TexturePtr tex = createAndClearRenderTarget(texinit, TextureUsageBit::kAllSampled);
 
@@ -177,7 +177,7 @@ Error Renderer::initInternal(UVec2 swapchainResolution)
 		m_dummyTexView3d = GrManager::getSingleton().newTextureView(viewinit);
 
 		m_dummyBuff = GrManager::getSingleton().newBuffer(
-			BufferInitInfo(1024, BufferUsageBit::kAllUniform | BufferUsageBit::kAllStorage, BufferMapAccessBit::kNone, "Dummy"));
+			BufferInitInfo(1024, BufferUsageBit::kAllConstant | BufferUsageBit::kAllUav, BufferMapAccessBit::kNone, "Dummy"));
 	}
 
 	// Init the stages. Careful with the order!!!!!!!!!!
@@ -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::kImageComputeWrite));
+	ANKI_ASSERT(!!(usage & TextureUsageBit::kFramebufferWrite) || !!(usage & TextureUsageBit::kUavComputeWrite));
 	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::kImageComputeWrite));
+	ANKI_ASSERT(!!(inf.m_usage & TextureUsageBit::kFramebufferWrite) || !!(inf.m_usage & TextureUsageBit::kUavComputeWrite));
 
 	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::kImageComputeWrite))
+	else if(!!(inf.m_usage & TextureUsageBit::kUavComputeWrite))
 	{
 		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->bindImage(0, 0, view.get());
+					cmdb->bindUavTexture(0, 0, view.get());
 
-					const TextureBarrierInfo barrier = {tex.get(), TextureUsageBit::kNone, TextureUsageBit::kImageComputeWrite, surf};
+					const TextureBarrierInfo barrier = {tex.get(), TextureUsageBit::kNone, TextureUsageBit::kUavComputeWrite, 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::kImageComputeWrite, initialUsage, surf};
+						const TextureBarrierInfo barrier = {tex.get(), TextureUsageBit::kUavComputeWrite, initialUsage, surf};
 
 						cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 					}
@@ -685,7 +685,7 @@ void Renderer::gpuSceneCopy(RenderingContext& ctx)
 	if(GpuSceneMicroPatcher::getSingleton().patchingIsNeeded())
 	{
 		ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("GPU scene patching");
-		rpass.newBufferDependency(m_runCtx.m_gpuSceneHandle, BufferUsageBit::kStorageComputeWrite);
+		rpass.newBufferDependency(m_runCtx.m_gpuSceneHandle, BufferUsageBit::kUavComputeWrite);
 
 		rpass.setWork([](RenderPassWorkContext& rgraphCtx) {
 			GpuSceneMicroPatcher::getSingleton().patchGpuScene(*rgraphCtx.m_commandBuffer);

AnKi/Renderer/RendererObject.h

@@ -62,22 +62,22 @@ protected:
 	}
 
 	template<typename T>
-	static T* allocateAndBindUniforms(CommandBuffer& cmdb, U32 set, U32 binding)
+	static T* allocateAndBindConstants(CommandBuffer& cmdb, U32 set, U32 binding)
 	{
 		T* ptr;
 		const RebarAllocation alloc = RebarTransientMemoryPool::getSingleton().allocateFrame(1, ptr);
 		ANKI_ASSERT(isAligned(alignof(T), ptrToNumber(ptr)));
-		cmdb.bindUniformBuffer(set, binding, alloc);
+		cmdb.bindConstantBuffer(set, binding, alloc);
 		return ptr;
 	}
 
 	template<typename T>
-	static T* allocateAndBindStorage(CommandBuffer& cmdb, U32 set, U32 binding, U32 count = 1)
+	static T* allocateAndBindUav(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.bindStorageBuffer(set, binding, alloc);
+		cmdb.bindUavBuffer(set, binding, alloc);
 		return ptr;
 	}
 

AnKi/Renderer/RtShadows.cpp

@@ -120,7 +120,7 @@ Error RtShadows::initInternal()
 	{
 		TextureInitInfo texinit = getRenderer().create2DRenderTargetInitInfo(
 			getRenderer().getInternalResolution().x() / 2, getRenderer().getInternalResolution().y() / 2, Format::kR8_Unorm,
-			TextureUsageBit::kAllSampled | TextureUsageBit::kImageTraceRaysWrite | TextureUsageBit::kImageComputeWrite, "RtShadows History");
+			TextureUsageBit::kAllSampled | TextureUsageBit::kUavTraceRaysWrite | TextureUsageBit::kUavComputeWrite, "RtShadows History");
 		m_historyRt = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
 	}
 
@@ -135,7 +135,7 @@ Error RtShadows::initInternal()
 	{
 		TextureInitInfo texinit = getRenderer().create2DRenderTargetInitInfo(
 			getRenderer().getInternalResolution().x() / 2, getRenderer().getInternalResolution().y() / 2, Format::kR32G32_Sfloat,
-			TextureUsageBit::kAllSampled | TextureUsageBit::kImageTraceRaysWrite | TextureUsageBit::kImageComputeWrite, "RtShadows Moments #1");
+			TextureUsageBit::kAllSampled | TextureUsageBit::kUavTraceRaysWrite | TextureUsageBit::kUavComputeWrite, "RtShadows Moments #1");
 		m_momentsRts[0] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
 
 		texinit.setName("RtShadows Moments #2");
@@ -222,7 +222,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 	BufferOffsetRange sbtBuildIndirectArgsBuffer;
 	{
 		sbtBuildIndirectArgsBuffer = GpuVisibleTransientMemoryPool::getSingleton().allocate(sizeof(DispatchIndirectArgs));
-		sbtBuildIndirectArgsHandle = rgraph.importBuffer(BufferUsageBit::kStorageComputeWrite, sbtBuildIndirectArgsBuffer);
+		sbtBuildIndirectArgsHandle = rgraph.importBuffer(BufferUsageBit::kUavComputeWrite, sbtBuildIndirectArgsBuffer);
 
 		ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("RtShadows setup build SBT");
 
@@ -234,8 +234,8 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 
 			cmdb.bindShaderProgram(m_setupBuildSbtGrProg.get());
 
-			cmdb.bindStorageBuffer(0, 0, GpuSceneArrays::RenderableBoundingVolumeRt::getSingleton().getBufferOffsetRange());
-			cmdb.bindStorageBuffer(0, 1, sbtBuildIndirectArgsBuffer);
+			cmdb.bindUavBuffer(0, 0, GpuSceneArrays::RenderableBoundingVolumeRt::getSingleton().getBufferOffsetRange());
+			cmdb.bindUavBuffer(0, 1, sbtBuildIndirectArgsBuffer);
 
 			cmdb.dispatchCompute(1, 1, 1);
 		});
@@ -249,7 +249,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 		U8* sbtMem;
 		sbtBuffer = RebarTransientMemoryPool::getSingleton().allocateFrame(
 			(GpuSceneArrays::RenderableBoundingVolumeRt::getSingleton().getElementCount() + 2) * m_sbtRecordSize, sbtMem);
-		sbtHandle = rgraph.importBuffer(BufferUsageBit::kStorageComputeWrite, sbtBuffer);
+		sbtHandle = rgraph.importBuffer(BufferUsageBit::kUavComputeWrite, sbtBuffer);
 
 		// Write the first 2 entries of the SBT
 		ConstWeakArray<U8> shaderGroupHandles = m_rtLibraryGrProg->getShaderGroupHandles();
@@ -264,7 +264,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 		BufferOffsetRange visibleRenderableIndicesBuff;
 		getRenderer().getAccelerationStructureBuilder().getVisibilityInfo(visibilityHandle, visibleRenderableIndicesBuff);
 
-		rpass.newBufferDependency(visibilityHandle, BufferUsageBit::kStorageComputeRead);
+		rpass.newBufferDependency(visibilityHandle, BufferUsageBit::kUavComputeRead);
 		rpass.newBufferDependency(sbtBuildIndirectArgsHandle, BufferUsageBit::kIndirectCompute);
 
 		rpass.setWork([this, sbtBuildIndirectArgsBuffer, sbtBuffer, visibleRenderableIndicesBuff](RenderPassWorkContext& rgraphCtx) {
@@ -273,13 +273,13 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 
 			cmdb.bindShaderProgram(m_buildSbtGrProg.get());
 
-			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);
+			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);
 
-			RtShadowsSbtBuildUniforms unis = {};
+			RtShadowsSbtBuildConstants unis = {};
 			ANKI_ASSERT(m_sbtRecordSize % 4 == 0);
 			unis.m_sbtRecordDwordSize = m_sbtRecordSize / 4;
 			const U32 shaderHandleSize = GrManager::getSingleton().getDeviceCapabilities().m_shaderGroupHandleSize;
@@ -296,7 +296,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::kImageTraceRaysWrite);
+		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[0], TextureUsageBit::kUavTraceRaysWrite);
 		rpass.newAccelerationStructureDependency(getRenderer().getAccelerationStructureBuilder().getAccelerationStructureHandle(),
 												 AccelerationStructureUsageBit::kTraceRaysRead);
 		rpass.newTextureDependency(ANKI_DEPTH_DEP);
@@ -305,9 +305,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::kImageTraceRaysWrite);
+		rpass.newTextureDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kUavTraceRaysWrite);
 
-		rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kStorageTraceRaysRead);
+		rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kUavTraceRaysRead);
 
 		rpass.setWork([this, sbtBuffer](RenderPassWorkContext& rgraphCtx) {
 			ANKI_TRACE_SCOPED_EVENT(RtShadows);
@@ -317,20 +317,20 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 
 			// Allocate, set and bind global uniforms
 			{
-				MaterialGlobalUniforms* globalUniforms;
+				MaterialGlobalConstants* globalUniforms;
 				const RebarAllocation globalUniformsToken = RebarTransientMemoryPool::getSingleton().allocateFrame(1, globalUniforms);
 
 				memset(globalUniforms, 0, sizeof(*globalUniforms)); // Don't care for now
 
-				cmdb.bindUniformBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kGlobalUniforms), globalUniformsToken);
+				cmdb.bindConstantBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kGlobalConstants), globalUniformsToken);
 			}
 
 			// More globals
 			cmdb.bindAllBindless(U32(MaterialSet::kBindless));
 			cmdb.bindSampler(U32(MaterialSet::kGlobal), U32(MaterialBinding::kTrilinearRepeatSampler),
 							 getRenderer().getSamplers().m_trilinearRepeat.get());
-			cmdb.bindStorageBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kGpuScene), &GpuSceneBuffer::getSingleton().getBuffer(), 0,
-								   kMaxPtrSize);
+			cmdb.bindUavBuffer(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), \
@@ -339,12 +339,12 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 
 			constexpr U32 kSet = 2;
 
-			cmdb.bindUniformBuffer(kSet, 0, getRenderer().getClusterBinning().getClusteredShadingUniforms());
-			cmdb.bindStorageBuffer(kSet, 1, getRenderer().getClusterBinning().getClustersBuffer());
+			cmdb.bindConstantBuffer(kSet, 0, getRenderer().getClusterBinning().getClusteredShadingConstants());
+			cmdb.bindUavBuffer(kSet, 1, getRenderer().getClusterBinning().getClustersBuffer());
 
 			cmdb.bindSampler(kSet, 2, getRenderer().getSamplers().m_trilinearRepeat.get());
 
-			rgraphCtx.bindImage(kSet, 3, m_runCtx.m_intermediateShadowsRts[0]);
+			rgraphCtx.bindUavTexture(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);
@@ -353,7 +353,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.bindImage(kSet, 12, m_runCtx.m_currentMomentsRt);
+			rgraphCtx.bindUavTexture(kSet, 12, m_runCtx.m_currentMomentsRt);
 			cmdb.bindTexture(kSet, 13, &m_blueNoiseImage->getTextureView());
 
 			cmdb.traceRays(sbtBuffer.m_buffer, sbtBuffer.m_offset, m_sbtRecordSize,
@@ -377,7 +377,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 		rpass.newTextureDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kSampledCompute);
 		rpass.newTextureDependency(getRenderer().getMotionVectors().getHistoryLengthRt(), TextureUsageBit::kSampledCompute);
 
-		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[1], TextureUsageBit::kImageComputeWrite);
+		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[1], TextureUsageBit::kUavComputeWrite);
 	}
 
 	// Denoise pass vertical
@@ -394,7 +394,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 		rpass.newTextureDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kSampledCompute);
 		rpass.newTextureDependency(getRenderer().getMotionVectors().getHistoryLengthRt(), TextureUsageBit::kSampledCompute);
 
-		rpass.newTextureDependency(m_runCtx.m_historyRt, TextureUsageBit::kImageComputeWrite);
+		rpass.newTextureDependency(m_runCtx.m_historyRt, TextureUsageBit::kUavComputeWrite);
 	}
 
 	// Variance calculation pass
@@ -408,8 +408,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::kImageComputeWrite);
-		rpass.newTextureDependency(m_runCtx.m_varianceRts[1], TextureUsageBit::kImageComputeWrite);
+		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[1], TextureUsageBit::kUavComputeWrite);
+		rpass.newTextureDependency(m_runCtx.m_varianceRts[1], TextureUsageBit::kUavComputeWrite);
 
 		rpass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
 			ANKI_TRACE_SCOPED_EVENT(RtShadows);
@@ -424,8 +424,8 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 			rgraphCtx.bindColorTexture(0, 3, getRenderer().getMotionVectors().getHistoryLengthRt());
 			rgraphCtx.bindTexture(0, 4, getRenderer().getDepthDownscale().getRt(), DepthDownscale::kQuarterInternalResolution);
 
-			rgraphCtx.bindImage(0, 5, m_runCtx.m_intermediateShadowsRts[1]);
-			rgraphCtx.bindImage(0, 6, m_runCtx.m_varianceRts[1]);
+			rgraphCtx.bindUavTexture(0, 5, m_runCtx.m_intermediateShadowsRts[1]);
+			rgraphCtx.bindUavTexture(0, 6, m_runCtx.m_varianceRts[1]);
 
 			const Mat4& invProjMat = ctx.m_matrices.m_projectionJitter.getInverse();
 			cmdb.setPushConstants(&invProjMat, sizeof(invProjMat));
@@ -451,13 +451,13 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 
 			if(!lastPass)
 			{
-				rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[!readRtIdx], TextureUsageBit::kImageComputeWrite);
+				rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[!readRtIdx], TextureUsageBit::kUavComputeWrite);
 
-				rpass.newTextureDependency(m_runCtx.m_varianceRts[!readRtIdx], TextureUsageBit::kImageComputeWrite);
+				rpass.newTextureDependency(m_runCtx.m_varianceRts[!readRtIdx], TextureUsageBit::kUavComputeWrite);
 			}
 			else
 			{
-				rpass.newTextureDependency(m_runCtx.m_historyRt, TextureUsageBit::kImageComputeWrite);
+				rpass.newTextureDependency(m_runCtx.m_historyRt, TextureUsageBit::kUavComputeWrite);
 			}
 
 			rpass.setWork([this, &ctx, passIdx = i](RenderPassWorkContext& rgraphCtx) {
@@ -485,12 +485,12 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 
 				if(!lastPass)
 				{
-					rgraphCtx.bindImage(0, 5, m_runCtx.m_intermediateShadowsRts[!readRtIdx]);
-					rgraphCtx.bindImage(0, 6, m_runCtx.m_varianceRts[!readRtIdx]);
+					rgraphCtx.bindUavTexture(0, 5, m_runCtx.m_intermediateShadowsRts[!readRtIdx]);
+					rgraphCtx.bindUavTexture(0, 6, m_runCtx.m_varianceRts[!readRtIdx]);
 				}
 				else
 				{
-					rgraphCtx.bindImage(0, 5, m_runCtx.m_historyRt);
+					rgraphCtx.bindUavTexture(0, 5, m_runCtx.m_historyRt);
 				}
 
 				const Mat4& invProjMat = ctx.m_matrices.m_projectionJitter.getInverse();
@@ -509,7 +509,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::kImageComputeWrite);
+		rpass.newTextureDependency(m_runCtx.m_upscaledRt, TextureUsageBit::kUavComputeWrite);
 
 		rpass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 			ANKI_TRACE_SCOPED_EVENT(RtShadows);
@@ -520,7 +520,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 			cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp.get());
 
 			rgraphCtx.bindColorTexture(0, 1, m_runCtx.m_historyRt);
-			rgraphCtx.bindImage(0, 2, m_runCtx.m_upscaledRt);
+			rgraphCtx.bindUavTexture(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));
 
@@ -543,9 +543,9 @@ void RtShadows::runDenoise(const RenderingContext& ctx, RenderPassWorkContext& r
 	rgraphCtx.bindColorTexture(0, 4, m_runCtx.m_currentMomentsRt);
 	rgraphCtx.bindColorTexture(0, 5, getRenderer().getMotionVectors().getHistoryLengthRt());
 
-	rgraphCtx.bindImage(0, 6, (horizontal) ? m_runCtx.m_intermediateShadowsRts[1] : m_runCtx.m_historyRt);
+	rgraphCtx.bindUavTexture(0, 6, (horizontal) ? m_runCtx.m_intermediateShadowsRts[1] : m_runCtx.m_historyRt);
 
-	RtShadowsDenoiseUniforms unis;
+	RtShadowsDenoiseConstants unis;
 	unis.m_invViewProjMat = ctx.m_matrices.m_invertedViewProjectionJitter;
 	unis.m_time = F32(GlobalFrameIndex::getSingleton().m_value % 0xFFFFu);
 	cmdb.setPushConstants(&unis, sizeof(unis));

AnKi/Renderer/Scale.cpp

@@ -197,7 +197,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::kAllImage & TextureUsageBit::kAllCompute;
+		const TextureUsageBit writeUsage = TextureUsageBit::kAllUav & TextureUsageBit::kAllCompute;
 
 		pass.newTextureDependency(getRenderer().getLightShading().getRt(), readUsage);
 		pass.newTextureDependency(getRenderer().getMotionVectors().getMotionVectorsRt(), readUsage);
@@ -219,7 +219,7 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		{
 			ComputeRenderPassDescription& pass = ctx.m_renderGraphDescr.newComputeRenderPass("Scale");
 			pass.newTextureDependency(inRt, TextureUsageBit::kSampledCompute);
-			pass.newTextureDependency(outRt, TextureUsageBit::kImageComputeWrite);
+			pass.newTextureDependency(outRt, TextureUsageBit::kUavComputeWrite);
 
 			pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 				runFsrOrBilinearScaling(rgraphCtx);
@@ -256,7 +256,7 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		{
 			ComputeRenderPassDescription& pass = ctx.m_renderGraphDescr.newComputeRenderPass("Tonemap");
 			pass.newTextureDependency(inRt, TextureUsageBit::kSampledCompute);
-			pass.newTextureDependency(outRt, TextureUsageBit::kImageComputeWrite);
+			pass.newTextureDependency(outRt, TextureUsageBit::kUavComputeWrite);
 
 			pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 				runTonemapping(rgraphCtx);
@@ -290,7 +290,7 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		{
 			ComputeRenderPassDescription& pass = ctx.m_renderGraphDescr.newComputeRenderPass("Sharpen");
 			pass.newTextureDependency(inRt, TextureUsageBit::kSampledCompute);
-			pass.newTextureDependency(outRt, TextureUsageBit::kImageComputeWrite);
+			pass.newTextureDependency(outRt, TextureUsageBit::kUavComputeWrite);
 
 			pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 				runRcasSharpening(rgraphCtx);
@@ -331,7 +331,7 @@ void Scale::runFsrOrBilinearScaling(RenderPassWorkContext& rgraphCtx)
 
 	if(preferCompute)
 	{
-		rgraphCtx.bindImage(0, 2, outRt);
+		rgraphCtx.bindUavTexture(0, 2, outRt);
 	}
 
 	if(m_upscalingMethod == UpscalingMethod::kFsr)
@@ -396,7 +396,7 @@ void Scale::runRcasSharpening(RenderPassWorkContext& rgraphCtx)
 
 	if(preferCompute)
 	{
-		rgraphCtx.bindImage(0, 2, outRt);
+		rgraphCtx.bindUavTexture(0, 2, outRt);
 	}
 
 	class
@@ -464,7 +464,7 @@ void Scale::runTonemapping(RenderPassWorkContext& rgraphCtx)
 	cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
 	rgraphCtx.bindColorTexture(0, 1, inRt);
 
-	rgraphCtx.bindImage(0, 2, getRenderer().getTonemapping().getRt());
+	rgraphCtx.bindUavTexture(0, 2, getRenderer().getTonemapping().getRt());
 
 	if(preferCompute)
 	{
@@ -477,7 +477,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.bindImage(0, 3, outRt);
+		rgraphCtx.bindUavTexture(0, 3, outRt);
 
 		dispatchPPCompute(cmdb, 8, 8, getRenderer().getPostProcessResolution().x(), getRenderer().getPostProcessResolution().y());
 	}

AnKi/Renderer/ShadowMapping.cpp

@@ -195,8 +195,7 @@ void ShadowMapping::populateRenderGraph(RenderingContext& ctx)
 		TextureSubresourceInfo subresource = TextureSubresourceInfo(DepthStencilAspectBit::kDepth);
 		pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kAllFramebuffer, subresource);
 
-		pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(),
-								 BufferUsageBit::kStorageGeometryRead | BufferUsageBit::kStorageFragmentRead);
+		pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kUavGeometryRead | BufferUsageBit::kUavFragmentRead);
 
 		pass.setFramebufferInfo(m_fbDescr, {}, m_runCtx.m_rt, {}, minx, miny, width, height);
 		pass.setWork(1, [this](RenderPassWorkContext& rgraphCtx) {
@@ -637,7 +636,7 @@ BufferOffsetRange ShadowMapping::vetVisibilityPass(CString passName, const Light
 	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_someBufferHandle, BufferUsageBit::kStorageComputeWrite);
+	pass.newBufferDependency(visOut.m_someBufferHandle, BufferUsageBit::kUavComputeWrite);
 
 	pass.setWork([this, &lightc, hashBuff = visOut.m_visiblesHashBuffer, mdiBuff = visOut.m_mdiDrawCountsBuffer,
 				  clearTileIndirectArgs](RenderPassWorkContext& rpass) {
@@ -648,11 +647,11 @@ BufferOffsetRange ShadowMapping::vetVisibilityPass(CString passName, const Light
 		const UVec4 lightIndex(lightc.getGpuSceneLightAllocation().getIndex());
 		cmdb.setPushConstants(&lightIndex, sizeof(lightIndex));
 
-		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.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);
 
 		ANKI_ASSERT(RenderStateBucketContainer::getSingleton().getBucketCount(RenderingTechnique::kDepth) <= 64 && "TODO");
 		cmdb.dispatchCompute(1, 1, 1);

AnKi/Renderer/ShadowmapsResolve.cpp

@@ -77,14 +77,14 @@ void ShadowmapsResolve::populateRenderGraph(RenderingContext& ctx)
 			run(rgraphCtx);
 		});
 
-		rpass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kImageComputeWrite);
+		rpass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kUavComputeWrite);
 		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::kStorageComputeRead);
+		rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kUavComputeRead);
 		rpass.newBufferDependency(getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kLight),
-								  BufferUsageBit::kStorageComputeRead);
+								  BufferUsageBit::kUavComputeRead);
 
 		if(getRenderer().getRtShadowsEnabled())
 		{
@@ -105,9 +105,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::kStorageFragmentRead);
+		rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kUavFragmentRead);
 		rpass.newBufferDependency(getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kLight),
-								  BufferUsageBit::kStorageFragmentRead);
+								  BufferUsageBit::kUavFragmentRead);
 
 		if(getRenderer().getRtShadowsEnabled())
 		{
@@ -123,10 +123,10 @@ void ShadowmapsResolve::run(RenderPassWorkContext& rgraphCtx)
 
 	cmdb.bindShaderProgram(m_grProg.get());
 
-	cmdb.bindUniformBuffer(0, 0, getRenderer().getClusterBinning().getClusteredShadingUniforms());
-	cmdb.bindStorageBuffer(0, 1, getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kLight));
+	cmdb.bindConstantBuffer(0, 0, getRenderer().getClusterBinning().getClusteredShadingConstants());
+	cmdb.bindUavBuffer(0, 1, getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kLight));
 	rgraphCtx.bindColorTexture(0, 2, getRenderer().getShadowMapping().getShadowmapRt());
-	cmdb.bindStorageBuffer(0, 3, getRenderer().getClusterBinning().getClustersBuffer());
+	cmdb.bindUavBuffer(0, 3, getRenderer().getClusterBinning().getClustersBuffer());
 
 	cmdb.bindSampler(0, 4, getRenderer().getSamplers().m_trilinearClamp.get());
 	cmdb.bindSampler(0, 5, getRenderer().getSamplers().m_trilinearClampShadow.get());
@@ -149,7 +149,7 @@ void ShadowmapsResolve::run(RenderPassWorkContext& rgraphCtx)
 
 	if(g_preferComputeCVar.get())
 	{
-		rgraphCtx.bindImage(0, 10, m_runCtx.m_rt, TextureSubresourceInfo());
+		rgraphCtx.bindUavTexture(0, 10, m_runCtx.m_rt, TextureSubresourceInfo());
 		dispatchPPCompute(cmdb, 8, 8, m_rtDescr.m_width, m_rtDescr.m_height);
 	}
 	else

AnKi/Renderer/TemporalAA.cpp

@@ -53,7 +53,7 @@ Error TemporalAA::initInternal()
 	for(U i = 0; i < 2; ++i)
 	{
 		TextureUsageBit usage = TextureUsageBit::kSampledFragment | TextureUsageBit::kSampledCompute;
-		usage |= (g_preferComputeCVar.get()) ? TextureUsageBit::kImageComputeWrite : TextureUsageBit::kFramebufferWrite;
+		usage |= (g_preferComputeCVar.get()) ? TextureUsageBit::kUavComputeWrite : TextureUsageBit::kFramebufferWrite;
 
 		TextureInitInfo texinit = getRenderer().create2DRenderTargetInitInfo(
 			getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y(), getRenderer().getHdrFormat(), usage, "TemporalAA");
@@ -103,8 +103,8 @@ void TemporalAA::populateRenderGraph(RenderingContext& ctx)
 	{
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("TemporalAA");
 
-		pass.newTextureDependency(m_runCtx.m_renderRt, TextureUsageBit::kImageComputeWrite);
-		pass.newTextureDependency(m_runCtx.m_tonemappedRt, TextureUsageBit::kImageComputeWrite);
+		pass.newTextureDependency(m_runCtx.m_renderRt, TextureUsageBit::kUavComputeWrite);
+		pass.newTextureDependency(m_runCtx.m_tonemappedRt, TextureUsageBit::kUavComputeWrite);
 
 		readUsage = TextureUsageBit::kSampledCompute;
 
@@ -138,12 +138,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.bindImage(0, 4, getRenderer().getTonemapping().getRt());
+		rgraphCtx.bindUavTexture(0, 4, getRenderer().getTonemapping().getRt());
 
 		if(g_preferComputeCVar.get())
 		{
-			rgraphCtx.bindImage(0, 5, m_runCtx.m_renderRt, TextureSubresourceInfo());
-			rgraphCtx.bindImage(0, 6, m_runCtx.m_tonemappedRt, TextureSubresourceInfo());
+			rgraphCtx.bindUavTexture(0, 5, m_runCtx.m_renderRt, TextureSubresourceInfo());
+			rgraphCtx.bindUavTexture(0, 6, m_runCtx.m_tonemappedRt, TextureSubresourceInfo());
 
 			dispatchPPCompute(cmdb, 8, 8, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
 		}

AnKi/Renderer/Tonemapping.cpp

@@ -42,11 +42,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::kAllImage;
+	const TextureUsageBit usage = TextureUsageBit::kAllUav;
 	const TextureInitInfo texinit = getRenderer().create2DRenderTargetInitInfo(1, 1, Format::kR16G16_Sfloat, usage, "ExposureAndAvgLum1x1");
 	ClearValue clearValue;
 	clearValue.m_colorf = {0.5f, 0.5f, 0.5f, 0.5f};
-	m_exposureAndAvgLuminance1x1 = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kAllImage, clearValue);
+	m_exposureAndAvgLuminance1x1 = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kAllUav, clearValue);
 
 	return Error::kNone;
 }
@@ -54,7 +54,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::kAllImage);
+	m_runCtx.m_exposureLuminanceHandle = ctx.m_renderGraphDescr.importRenderTarget(m_exposureAndAvgLuminance1x1.get(), TextureUsageBit::kAllUav);
 }
 
 void Tonemapping::populateRenderGraph(RenderingContext& ctx)
@@ -70,7 +70,7 @@ void Tonemapping::populateRenderGraph(RenderingContext& ctx)
 		CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
 		cmdb.bindShaderProgram(m_grProg.get());
-		rgraphCtx.bindImage(0, 1, m_runCtx.m_exposureLuminanceHandle);
+		rgraphCtx.bindUavTexture(0, 1, m_runCtx.m_exposureLuminanceHandle);
 
 		TextureSubresourceInfo inputTexSubresource;
 		inputTexSubresource.m_firstMipmap = m_inputTexMip;

AnKi/Renderer/Utils/Drawer.cpp

@@ -46,7 +46,7 @@ void RenderableDrawer::setState(const RenderableDrawerArguments& args, CommandBu
 {
 	// Allocate, set and bind global uniforms
 	{
-		MaterialGlobalUniforms* globalUniforms;
+		MaterialGlobalConstants* globalUniforms;
 		const RebarAllocation globalUniformsToken = RebarTransientMemoryPool::getSingleton().allocateFrame(1, globalUniforms);
 
 		globalUniforms->m_viewProjectionMatrix = args.m_viewProjectionMatrix;
@@ -56,13 +56,13 @@ void RenderableDrawer::setState(const RenderableDrawerArguments& args, CommandBu
 		static_assert(sizeof(globalUniforms->m_cameraTransform) == sizeof(args.m_cameraTransform));
 		memcpy(&globalUniforms->m_cameraTransform, &args.m_cameraTransform, sizeof(args.m_cameraTransform));
 
-		cmdb.bindUniformBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kGlobalUniforms), globalUniformsToken);
+		cmdb.bindConstantBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kGlobalConstants), globalUniformsToken);
 	}
 
 	// More globals
 	cmdb.bindAllBindless(U32(MaterialSet::kBindless));
 	cmdb.bindSampler(U32(MaterialSet::kGlobal), U32(MaterialBinding::kTrilinearRepeatSampler), args.m_sampler);
-	cmdb.bindStorageBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kGpuScene), &GpuSceneBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize);
+	cmdb.bindUavBuffer(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), \
@@ -125,10 +125,10 @@ void RenderableDrawer::drawMdi(const RenderableDrawerArguments& args, CommandBuf
 		cmdb.pushDebugMarker("Draw stats", Vec3(0.0f, 1.0f, 0.0f));
 
 		cmdb.bindShaderProgram(m_stats.m_updateStatsGrProgs[variant].get());
-		cmdb.bindStorageBuffer(0, 0, m_stats.m_statsBuffer, m_stats.m_statsBufferOffset, sizeof(U32));
-		cmdb.bindStorageBuffer(0, 1, threadCountBuff);
-		cmdb.bindStorageBuffer(0, 2, args.m_mdiDrawCountsBuffer);
-		cmdb.bindStorageBuffer(0, 3, m_stats.m_passCountBuffer);
+		cmdb.bindUavBuffer(0, 0, m_stats.m_statsBuffer, m_stats.m_statsBufferOffset, sizeof(U32));
+		cmdb.bindUavBuffer(0, 1, threadCountBuff);
+		cmdb.bindUavBuffer(0, 2, args.m_mdiDrawCountsBuffer);
+		cmdb.bindUavBuffer(0, 3, m_stats.m_passCountBuffer);
 
 		cmdb.draw(PrimitiveTopology::kTriangles, 6);
 

AnKi/Renderer/Utils/GpuVisibility.cpp

@@ -136,13 +136,13 @@ void GpuVisibility::populateRenderGraphInternal(Bool distanceBased, BaseGpuVisib
 	if(in.m_hashVisibles)
 	{
 		counterMemory += sizeof(GpuVisibilityHash);
-		alignRoundUp(GrManager::getSingleton().getDeviceCapabilities().m_storageBufferBindOffsetAlignment, counterMemory);
+		alignRoundUp(GrManager::getSingleton().getDeviceCapabilities().m_uavBufferBindOffsetAlignment, counterMemory);
 	}
 
 	const PtrSize mdiBufferOffset = counterMemory;
 	const PtrSize mdiBufferSize = sizeof(U32) * bucketCount;
 	counterMemory += mdiBufferSize;
-	alignRoundUp(GrManager::getSingleton().getDeviceCapabilities().m_storageBufferBindOffsetAlignment, counterMemory);
+	alignRoundUp(GrManager::getSingleton().getDeviceCapabilities().m_uavBufferBindOffsetAlignment, counterMemory);
 
 	const BufferOffsetRange counterBuffer = GpuVisibleTransientMemoryPool::getSingleton().allocate(counterMemory);
 	const BufferHandle counterBufferHandle = in.m_rgraph->importBuffer(BufferUsageBit::kNone, counterBuffer);
@@ -174,8 +174,8 @@ void GpuVisibility::populateRenderGraphInternal(Bool distanceBased, BaseGpuVisib
 	// Create the renderpass
 	ComputeRenderPassDescription& pass = in.m_rgraph->newComputeRenderPass(in.m_passesName);
 
-	pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kStorageComputeRead);
-	pass.newBufferDependency(counterBufferHandle, BufferUsageBit::kStorageComputeWrite);
+	pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kUavComputeRead);
+	pass.newBufferDependency(counterBufferHandle, BufferUsageBit::kUavComputeWrite);
 
 	if(!distanceBased && static_cast<FrustumGpuVisibilityInput&>(in).m_hzbRt)
 	{
@@ -217,13 +217,13 @@ void GpuVisibility::populateRenderGraphInternal(Bool distanceBased, BaseGpuVisib
 			ANKI_ASSERT(0);
 		}
 
-		cmdb.bindStorageBuffer(0, 0, aabbsBuffer);
-		cmdb.bindStorageBuffer(0, 1, GpuSceneArrays::Renderable::getSingleton().getBufferOffsetRange());
-		cmdb.bindStorageBuffer(0, 2, &GpuSceneBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize);
-		cmdb.bindStorageBuffer(0, 3, instanceRateRenderables);
-		cmdb.bindStorageBuffer(0, 4, indirectArgs);
+		cmdb.bindUavBuffer(0, 0, aabbsBuffer);
+		cmdb.bindUavBuffer(0, 1, GpuSceneArrays::Renderable::getSingleton().getBufferOffsetRange());
+		cmdb.bindUavBuffer(0, 2, &GpuSceneBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize);
+		cmdb.bindUavBuffer(0, 3, instanceRateRenderables);
+		cmdb.bindUavBuffer(0, 4, indirectArgs);
 
-		U32* offsets = allocateAndBindStorage<U32>(cmdb, 0, 5, RenderStateBucketContainer::getSingleton().getBucketCount(technique));
+		U32* offsets = allocateAndBindUav<U32>(cmdb, 0, 5, RenderStateBucketContainer::getSingleton().getBucketCount(technique));
 		U32 bucketCount = 0;
 		U32 userCount = 0;
 		RenderStateBucketContainer::getSingleton().iterateBuckets(technique, [&](const RenderStateInfo&, U32 userCount_) {
@@ -233,11 +233,11 @@ void GpuVisibility::populateRenderGraphInternal(Bool distanceBased, BaseGpuVisib
 		});
 		ANKI_ASSERT(userCount == RenderStateBucketContainer::getSingleton().getBucketsItemCount(technique));
 
-		cmdb.bindStorageBuffer(0, 6, mdiDrawCountsBuffer);
+		cmdb.bindUavBuffer(0, 6, mdiDrawCountsBuffer);
 
 		if(frustumTestData)
 		{
-			FrustumGpuVisibilityUniforms* unis = allocateAndBindUniforms<FrustumGpuVisibilityUniforms>(cmdb, 0, 7);
+			FrustumGpuVisibilityConstants* unis = allocateAndBindConstants<FrustumGpuVisibilityConstants>(cmdb, 0, 7);
 
 			Array<Plane, 6> planes;
 			extractClipPlanes(frustumTestData->m_viewProjMat, planes);
@@ -263,7 +263,7 @@ void GpuVisibility::populateRenderGraphInternal(Bool distanceBased, BaseGpuVisib
 		}
 		else
 		{
-			DistanceGpuVisibilityUniforms unis;
+			DistanceGpuVisibilityConstants unis;
 			unis.m_pointOfTest = distTestData->m_pointOfTest;
 			unis.m_testRadius = distTestData->m_testRadius;
 
@@ -279,12 +279,12 @@ void GpuVisibility::populateRenderGraphInternal(Bool distanceBased, BaseGpuVisib
 
 		if(gatherAabbIndices)
 		{
-			cmdb.bindStorageBuffer(0, 12, visibleAabbsBuffer);
+			cmdb.bindUavBuffer(0, 12, visibleAabbsBuffer);
 		}
 
 		if(genHash)
 		{
-			cmdb.bindStorageBuffer(0, 13, hashBuffer);
+			cmdb.bindUavBuffer(0, 13, hashBuffer);
 		}
 
 		dispatchPPCompute(cmdb, 64, 1, aabbCount, 1);
@@ -376,8 +376,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_storageBufferBindOffsetAlignment,
-														   U32(kCountersPerDispatch * sizeof(U32)));
+	const U32 counterBufferElementSize =
+		getAlignedRoundUp(GrManager::getSingleton().getDeviceCapabilities().m_uavBufferBindOffsetAlignment, 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
@@ -385,7 +385,7 @@ void GpuVisibilityNonRenderables::populateRenderGraph(GpuVisibilityNonRenderable
 		BufferInitInfo buffInit("GpuVisibilityNonRenderablesCounters");
 		buffInit.m_size = (m_counterBuffer.isCreated()) ? m_counterBuffer->getSize() * 2
 														: kCountersPerDispatch * counterBufferElementSize * kInitialCounterArraySize;
-		buffInit.m_usage = BufferUsageBit::kStorageComputeWrite | BufferUsageBit::kStorageComputeRead | BufferUsageBit::kTransferDestination;
+		buffInit.m_usage = BufferUsageBit::kUavComputeWrite | BufferUsageBit::kUavComputeRead | BufferUsageBit::kTransferDestination;
 		m_counterBuffer = GrManager::getSingleton().newBuffer(buffInit);
 
 		m_counterBufferZeroingHandle = rgraph.importBuffer(m_counterBuffer.get(), buffInit.m_usage, 0, kMaxPtrSize);
@@ -412,8 +412,8 @@ void GpuVisibilityNonRenderables::populateRenderGraph(GpuVisibilityNonRenderable
 	// Create the renderpass
 	ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass(in.m_passesName);
 
-	pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kStorageComputeRead);
-	pass.newBufferDependency(out.m_visiblesBufferHandle, BufferUsageBit::kStorageComputeWrite);
+	pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kUavComputeRead);
+	pass.newBufferDependency(out.m_visiblesBufferHandle, BufferUsageBit::kUavComputeWrite);
 
 	if(in.m_hzbRt)
 	{
@@ -422,7 +422,7 @@ void GpuVisibilityNonRenderables::populateRenderGraph(GpuVisibilityNonRenderable
 
 	if(m_counterBufferZeroingHandle.isValid()) [[unlikely]]
 	{
-		pass.newBufferDependency(m_counterBufferZeroingHandle, BufferUsageBit::kStorageComputeRead | BufferUsageBit::kStorageComputeWrite);
+		pass.newBufferDependency(m_counterBufferZeroingHandle, BufferUsageBit::kUavComputeRead | BufferUsageBit::kUavComputeWrite);
 	}
 
 	pass.setWork([this, objType = in.m_objectType, feedbackBuffer = in.m_cpuFeedbackBuffer, viewProjectionMat = in.m_viewProjectionMat,
@@ -455,9 +455,9 @@ void GpuVisibilityNonRenderables::populateRenderGraph(GpuVisibilityNonRenderable
 		default:
 			ANKI_ASSERT(0);
 		}
-		cmdb.bindStorageBuffer(0, 0, objBuffer);
+		cmdb.bindUavBuffer(0, 0, objBuffer);
 
-		GpuVisibilityNonRenderableUniforms unis;
+		GpuVisibilityNonRenderableConstants unis;
 		Array<Plane, 6> planes;
 		extractClipPlanes(viewProjectionMat, planes);
 		for(U32 i = 0; i < 6; ++i)
@@ -466,12 +466,12 @@ void GpuVisibilityNonRenderables::populateRenderGraph(GpuVisibilityNonRenderable
 		}
 		cmdb.setPushConstants(&unis, sizeof(unis));
 
-		rgraph.bindStorageBuffer(0, 1, visibleIndicesBuffHandle);
-		cmdb.bindStorageBuffer(0, 2, counterBuffer.get(), counterBufferOffset, sizeof(U32) * kCountersPerDispatch);
+		rgraph.bindUavBuffer(0, 1, visibleIndicesBuffHandle);
+		cmdb.bindUavBuffer(0, 2, counterBuffer.get(), counterBufferOffset, sizeof(U32) * kCountersPerDispatch);
 
 		if(needsFeedback)
 		{
-			cmdb.bindStorageBuffer(0, 3, feedbackBuffer.m_buffer, feedbackBuffer.m_offset, feedbackBuffer.m_range);
+			cmdb.bindUavBuffer(0, 3, feedbackBuffer.m_buffer, feedbackBuffer.m_offset, feedbackBuffer.m_range);
 		}
 
 		dispatchPPCompute(cmdb, 64, 1, objCount, 1);
@@ -486,7 +486,7 @@ Error GpuVisibilityAccelerationStructures::init()
 
 	BufferInitInfo inf("GpuVisibilityAccelerationStructuresCounters");
 	inf.m_size = sizeof(U32) * 2;
-	inf.m_usage = BufferUsageBit::kStorageComputeWrite | BufferUsageBit::kStorageComputeRead | BufferUsageBit::kTransferDestination;
+	inf.m_usage = BufferUsageBit::kUavComputeWrite | BufferUsageBit::kUavComputeRead | BufferUsageBit::kTransferDestination;
 	m_counterBuffer = GrManager::getSingleton().newBuffer(inf);
 
 	zeroBuffer(m_counterBuffer.get());
@@ -509,7 +509,7 @@ void GpuVisibilityAccelerationStructures::pupulateRenderGraph(GpuVisibilityAccel
 	const U32 aabbCount = GpuSceneArrays::RenderableBoundingVolumeRt::getSingleton().getElementCount();
 
 	out.m_instancesBuffer = GpuVisibleTransientMemoryPool::getSingleton().allocate(aabbCount * sizeof(AccelerationStructureInstance));
-	out.m_someBufferHandle = rgraph.importBuffer(BufferUsageBit::kStorageComputeWrite, out.m_instancesBuffer);
+	out.m_someBufferHandle = rgraph.importBuffer(BufferUsageBit::kUavComputeWrite, out.m_instancesBuffer);
 
 	out.m_renderableIndicesBuffer = GpuVisibleTransientMemoryPool::getSingleton().allocate((aabbCount + 1) * sizeof(U32));
 
@@ -519,8 +519,8 @@ void GpuVisibilityAccelerationStructures::pupulateRenderGraph(GpuVisibilityAccel
 	{
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass(in.m_passesName);
 
-		pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kStorageComputeRead);
-		pass.newBufferDependency(out.m_someBufferHandle, BufferUsageBit::kStorageComputeWrite);
+		pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kUavComputeRead);
+		pass.newBufferDependency(out.m_someBufferHandle, BufferUsageBit::kUavComputeWrite);
 
 		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,
@@ -529,7 +529,7 @@ void GpuVisibilityAccelerationStructures::pupulateRenderGraph(GpuVisibilityAccel
 
 			cmdb.bindShaderProgram(m_visibilityGrProg.get());
 
-			GpuVisibilityAccelerationStructuresUniforms unis;
+			GpuVisibilityAccelerationStructuresConstants unis;
 			Array<Plane, 6> planes;
 			extractClipPlanes(viewProjMat, planes);
 			for(U32 i = 0; i < 6; ++i)
@@ -548,13 +548,13 @@ void GpuVisibilityAccelerationStructures::pupulateRenderGraph(GpuVisibilityAccel
 
 			cmdb.setPushConstants(&unis, sizeof(unis));
 
-			cmdb.bindStorageBuffer(0, 0, GpuSceneArrays::RenderableBoundingVolumeRt::getSingleton().getBufferOffsetRange());
-			cmdb.bindStorageBuffer(0, 1, GpuSceneArrays::Renderable::getSingleton().getBufferOffsetRange());
-			cmdb.bindStorageBuffer(0, 2, &GpuSceneBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize);
-			cmdb.bindStorageBuffer(0, 3, instancesBuff);
-			cmdb.bindStorageBuffer(0, 4, indicesBuff);
-			cmdb.bindStorageBuffer(0, 5, m_counterBuffer.get(), 0, sizeof(U32) * 2);
-			cmdb.bindStorageBuffer(0, 6, zeroInstancesDispatchArgsBuff);
+			cmdb.bindUavBuffer(0, 0, GpuSceneArrays::RenderableBoundingVolumeRt::getSingleton().getBufferOffsetRange());
+			cmdb.bindUavBuffer(0, 1, GpuSceneArrays::Renderable::getSingleton().getBufferOffsetRange());
+			cmdb.bindUavBuffer(0, 2, &GpuSceneBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize);
+			cmdb.bindUavBuffer(0, 3, instancesBuff);
+			cmdb.bindUavBuffer(0, 4, indicesBuff);
+			cmdb.bindUavBuffer(0, 5, m_counterBuffer.get(), 0, sizeof(U32) * 2);
+			cmdb.bindUavBuffer(0, 6, zeroInstancesDispatchArgsBuff);
 
 			const U32 aabbCount = GpuSceneArrays::RenderableBoundingVolumeRt::getSingleton().getElementCount();
 			dispatchPPCompute(cmdb, 64, 1, aabbCount, 1);
@@ -568,7 +568,7 @@ void GpuVisibilityAccelerationStructures::pupulateRenderGraph(GpuVisibilityAccel
 
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass(passName.getBegin());
 
-		pass.newBufferDependency(out.m_someBufferHandle, BufferUsageBit::kStorageComputeWrite);
+		pass.newBufferDependency(out.m_someBufferHandle, BufferUsageBit::kUavComputeWrite);
 
 		pass.setWork([this, zeroInstancesDispatchArgsBuff, instancesBuff = out.m_instancesBuffer,
 					  indicesBuff = out.m_renderableIndicesBuffer](RenderPassWorkContext& rgraph) {
@@ -576,8 +576,8 @@ void GpuVisibilityAccelerationStructures::pupulateRenderGraph(GpuVisibilityAccel
 
 			cmdb.bindShaderProgram(m_zeroRemainingInstancesGrProg.get());
 
-			cmdb.bindStorageBuffer(0, 0, indicesBuff);
-			cmdb.bindStorageBuffer(0, 1, instancesBuff);
+			cmdb.bindUavBuffer(0, 0, indicesBuff);
+			cmdb.bindUavBuffer(0, 1, instancesBuff);
 
 			cmdb.dispatchComputeIndirect(zeroInstancesDispatchArgsBuff.m_buffer, zeroInstancesDispatchArgsBuff.m_offset);
 		});

AnKi/Renderer/Utils/HzbGenerator.cpp

@@ -58,10 +58,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_storageBufferBindOffsetAlignment);
+	m_counterBufferElementSize = max<U32>(sizeof(U32), GrManager::getSingleton().getDeviceCapabilities().m_uavBufferBindOffsetAlignment);
 	BufferInitInfo buffInit("HzbCounterBuffer");
 	buffInit.m_size = m_counterBufferElementSize * kCounterBufferElementCount;
-	buffInit.m_usage = BufferUsageBit::kStorageComputeWrite | BufferUsageBit::kTransferDestination;
+	buffInit.m_usage = BufferUsageBit::kUavComputeWrite | BufferUsageBit::kTransferDestination;
 	m_counterBuffer = GrManager::getSingleton().newBuffer(buffInit);
 
 	// Zero counter buffer
@@ -122,7 +122,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::kImageComputeWrite);
+		pass.newTextureDependency(dispatchInputs[i].m_dstHzbRt, TextureUsageBit::kUavComputeWrite);
 
 		dispatchInputsCopy[i] = dispatchInputs[i];
 	}
@@ -148,7 +148,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 Uniforms
+			struct Constants
 			{
 				Vec2 m_invSrcTexSize;
 				U32 m_threadGroupCount;
@@ -173,10 +173,10 @@ void HzbGenerator::populateRenderGraphInternal(ConstWeakArray<DispatchInput> dis
 					subresource.m_firstMipmap = 0; // Put something random
 				}
 
-				rgraphCtx.bindImage(0, 0, in.m_dstHzbRt, subresource, mip);
+				rgraphCtx.bindUavTexture(0, 0, in.m_dstHzbRt, subresource, mip);
 			}
 
-			cmdb.bindStorageBuffer(0, 1, m_counterBuffer.get(), (firstCounterBufferElement + dispatch) * m_counterBufferElementSize, sizeof(U32));
+			cmdb.bindUavBuffer(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);
@@ -215,14 +215,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::kImageComputeWrite);
+		pass.newTextureDependency(maxDepthRt, TextureUsageBit::kUavComputeWrite);
 
 		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.bindImage(0, 2, maxDepthRt);
+			rgraphCtx.bindUavTexture(0, 2, maxDepthRt);
 
 			cmdb.bindShaderProgram(m_maxDepthGrProg.get());
 
@@ -292,7 +292,7 @@ void HzbGenerator::populateRenderGraphDirectionalLight(const HzbDirectionalLight
 
 			rgraphCtx.bindColorTexture(0, 0, maxDepthRt);
 
-			struct Uniforms
+			struct Constants
 			{
 				Mat4 m_reprojectionMat;
 

AnKi/Renderer/Utils/TraditionalDeferredShading.cpp

@@ -84,7 +84,7 @@ void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShading
 			cmdb.bindTexture(0, 3, &skyc->getImageResource().getTextureView());
 		}
 
-		TraditionalDeferredSkyboxUniforms unis;
+		TraditionalDeferredSkyboxConstants unis;
 		unis.m_solidColor = (isSolidColor) ? skyc->getSolidColor() : Vec3(0.0f);
 		unis.m_inputTexUvBias = info.m_gbufferTexCoordsBias;
 		unis.m_inputTexUvScale = info.m_gbufferTexCoordsScale;
@@ -99,7 +99,7 @@ void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShading
 	{
 		const LightComponent* dirLightc = SceneGraph::getSingleton().getDirectionalLight();
 
-		TraditionalDeferredShadingUniforms* unis = allocateAndBindUniforms<TraditionalDeferredShadingUniforms>(cmdb, 0, 0);
+		TraditionalDeferredShadingConstants* unis = allocateAndBindConstants<TraditionalDeferredShadingConstants>(cmdb, 0, 0);
 
 		unis->m_inputTexUvScale = info.m_gbufferTexCoordsScale;
 		unis->m_inputTexUvBias = info.m_gbufferTexCoordsBias;
@@ -121,15 +121,15 @@ void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShading
 			unis->m_dirLight.m_active = 0;
 		}
 
-		cmdb.bindStorageBuffer(0, 1, info.m_visibleLightsBuffer.m_buffer, info.m_visibleLightsBuffer.m_offset, info.m_visibleLightsBuffer.m_range);
+		cmdb.bindUavBuffer(0, 1, info.m_visibleLightsBuffer.m_buffer, info.m_visibleLightsBuffer.m_offset, info.m_visibleLightsBuffer.m_range);
 		if(GpuSceneArrays::Light::getSingleton().getElementCount() > 0)
 		{
-			cmdb.bindStorageBuffer(0, 2, GpuSceneArrays::Light::getSingleton().getBufferOffsetRange());
+			cmdb.bindUavBuffer(0, 2, GpuSceneArrays::Light::getSingleton().getBufferOffsetRange());
 		}
 		else
 		{
 			// Set something random
-			cmdb.bindStorageBuffer(0, 2, GpuSceneBuffer::getSingleton().getBufferOffsetRange());
+			cmdb.bindUavBuffer(0, 2, GpuSceneBuffer::getSingleton().getBufferOffsetRange());
 		}
 
 		// NOTE: Use nearest sampler because we don't want the result to sample the near tiles

AnKi/Renderer/VolumetricFog.cpp

@@ -56,7 +56,7 @@ void VolumetricFog::populateRenderGraph(RenderingContext& ctx)
 
 	ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("Vol fog");
 
-	pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kImageComputeWrite);
+	pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kUavComputeWrite);
 	pass.newTextureDependency(getRenderer().getVolumetricLightingAccumulation().getRt(), TextureUsageBit::kSampledCompute);
 
 	pass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
@@ -68,11 +68,11 @@ void VolumetricFog::populateRenderGraph(RenderingContext& ctx)
 		cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp.get());
 		rgraphCtx.bindColorTexture(0, 1, getRenderer().getVolumetricLightingAccumulation().getRt());
 
-		rgraphCtx.bindImage(0, 2, m_runCtx.m_rt, TextureSubresourceInfo());
+		rgraphCtx.bindUavTexture(0, 2, m_runCtx.m_rt, TextureSubresourceInfo());
 
 		const SkyboxComponent* sky = SceneGraph::getSingleton().getSkybox();
 
-		VolumetricFogUniforms regs;
+		VolumetricFogConstants 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

@@ -56,7 +56,7 @@ Error VolumetricLightingAccumulation::init()
 
 	// Create RTs
 	TextureInitInfo texinit = getRenderer().create2DRenderTargetInitInfo(m_volumeSize[0], m_volumeSize[1], Format::kR16G16B16A16_Sfloat,
-																		 TextureUsageBit::kImageComputeRead | TextureUsageBit::kImageComputeWrite
+																		 TextureUsageBit::kUavComputeRead | TextureUsageBit::kUavComputeWrite
 																			 | TextureUsageBit::kSampledFragment | TextureUsageBit::kSampledCompute,
 																		 "VolLight");
 	texinit.m_depth = m_volumeSize[2];
@@ -80,17 +80,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::kImageComputeWrite);
+	pass.newTextureDependency(m_runCtx.m_rts[1], TextureUsageBit::kUavComputeWrite);
 	pass.newTextureDependency(getRenderer().getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledCompute);
 
-	pass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kStorageComputeRead);
+	pass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kUavComputeRead);
 	pass.newBufferDependency(getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kLight),
-							 BufferUsageBit::kStorageComputeRead);
+							 BufferUsageBit::kUavComputeRead);
 	pass.newBufferDependency(
 		getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kGlobalIlluminationProbe),
-		BufferUsageBit::kStorageComputeRead);
+		BufferUsageBit::kUavComputeRead);
 	pass.newBufferDependency(getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kFogDensityVolume),
-							 BufferUsageBit::kStorageComputeRead);
+							 BufferUsageBit::kUavComputeRead);
 
 	if(getRenderer().getIndirectDiffuseProbes().hasCurrentlyRefreshedVolumeRt())
 	{
@@ -108,25 +108,24 @@ void VolumetricLightingAccumulation::populateRenderGraph(RenderingContext& ctx)
 		cmdb.bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
 		cmdb.bindSampler(0, 2, getRenderer().getSamplers().m_trilinearClampShadow.get());
 
-		rgraphCtx.bindImage(0, 3, m_runCtx.m_rts[1], TextureSubresourceInfo());
+		rgraphCtx.bindUavTexture(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.bindUniformBuffer(0, 6, getRenderer().getClusterBinning().getClusteredShadingUniforms());
-		cmdb.bindStorageBuffer(0, 7, getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kLight));
+		cmdb.bindConstantBuffer(0, 6, getRenderer().getClusterBinning().getClusteredShadingConstants());
+		cmdb.bindUavBuffer(0, 7, getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kLight));
 		rgraphCtx.bindColorTexture(0, 8, getRenderer().getShadowMapping().getShadowmapRt());
-		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.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.bindAllBindless(1);
 
 		const SkyboxComponent* sky = SceneGraph::getSingleton().getSkybox();
 
-		VolumetricLightingUniforms unis;
+		VolumetricLightingConstants 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::kImageComputeWrite | TextureUsageBit::kAllSampled;
+	const TextureUsageBit texUsage = TextureUsageBit::kFramebufferShadingRate | TextureUsageBit::kUavComputeWrite | TextureUsageBit::kAllSampled;
 	TextureInitInfo sriInitInfo = getRenderer().create2DRenderTargetInitInfo(rez.x(), rez.y(), Format::kR8_Uint, texUsage, "VrsSri");
 	m_sriTex = getRenderer().createAndClearRenderTarget(sriInitInfo, TextureUsageBit::kFramebufferShadingRate);
 
@@ -138,7 +138,7 @@ void VrsSriGeneration::populateRenderGraph(RenderingContext& ctx)
 	{
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("VRS SRI generation");
 
-		pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kImageComputeWrite);
+		pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kUavComputeWrite);
 		pass.newTextureDependency(getRenderer().getLightShading().getRt(), TextureUsageBit::kSampledCompute);
 
 		pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
@@ -149,7 +149,7 @@ void VrsSriGeneration::populateRenderGraph(RenderingContext& ctx)
 
 			rgraphCtx.bindColorTexture(0, 0, getRenderer().getLightShading().getRt());
 			cmdb.bindSampler(0, 1, getRenderer().getSamplers().m_nearestNearestClamp.get());
-			rgraphCtx.bindImage(0, 2, m_runCtx.m_rt);
+			rgraphCtx.bindUavTexture(0, 2, m_runCtx.m_rt);
 			const Vec4 pc(1.0f / Vec2(getRenderer().getInternalResolution()), g_vrsThresholdCVar.get(), 0.0f);
 			cmdb.setPushConstants(&pc, sizeof(pc));
 
@@ -164,7 +164,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::kImageComputeWrite);
+		pass.newTextureDependency(m_runCtx.m_downscaledRt, TextureUsageBit::kUavComputeWrite);
 
 		pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 			ANKI_TRACE_SCOPED_EVENT(VrsSriGeneration);
@@ -176,7 +176,7 @@ void VrsSriGeneration::populateRenderGraph(RenderingContext& ctx)
 
 			rgraphCtx.bindColorTexture(0, 0, m_runCtx.m_rt);
 			cmdb.bindSampler(0, 1, getRenderer().getSamplers().m_nearestNearestClamp.get());
-			rgraphCtx.bindImage(0, 2, m_runCtx.m_downscaledRt);
+			rgraphCtx.bindUavTexture(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

@@ -226,7 +226,7 @@ Error MaterialResource::createVars(Program& prog)
 	const ShaderProgramBinaryStruct* localUniformsStruct = nullptr;
 	for(const ShaderProgramBinaryStruct& strct : binary.m_structs)
 	{
-		if(CString(strct.m_name.getBegin()) == "AnKiLocalUniforms")
+		if(CString(strct.m_name.getBegin()) == "AnKiLocalConstants")
 		{
 			localUniformsStruct = &strct;
 			break;
@@ -291,7 +291,7 @@ Error MaterialResource::createVars(Program& prog)
 			else
 			{
 				// Check that there are no other vars that overlap with the current var. This could happen if
-				// different programs have different signature for AnKiLocalUniforms
+				// different programs have different signature for AnKiLocalConstants
 				for(const MaterialVariable& otherVar : m_vars)
 				{
 					if(!otherVar.isUniform())
@@ -306,7 +306,7 @@ Error MaterialResource::createVars(Program& prog)
 
 					if((aVarOffset <= bVarOffset && aVarEnd > bVarOffset) || (bVarOffset <= aVarOffset && bVarEnd > aVarOffset))
 					{
-						ANKI_RESOURCE_LOGE("Member %s in AnKiLocalUniforms overlaps with %s. Check your shaders", memberName.cstr(),
+						ANKI_RESOURCE_LOGE("Member %s in AnKiLocalConstants overlaps with %s. Check your shaders", memberName.cstr(),
 										   otherVar.m_name.cstr());
 						return Error::kUserData;
 					}

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::kImageComputeWrite | TextureUsageBit::kImageComputeRead;
+		texInit.m_usage = TextureUsageBit::kAllSampled | TextureUsageBit::kUavComputeWrite | TextureUsageBit::kUavComputeRead;
 
 		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::kImageComputeWrite;
+		texBarrier.m_nextUsage = TextureUsageBit::kUavComputeWrite;
 		texBarrier.m_texture = m_volTex.get();
 		cmdb->setPipelineBarrier({&texBarrier, 1}, {}, {});
 
 		cmdb->bindShaderProgram(&variant->getProgram());
-		cmdb->bindImage(0, 0, m_volView.get());
+		cmdb->bindUavTexture(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::kImageComputeWrite;
+		texBarrier.m_previousUsage = TextureUsageBit::kUavComputeWrite;
 		texBarrier.m_nextUsage = m_volTex->getTextureUsage();
 		cmdb->setPipelineBarrier({&texBarrier, 1}, {}, {});
 

AnKi/Scene/Components/ModelComponent.cpp

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

AnKi/Scene/Components/ParticleEmitterComponent.cpp

@@ -399,7 +399,7 @@ Error ParticleEmitterComponent::update(SceneComponentUpdateInfo& info, Bool& upd
 		// Upload the GpuSceneRenderable
 		GpuSceneRenderable renderable;
 		renderable.m_boneTransformsOffset = 0;
-		renderable.m_uniformsOffset = m_gpuSceneUniforms.getOffset();
+		renderable.m_constantsOffset = m_gpuSceneUniforms.getOffset();
 		renderable.m_meshLodsOffset = m_gpuSceneMeshLods.getGpuSceneOffset();
 		renderable.m_particleEmitterOffset = m_gpuSceneParticleEmitter.getGpuSceneOffset();
 		renderable.m_worldTransformsOffset = 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::kImageComputeWrite | TextureUsageBit::kImageComputeRead
+	texInit.m_usage = TextureUsageBit::kAllSampled | TextureUsageBit::kUavComputeWrite | TextureUsageBit::kUavComputeRead
 					  | 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_storageBufferBindOffsetAlignment;
+	const U32 alignment = GrManager::getSingleton().getDeviceCapabilities().m_uavBufferBindOffsetAlignment;
 	m_gpuSceneAllocation = GpuSceneBuffer::getSingleton().allocate(sizeof(TGpuSceneObject) * maxArraySize, alignment);
 
 	m_inUseIndicesMask.resize(maxArraySize / sizeof(SubMask), false);

AnKi/Shaders/Blit.hlsl

@@ -17,13 +17,13 @@
 #if USE_COMPUTE
 [[vk::binding(2)]] RWTexture2D<RVec4> g_outUav;
 
-struct Uniforms
+struct Constants
 {
 	Vec2 m_viewportSize;
 	UVec2 m_viewportSizeU;
 };
 
-[[vk::push_constant]] ConstantBuffer<Uniforms> g_pc;
+[[vk::push_constant]] ConstantBuffer<Constants> g_pc;
 #endif
 
 #if USE_COMPUTE

AnKi/Shaders/Bloom.hlsl

@@ -13,12 +13,12 @@ ANKI_SPECIALIZATION_CONSTANT_UVEC2(kViewport, 0u);
 [[vk::binding(0)]] SamplerState g_linearAnyClampSampler;
 [[vk::binding(1)]] Texture2D g_inTex; ///< Its the IS RT
 
-struct Uniforms
+struct Constants
 {
 	Vec4 m_thresholdScalePad2;
 };
 
-[[vk::push_constant]] ConstantBuffer<Uniforms> g_pc;
+[[vk::push_constant]] ConstantBuffer<Constants> g_pc;
 
 #if defined(ANKI_COMPUTE_SHADER)
 #	define THREADGROUP_SIZE_X 8

AnKi/Shaders/ClearTextureCompute.ankiprog

@@ -11,7 +11,7 @@
 #pragma anki start comp
 #include <AnKi/Shaders/Common.hlsl>
 
-struct Uniforms
+struct Constants
 {
 #if COMPONENT_TYPE == 0
 	Vec4 m_clearColor;
@@ -20,7 +20,7 @@ struct Uniforms
 #endif
 };
 
-[[vk::push_constant]] ConstantBuffer<Uniforms> g_pc;
+[[vk::push_constant]] ConstantBuffer<Constants> g_pc;
 
 #if TEXTURE_DIMENSIONS == 2
 #	if COMPONENT_TYPE == 0

AnKi/Shaders/ClusterBinning.ankiprog

@@ -28,7 +28,7 @@ typedef GpuSceneGlobalIlluminationProbe GpuSceneType;
 #	error See file
 #endif
 
-struct ClusterBinningUniforms
+struct ClusterBinningConstants
 {
 	Vec3 m_cameraOrigin;
 	F32 m_zSplitCountOverFrustumLength;
@@ -42,7 +42,7 @@ struct ClusterBinningUniforms
 	Mat4 m_invertedViewProjMat;
 };
 
-[[vk::push_constant]] ConstantBuffer<ClusterBinningUniforms> g_unis;
+[[vk::push_constant]] ConstantBuffer<ClusterBinningConstants> g_consts;
 
 [[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;
@@ -60,25 +60,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_unis.m_tileCount * kSampleCount);
+	const U32 dispatchThreadIdX = min(svDispatchThreadId.x, g_consts.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_unis.m_tileCountX, tileIdx / g_unis.m_tileCountX);
+	const UVec2 tileXY = UVec2(tileIdx % g_consts.m_tileCountX, tileIdx / g_consts.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_unis.m_renderingSize;
+	const Vec2 uv = Vec2(pixel) / g_consts.m_renderingSize;
 	const Vec2 ndc = uvToNdc(uv);
 
 	// Unproject the sample in world space
-	const Vec4 farWorldPos4 = mul(g_unis.m_invertedViewProjMat, Vec4(ndc, 1.0, 1.0));
+	const Vec4 farWorldPos4 = mul(g_consts.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_unis.m_cameraOrigin;
+	const Vec3 rayOrigin = g_consts.m_cameraOrigin;
 	const Vec3 rayDir = normalize(farWorldPos - rayOrigin);
 
 	// Do collision
@@ -179,8 +179,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_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);
+		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);
 
 		F32 minDistFromNearPlane;
 		F32 maxDistFromNearPlane;
@@ -195,27 +195,27 @@ constexpr UVec2 kSampleLocations[kSampleCount] = {LOCATION(1, -3), LOCATION(-1,
 			maxDistFromNearPlane = distFromNearPlaneA;
 		}
 
-		const I32 startZSplit = max(I32(minDistFromNearPlane * g_unis.m_zSplitCountOverFrustumLength), 0);
-		const I32 endZSplit = clamp(I32(maxDistFromNearPlane * g_unis.m_zSplitCountOverFrustumLength), 0, I32(kZSplitCount) - 1);
+		const I32 startZSplit = max(I32(minDistFromNearPlane * g_consts.m_zSplitCountOverFrustumLength), 0);
+		const I32 endZSplit = clamp(I32(maxDistFromNearPlane * g_consts.m_zSplitCountOverFrustumLength), 0, I32(kZSplitCount) - 1);
 		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_unis.m_tileCount + i].m_pointLightsMask[maskArrayIdx], mask);
+				InterlockedOr(g_clusters[g_consts.m_tileCount + i].m_pointLightsMask[maskArrayIdx], mask);
 			}
 			else
 			{
-				InterlockedOr(g_clusters[g_unis.m_tileCount + i].m_spotLightsMask[maskArrayIdx], mask);
+				InterlockedOr(g_clusters[g_consts.m_tileCount + i].m_spotLightsMask[maskArrayIdx], mask);
 			}
 #elif OBJECT_TYPE == ANKI_GPU_SCENE_NON_RENDERABLE_OBJECT_TYPE_DECAL
-			InterlockedOr(g_clusters[g_unis.m_tileCount + i].m_decalsMask[maskArrayIdx], mask);
+			InterlockedOr(g_clusters[g_consts.m_tileCount + i].m_decalsMask[maskArrayIdx], mask);
 #elif OBJECT_TYPE == ANKI_GPU_SCENE_NON_RENDERABLE_OBJECT_TYPE_FOG_DENSITY_VOLUME
-			InterlockedOr(g_clusters[g_unis.m_tileCount + i].m_fogDensityVolumesMask, mask);
+			InterlockedOr(g_clusters[g_consts.m_tileCount + i].m_fogDensityVolumesMask, mask);
 #elif OBJECT_TYPE == ANKI_GPU_SCENE_NON_RENDERABLE_OBJECT_TYPE_REFLECTION_PROBE
-			InterlockedOr(g_clusters[g_unis.m_tileCount + i].m_reflectionProbesMask, mask);
+			InterlockedOr(g_clusters[g_consts.m_tileCount + i].m_reflectionProbesMask, mask);
 #elif OBJECT_TYPE == ANKI_GPU_SCENE_NON_RENDERABLE_OBJECT_TYPE_GLOBAL_ILLUMINATION_PROBE
-			InterlockedOr(g_clusters[g_unis.m_tileCount + i].m_giProbesMask, mask);
+			InterlockedOr(g_clusters[g_consts.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 Uniforms
+struct Constants
 {
 	U32 m_tileCount;
 	U32 m_padding1;
 	U32 m_padding2;
 	U32 m_padding3;
 };
-[[vk::push_constant]] ConstantBuffer<Uniforms> g_unis;
+[[vk::push_constant]] ConstantBuffer<Constants> g_consts;
 
 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_unis.m_tileCount * kSampleCount + kClusterBinningThreadgroupSize - 1) / kClusterBinningThreadgroupSize;
+		args.m_threadGroupCountX = (g_consts.m_tileCount * kSampleCount + kClusterBinningThreadgroupSize - 1) / kClusterBinningThreadgroupSize;
 		args.m_threadGroupCountY = objCount;
 		args.m_threadGroupCountZ = 1;
 

AnKi/Shaders/ClusteredShadingFunctions.hlsl

@@ -104,7 +104,7 @@ Cluster getClusterFragCoord(StructuredBuffer<Cluster> clusters, Vec3 fragCoord,
 	return mergeClusters(tileCluster, zCluster);
 }
 
-Cluster getClusterFragCoord(StructuredBuffer<Cluster> clusters, ClusteredShadingUniforms unis, Vec3 fragCoord)
+Cluster getClusterFragCoord(StructuredBuffer<Cluster> clusters, ClusteredShadingConstants unis, Vec3 fragCoord)
 {
 	return getClusterFragCoord(clusters, fragCoord, unis.m_tileCounts, unis.m_zSplitCount, unis.m_zSplitMagic.x, unis.m_zSplitMagic.y);
 }

AnKi/Shaders/DbgBillboard.ankiprog

@@ -13,13 +13,13 @@
 constexpr F32 kAlpha = 0.95f;
 constexpr F32 kBillboardScale = 0.25f;
 
-struct Uniforms
+struct Constants
 {
 	Mat4 m_viewProjMat;
 	Mat3x4 m_camTrf;
 };
 
-[[vk::push_constant]] ConstantBuffer<Uniforms> g_unis;
+[[vk::push_constant]] ConstantBuffer<Constants> g_consts;
 
 #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_unis.m_camTrf, Vec4((output.m_uv * 2.0 - 1.0) * kBillboardScale, 0.0, 0.0)) + localPos;
+		const Vec3 worldPos = mul(g_consts.m_camTrf, Vec4((output.m_uv * 2.0 - 1.0) * kBillboardScale, 0.0, 0.0)) + localPos;
 
-		output.m_svPosition = mul(g_unis.m_viewProjMat, Vec4(worldPos, 1.0));
+		output.m_svPosition = mul(g_consts.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 Uniforms
+struct Constants
 {
 	Vec4 m_color;
 	Mat4 m_viewProjMat;
 };
 
-[[vk::push_constant]] ConstantBuffer<Uniforms> g_uniforms;
+[[vk::push_constant]] ConstantBuffer<Constants> g_consts;
 
 [[vk::binding(2)]] StructuredBuffer<GpuSceneRenderableBoundingVolume> g_renderableBoundingVolumes;
 [[vk::binding(3)]] StructuredBuffer<U32> g_visibleRenderableBoundingVolumeIndices;
@@ -41,7 +41,7 @@ VertOut main(VertIn input)
 	{
 		const GpuSceneRenderableBoundingVolume bvol = g_renderableBoundingVolumes[g_visibleRenderableBoundingVolumeIndices[input.m_svInstanceId + 1]];
 		Vec3 localPos = input.m_position * bvol.m_aabbExtend + bvol.m_sphereCenter;
-		output.m_svPosition = mul(g_uniforms.m_viewProjMat, Vec4(localPos, 1.0));
+		output.m_svPosition = mul(g_consts.m_viewProjMat, Vec4(localPos, 1.0));
 	}
 	else
 	{
@@ -83,6 +83,6 @@ Vec4 main(VertOut input) : SV_TARGET0
 #endif
 
 	// Write the color
-	return g_uniforms.m_color;
+	return g_consts.m_color;
 }
 #pragma anki end

AnKi/Shaders/DepthDownscaleCompute.ankiprog

@@ -11,7 +11,7 @@
 #include <AnKi/Shaders/Common.hlsl>
 #include <AnKi/Shaders/Include/MiscRendererTypes.h>
 
-[[vk::push_constant]] ConstantBuffer<DepthDownscaleUniforms> g_uniforms;
+[[vk::push_constant]] ConstantBuffer<DepthDownscaleConstants> g_consts;
 
 [[vk::binding(0)]] RWTexture2D<Vec4> g_dstUavs[kMaxMipsSinglePassDownsamplerCanProduce];
 [[vk::binding(1)]] globallycoherent RWStructuredBuffer<U32> g_spdCounter;
@@ -30,7 +30,7 @@ groupshared AF1 s_spdIntermediateR[16][16];
 AF4 SpdLoadSourceImage(AU2 p, AU1 slice)
 {
 	ANKI_MAYBE_UNUSED(slice);
-	const AF2 textureCoord = Vec2(p) * g_uniforms.m_srcTexSizeOverOne + g_uniforms.m_srcTexSizeOverOne;
+	const AF2 textureCoord = Vec2(p) * g_consts.m_srcTexSizeOverOne + g_consts.m_srcTexSizeOverOne;
 	return AF4(g_srcTex.SampleLevel(u_linearAnyClampSampler, textureCoord, 0.0).r, 0.0, 0.0, 0.0);
 }
 
@@ -91,7 +91,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_uniforms.m_mipmapCount), AU1(g_uniforms.m_threadgroupCount), slice, offset);
+	SpdDownsample(AU2(svGroupId.xy), AU1(svGroupIndex), AU1(g_consts.m_mipmapCount), AU1(g_consts.m_threadgroupCount), slice, offset);
 }
 
 #pragma anki end

AnKi/Shaders/DownscaleBlur.hlsl

@@ -14,13 +14,13 @@
 constexpr U32 kTonemappingBinding = 2u;
 #include <AnKi/Shaders/TonemappingResources.hlsl>
 
-struct Uniforms
+struct Constants
 {
 	UVec2 m_fbSize;
 	U32 m_revertTonemapping;
 	U32 m_padding;
 };
-[[vk::push_constant]] ConstantBuffer<Uniforms> g_uniforms;
+[[vk::push_constant]] ConstantBuffer<Constants> g_consts;
 
 #if defined(ANKI_COMPUTE_SHADER)
 [[vk::binding(3)]] RWTexture2D<RVec4> g_outUav;
@@ -33,13 +33,13 @@ RVec3 main([[vk::location(0)]] Vec2 uv : TEXCOORD) : SV_TARGET0
 #endif
 {
 #if defined(ANKI_COMPUTE_SHADER)
-	if(svDispatchThreadId.x >= g_uniforms.m_fbSize.x || svDispatchThreadId.y >= g_uniforms.m_fbSize.y)
+	if(svDispatchThreadId.x >= g_consts.m_fbSize.x || svDispatchThreadId.y >= g_consts.m_fbSize.y)
 	{
 		// Skip pixels outside the viewport
 		return;
 	}
 
-	const Vec2 uv = (Vec2(svDispatchThreadId.xy) + 0.5) / Vec2(g_uniforms.m_fbSize);
+	const Vec2 uv = (Vec2(svDispatchThreadId.xy) + 0.5) / Vec2(g_consts.m_fbSize);
 #endif
 
 	RVec3 output;
@@ -50,7 +50,7 @@ RVec3 main([[vk::location(0)]] Vec2 uv : TEXCOORD) : SV_TARGET0
 	output += g_tex.SampleLevel(g_linearAnyClampSampler, uv, 0.0, IVec2(+1, -1)) * weight;
 	output += g_tex.SampleLevel(g_linearAnyClampSampler, uv, 0.0, IVec2(-1, +1)) * weight;
 
-	if(g_uniforms.m_revertTonemapping != 0u)
+	if(g_consts.m_revertTonemapping != 0u)
 	{
 		output = saturate(output);
 		output = sRgbToLinear(output);

AnKi/Shaders/ForwardShadingFog.ankiprog

@@ -8,8 +8,8 @@
 #include <AnKi/Shaders/ForwardShadingCommon.hlsl>
 #include <AnKi/Shaders/Functions.hlsl>
 
-#pragma anki reflect AnKiLocalUniforms
-#pragma anki struct AnKiLocalUniforms
+#pragma anki reflect AnKiLocalConstants
+#pragma anki struct AnKiLocalConstants
 #pragma anki member RVec3 m_fogColor
 #pragma anki member RF32 m_fogAlphaScale
 #pragma anki member RF32 m_fogDistanceOfMaxThikness
@@ -25,7 +25,7 @@ struct VertOut
 {
 	Vec4 m_svPosition : SV_POSITION;
 	F32 m_zVSpace : ZVSPACE;
-	nointerpolation U32 m_uniformsOffset : UNIFORMS;
+	nointerpolation U32 m_constantsOffset : UNIFORMS;
 };
 
 #pragma anki start vert
@@ -40,12 +40,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_globalUniforms.m_viewProjectionMatrix, Vec4(worldPos, 1.0));
+	output.m_svPosition = mul(g_globalConstants.m_viewProjectionMatrix, Vec4(worldPos, 1.0));
 
-	const Vec3 viewPos = mul(g_globalUniforms.m_viewTransform, Vec4(worldPos, 1.0));
+	const Vec3 viewPos = mul(g_globalConstants.m_viewTransform, Vec4(worldPos, 1.0));
 	output.m_zVSpace = viewPos.z;
 
-	output.m_uniformsOffset = renderable.m_uniformsOffset;
+	output.m_constantsOffset = renderable.m_constantsOffset;
 
 	return output;
 }
@@ -57,9 +57,9 @@ VertOut main(VertIn input)
 FragOut main(VertOut input)
 {
 	FragOut output = (FragOut)0;
-	const AnKiLocalUniforms localUniforms = loadAnKiLocalUniforms(g_gpuScene, input.m_uniformsOffset);
+	const AnKiLocalConstants localConstants = loadAnKiLocalConstants(g_gpuScene, input.m_constantsOffset);
 
-	fog(localUniforms.m_fogColor, localUniforms.m_fogAlphaScale, localUniforms.m_fogDistanceOfMaxThikness, input.m_svPosition, input.m_zVSpace,
+	fog(localConstants.m_fogColor, localConstants.m_fogAlphaScale, localConstants.m_fogDistanceOfMaxThikness, input.m_svPosition, input.m_zVSpace,
 		output);
 
 	return output;

AnKi/Shaders/ForwardShadingGenericTransparent.ankiprog

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

AnKi/Shaders/ForwardShadingParticles.ankiprog

@@ -17,15 +17,15 @@ struct VertIn
 
 struct VertOut
 {
-	nointerpolation U32 m_uniformsOffset : UNIS_OFFSET;
+	nointerpolation U32 m_constantsOffset : UNIS_OFFSET;
 	nointerpolation RF32 m_alpha : ALPHA;
 	Vec2 m_uv : TEXCOORD;
 	Vec3 m_worldPos : WORLD_POS;
 	Vec4 m_svPosition : SV_POSITION;
 };
 
-#pragma anki reflect AnKiLocalUniforms
-#pragma anki struct AnKiLocalUniforms
+#pragma anki reflect AnKiLocalConstants
+#pragma anki struct AnKiLocalConstants
 #pragma anki member F32 m_animationPeriod if ANIMATED_TEXTURE is 1
 #pragma anki member Vec4 m_colorScale
 #pragma anki member Vec4 m_colorBias
@@ -59,12 +59,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_globalUniforms.m_cameraTransform, Vec4(localPos * particleScale, 0.0)) + particlePos;
+	output.m_worldPos = mul(g_globalConstants.m_cameraTransform, Vec4(localPos * particleScale, 0.0)) + particlePos;
 
-	output.m_svPosition = mul(g_globalUniforms.m_viewProjectionMatrix, Vec4(output.m_worldPos, 1.0));
+	output.m_svPosition = mul(g_globalConstants.m_viewProjectionMatrix, Vec4(output.m_worldPos, 1.0));
 
 	output.m_alpha = particleAlpha;
-	output.m_uniformsOffset = renderable.m_uniformsOffset;
+	output.m_constantsOffset = renderable.m_constantsOffset;
 
 	return output;
 }
@@ -75,22 +75,22 @@ VertOut main(VertIn input)
 FragOut main(VertOut input)
 {
 	FragOut output = (FragOut)0;
-	const AnKiLocalUniforms localUniforms = loadAnKiLocalUniforms(g_gpuScene, WaveReadLaneFirst(input.m_uniformsOffset));
+	const AnKiLocalConstants localConstants = loadAnKiLocalConstants(g_gpuScene, WaveReadLaneFirst(input.m_constantsOffset));
 
 #if ANIMATED_TEXTURE == 1
-	RVec4 texCol = readAnimatedTextureRgba(g_bindlessTextures2dArrayF32[localUniforms.m_diffuseMap], g_globalSampler, localUniforms.m_animationPeriod,
-										   input.m_uv, g_clusteredShading.m_time);
+	RVec4 texCol = readAnimatedTextureRgba(g_bindlessTextures2dArrayF32[localConstants.m_diffuseMap], g_globalSampler,
+										   localConstants.m_animationPeriod, input.m_uv, g_clusteredShading.m_time);
 #else
-	RVec4 texCol = g_bindlessTextures2dF32[localUniforms.m_diffuseMap].Sample(g_globalSampler, input.m_uv);
+	RVec4 texCol = g_bindlessTextures2dF32[localConstants.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 = localUniforms.m_colorScale;
+	RVec4 colScale = localConstants.m_colorScale;
 	colScale.a *= input.m_alpha;
-	particleAlpha(texCol, colScale, localUniforms.m_colorBias, output);
+	particleAlpha(texCol, colScale, localConstants.m_colorBias, output);
 
 	return output;
 }

AnKi/Shaders/Fsr.hlsl

@@ -15,7 +15,7 @@
 [[vk::binding(2)]] RWTexture2D<Vec4> g_outUav;
 #endif
 
-struct Uniforms
+struct Constants
 {
 	UVec4 m_fsrConsts0;
 	UVec4 m_fsrConsts1;
@@ -25,7 +25,7 @@ struct Uniforms
 	UVec2 m_padding;
 };
 
-[[vk::push_constant]] ConstantBuffer<Uniforms> g_uniforms;
+[[vk::push_constant]] ConstantBuffer<Constants> g_consts;
 
 // FSR begin
 #define A_GPU 1
@@ -82,7 +82,7 @@ Vec3 main(Vec4 svPosition : SV_POSITION) : SV_TARGET0
 #endif
 {
 #if defined(ANKI_COMPUTE_SHADER)
-	if(any(svDispatchThreadId >= g_uniforms.m_viewportSize))
+	if(any(svDispatchThreadId >= g_consts.m_viewportSize))
 	{
 		return;
 	}
@@ -94,11 +94,11 @@ Vec3 main(Vec4 svPosition : SV_POSITION) : SV_TARGET0
 
 	HVec3 color;
 #if SHARPEN
-	FsrRcasH(color.r, color.g, color.b, uv, g_uniforms.m_fsrConsts0);
+	FsrRcasH(color.r, color.g, color.b, uv, g_consts.m_fsrConsts0);
 #elif FSR_QUALITY == 0
-	FsrEasuL(color, uv, g_uniforms.m_fsrConsts0, g_uniforms.m_fsrConsts1, g_uniforms.m_fsrConsts2, g_uniforms.m_fsrConsts3);
+	FsrEasuL(color, uv, g_consts.m_fsrConsts0, g_consts.m_fsrConsts1, g_consts.m_fsrConsts2, g_consts.m_fsrConsts3);
 #else
-	FsrEasuH(color, uv, g_uniforms.m_fsrConsts0, g_uniforms.m_fsrConsts1, g_uniforms.m_fsrConsts2, g_uniforms.m_fsrConsts3);
+	FsrEasuH(color, uv, g_consts.m_fsrConsts0, g_consts.m_fsrConsts1, g_consts.m_fsrConsts2, g_consts.m_fsrConsts3);
 #endif
 
 #if defined(ANKI_COMPUTE_SHADER)

AnKi/Shaders/GBufferGeneric.ankiprog

@@ -30,8 +30,8 @@
 #include <AnKi/Shaders/Functions.hlsl>
 #include <AnKi/Shaders/MaterialShadersCommon.hlsl>
 
-#pragma anki reflect AnKiLocalUniforms
-#pragma anki struct AnKiLocalUniforms
+#pragma anki reflect AnKiLocalConstants
+#pragma anki struct AnKiLocalConstants
 
 #pragma anki member RVec3 m_diffColor if DIFFUSE_TEX is 0
 #pragma anki member U32 m_diffTex if DIFFUSE_TEX is 1
@@ -86,7 +86,7 @@ struct VertOut
 #	endif
 #endif
 
-	nointerpolation U32 m_uniformsOffset : UNIS_OFFSET;
+	nointerpolation U32 m_constantsOffset : UNIS_OFFSET;
 };
 
 #if ANKI_TECHNIQUE == ANKI_RENDERING_TECHNIQUE_GBUFFER
@@ -160,7 +160,7 @@ void velocity(Mat3x4 worldTransform, Mat3x4 prevWorldTransform, Vec3 prevLocalPo
 #	endif
 
 	Vec4 v4 = Vec4(mul(trf, Vec4(prevLocalPos, 1.0)), 1.0);
-	v4 = mul(g_globalUniforms.m_previousViewProjectionMatrix, v4);
+	v4 = mul(g_globalConstants.m_previousViewProjectionMatrix, v4);
 
 	output.m_prevClipXyw = v4.xyw;
 	output.m_crntClipXyw = output.m_position.xyw;
@@ -184,7 +184,7 @@ VertOut main(VertIn input)
 #endif
 	Vec3 prevPos = vert.m_position;
 	ANKI_MAYBE_UNUSED(prevPos);
-	output.m_uniformsOffset = renderable.m_uniformsOffset;
+	output.m_constantsOffset = renderable.m_constantsOffset;
 
 	// Do stuff
 #if ANKI_BONES
@@ -192,7 +192,7 @@ VertOut main(VertIn input)
 #endif
 
 	output.m_position = Vec4(mul(worldTransform, Vec4(vert.m_position, 1.0)), 1.0);
-	output.m_position = mul(g_globalUniforms.m_viewProjectionMatrix, output.m_position);
+	output.m_position = mul(g_globalConstants.m_viewProjectionMatrix, output.m_position);
 
 #if ANKI_TECHNIQUE == ANKI_RENDERING_TECHNIQUE_GBUFFER
 	output.m_normal = mul(worldTransform, Vec4(vert.m_normal, 0.0));
@@ -224,8 +224,8 @@ void main(VertOut input)
 {
 	ANKI_MAYBE_UNUSED(input);
 #	if REALLY_ALPHA_TEST
-	const AnKiLocalUniforms localUniforms = loadAnKiLocalUniforms(g_gpuScene, input.m_uniformsOffset);
-	const RVec4 diffColorA = g_bindlessTextures2dF32[localUniforms.m_diffTex].Sample(g_globalSampler, input.m_uv);
+	const AnKiLocalConstants localConstants = loadAnKiLocalConstants(g_gpuScene, input.m_constantsOffset);
+	const RVec4 diffColorA = g_bindlessTextures2dF32[localConstants.m_diffTex].Sample(g_globalSampler, input.m_uv);
 	doAlphaTest(diffColorA.a);
 #	endif
 }
@@ -247,7 +247,7 @@ RVec3 readNormalFromTexture(VertOut input, Texture2D<RVec4> map, SamplerState sa
 
 FragOut main(VertOut input)
 {
-	const AnKiLocalUniforms localUniforms = loadAnKiLocalUniforms(g_gpuScene, input.m_uniformsOffset);
+	const AnKiLocalConstants localConstants = loadAnKiLocalConstants(g_gpuScene, input.m_constantsOffset);
 
 #	if REALLY_USING_PARALLAX
 	// TODO
@@ -259,44 +259,44 @@ FragOut main(VertOut input)
 
 #	if DIFFUSE_TEX
 #		if REALLY_ALPHA_TEST
-	const RVec4 diffColorA = g_bindlessTextures2dF32[localUniforms.m_diffTex].Sample(g_globalSampler, uv);
+	const RVec4 diffColorA = g_bindlessTextures2dF32[localConstants.m_diffTex].Sample(g_globalSampler, uv);
 	doAlphaTest(diffColorA.a);
 	const RVec3 diffColor = diffColorA.rgb;
 #		else
-	const RVec3 diffColor = g_bindlessTextures2dF32[localUniforms.m_diffTex].Sample(g_globalSampler, uv).rgb;
+	const RVec3 diffColor = g_bindlessTextures2dF32[localConstants.m_diffTex].Sample(g_globalSampler, uv).rgb;
 #		endif
 #	else
-	const RVec3 diffColor = localUniforms.m_diffColor;
+	const RVec3 diffColor = localConstants.m_diffColor;
 #	endif
 
 #	if SPECULAR_TEX
-	const RVec3 specColor = g_bindlessTextures2dF32[localUniforms.m_specTex].Sample(g_globalSampler, uv).rgb;
+	const RVec3 specColor = g_bindlessTextures2dF32[localConstants.m_specTex].Sample(g_globalSampler, uv).rgb;
 #	else
-	const RVec3 specColor = localUniforms.m_specColor;
+	const RVec3 specColor = localConstants.m_specColor;
 #	endif
 
 #	if ROUGHNESS_TEX
-	const RF32 roughness = g_bindlessTextures2dF32[localUniforms.m_roughnessTex].Sample(g_globalSampler, uv).g;
+	const RF32 roughness = g_bindlessTextures2dF32[localConstants.m_roughnessTex].Sample(g_globalSampler, uv).g;
 #	else
-	const RF32 roughness = localUniforms.m_roughness;
+	const RF32 roughness = localConstants.m_roughness;
 #	endif
 
 #	if METAL_TEX
-	const RF32 metallic = g_bindlessTextures2dF32[localUniforms.m_metallicTex].Sample(g_globalSampler, uv).b;
+	const RF32 metallic = g_bindlessTextures2dF32[localConstants.m_metallicTex].Sample(g_globalSampler, uv).b;
 #	else
-	const RF32 metallic = localUniforms.m_metallic;
+	const RF32 metallic = localConstants.m_metallic;
 #	endif
 
 #	if NORMAL_TEX
-	const RVec3 normal = readNormalFromTexture(input, g_bindlessTextures2dF32[localUniforms.m_normalTex], g_globalSampler, uv);
+	const RVec3 normal = readNormalFromTexture(input, g_bindlessTextures2dF32[localConstants.m_normalTex], g_globalSampler, uv);
 #	else
 	const RVec3 normal = normalize(input.m_normal);
 #	endif
 
 #	if EMISSIVE_TEX
-	const RVec3 emission = g_bindlessTextures2dF32[localUniforms.m_emissiveTex].Sample(g_globalSampler, uv).rgb;
+	const RVec3 emission = g_bindlessTextures2dF32[localConstants.m_emissiveTex].Sample(g_globalSampler, uv).rgb;
 #	else
-	const RVec3 emission = localUniforms.m_emission;
+	const RVec3 emission = localConstants.m_emission;
 #	endif
 
 #	if ANKI_VELOCITY || ANKI_BONES
@@ -314,7 +314,7 @@ FragOut main(VertOut input)
 	g.m_normal = normal;
 	g.m_f0 = specColor;
 	g.m_roughness = roughness;
-	g.m_subsurface = localUniforms.m_subsurface;
+	g.m_subsurface = localConstants.m_subsurface;
 	g.m_emission = emission;
 	g.m_metallic = metallic;
 	g.m_velocity = velocity;

AnKi/Shaders/GBufferGpuParticles.ankiprog

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

@@ -19,7 +19,7 @@ ANKI_SPECIALIZATION_CONSTANT_U32(kZSplitCount, 2u);
 [[vk::binding(1)]] Texture2D g_depthTex;
 [[vk::binding(2)]] SamplerState g_trilinearRepeatSampler;
 
-[[vk::binding(3)]] ConstantBuffer<ClusteredShadingUniforms> g_clusteredShading;
+[[vk::binding(3)]] ConstantBuffer<ClusteredShadingConstants> g_clusteredShading;
 [[vk::binding(4)]] StructuredBuffer<Decal> g_decals;
 [[vk::binding(5)]] StructuredBuffer<Cluster> g_clusters;
 

AnKi/Shaders/GpuVisibility.ankiprog

@@ -42,9 +42,9 @@ struct DrawIndirectArgsWithPadding
 [[vk::binding(6)]] RWStructuredBuffer<U32> g_mdiDrawCounts;
 
 #if DISTANCE_TEST == 0
-[[vk::binding(7)]] ConstantBuffer<FrustumGpuVisibilityUniforms> g_unis;
+[[vk::binding(7)]] ConstantBuffer<FrustumGpuVisibilityConstants> g_consts;
 #else
-[[vk::push_constant]] ConstantBuffer<DistanceGpuVisibilityUniforms> g_unis;
+[[vk::push_constant]] ConstantBuffer<DistanceGpuVisibilityConstants> g_consts;
 #endif
 
 #if HZB_TEST
@@ -76,7 +76,7 @@ struct DrawIndirectArgsWithPadding
 #if DISTANCE_TEST == 0
 	// Frustum test
 	//
-	if(!frustumTest(g_unis.m_clipPlanes, bvolume.m_sphereCenter, bvolume.m_sphereRadius))
+	if(!frustumTest(g_consts.m_clipPlanes, bvolume.m_sphereCenter, bvolume.m_sphereRadius))
 	{
 		return;
 	}
@@ -93,7 +93,7 @@ struct DrawIndirectArgsWithPadding
 	Vec2 maxNdc = -1000.0f;
 	[unroll] for(U32 i = 0; i < 8; ++i)
 	{
-		Vec4 p = mul(g_unis.m_viewProjectionMat, Vec4(aabbEdges[i], 1.0f));
+		Vec4 p = mul(g_consts.m_viewProjectionMat, Vec4(aabbEdges[i], 1.0f));
 
 		p.xyz /= abs(p.w);
 
@@ -150,7 +150,7 @@ struct DrawIndirectArgsWithPadding
 	}
 #	endif // HZB_TEST
 #else // DISTANCE_TEST == 1
-	if(!testSphereSphereCollision(bvolume.m_sphereCenter, bvolume.m_sphereRadius, g_unis.m_pointOfTest, g_unis.m_testRadius))
+	if(!testSphereSphereCollision(bvolume.m_sphereCenter, bvolume.m_sphereRadius, g_consts.m_pointOfTest, g_consts.m_testRadius))
 	{
 		return;
 	}
@@ -158,14 +158,14 @@ struct DrawIndirectArgsWithPadding
 
 	// Compute the LOD
 	//
-	const F32 distFromLodPoint = length(bvolume.m_sphereCenter - g_unis.m_lodReferencePoint) - bvolume.m_sphereRadius;
+	const F32 distFromLodPoint = length(bvolume.m_sphereCenter - g_consts.m_lodReferencePoint) - bvolume.m_sphereRadius;
 
 	U32 lod;
-	if(distFromLodPoint < g_unis.m_maxLodDistances[0])
+	if(distFromLodPoint < g_consts.m_maxLodDistances[0])
 	{
 		lod = 0u;
 	}
-	else if(distFromLodPoint < g_unis.m_maxLodDistances[1])
+	else if(distFromLodPoint < g_consts.m_maxLodDistances[1])
 	{
 		lod = 1u;
 	}
@@ -203,7 +203,7 @@ struct DrawIndirectArgsWithPadding
 
 		UVec4 instanceVertex;
 		instanceVertex.x = renderable.m_worldTransformsOffset;
-		instanceVertex.y = renderable.m_uniformsOffset;
+		instanceVertex.y = renderable.m_constantsOffset;
 		instanceVertex.z = meshLodOffset;
 		instanceVertex.w = renderable.m_boneTransformsOffset;
 		g_instanceRateRenderables[indirectIdx] = instanceVertex;
@@ -221,7 +221,7 @@ struct DrawIndirectArgsWithPadding
 
 		UVec4 instanceVertex;
 		instanceVertex.x = renderable.m_worldTransformsOffset;
-		instanceVertex.y = renderable.m_uniformsOffset;
+		instanceVertex.y = renderable.m_constantsOffset;
 		instanceVertex.z = meshLodOffset;
 		instanceVertex.w = renderable.m_particleEmitterOffset;
 		g_instanceRateRenderables[indirectIdx] = instanceVertex;

AnKi/Shaders/GpuVisibilityAccelerationStructures.ankiprog

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

AnKi/Shaders/GpuVisibilityNonRenderables.ankiprog

@@ -30,7 +30,7 @@ typedef GpuSceneGlobalIlluminationProbe ObjectType;
 #endif
 
 [[vk::binding(0)]] StructuredBuffer<ObjectType> g_objects;
-[[vk::push_constant]] ConstantBuffer<GpuVisibilityNonRenderableUniforms> g_unis;
+[[vk::push_constant]] ConstantBuffer<GpuVisibilityNonRenderableConstants> g_consts;
 [[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_unis.m_clipPlanes, sphere.xyz, sphere.w);
+		skip = !frustumTest(g_consts.m_clipPlanes, sphere.xyz, sphere.w);
 	}
 
 	// Add the object

AnKi/Shaders/HzbGenPyramid.ankiprog

@@ -9,14 +9,14 @@
 #pragma anki start comp
 #include <AnKi/Shaders/Common.hlsl>
 
-struct Uniforms
+struct Constants
 {
 	Vec2 m_invSrcTexSize;
 	U32 m_threadGroupCount;
 	U32 m_mipmapCount;
 };
 
-[[vk::push_constant]] ConstantBuffer<Uniforms> g_uniforms;
+[[vk::push_constant]] ConstantBuffer<Constants> g_consts;
 
 [[vk::binding(0)]] globallycoherent RWTexture2D<Vec4> g_dstUavs[kMaxMipsSinglePassDownsamplerCanProduce];
 [[vk::binding(1)]] globallycoherent RWStructuredBuffer<U32> g_spdCounter;
@@ -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_uniforms.m_invSrcTexSize + g_uniforms.m_invSrcTexSize;
+	const AF2 uv = p * g_consts.m_invSrcTexSize + g_consts.m_invSrcTexSize;
 
 #if MIN_MAX_SAMPLER
 	const F32 f = g_srcTex.SampleLevel(g_minMaxAnyClampSampler, uv, 0.0).r;
@@ -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_uniforms.m_mipmapCount), AU1(g_uniforms.m_threadGroupCount), slice, offset);
+	SpdDownsample(AU2(svGroupId.xy), AU1(svGroupIndex), AU1(g_consts.m_mipmapCount), AU1(g_consts.m_threadGroupCount), slice, offset);
 }
 
 #pragma anki end

AnKi/Shaders/HzbMaxDepthProject.ankiprog

@@ -11,7 +11,7 @@
 
 [[vk::binding(0)]] Texture2D<Vec4> g_maxDepthRt;
 
-struct Uniforms
+struct Constants
 {
 	Mat4 m_reprojectionMat;
 
@@ -21,7 +21,7 @@ struct Uniforms
 	F32 m_padding1;
 };
 
-[[vk::push_constant]] ConstantBuffer<Uniforms> g_unis;
+[[vk::push_constant]] ConstantBuffer<Constants> g_consts;
 
 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_unis.m_cascadeMaxDepth);
-	const F32 minDepth = g_unis.m_cascadeMinDepth;
+	const F32 maxDepth = min(g_maxDepthRt[UVec2(tileX, tileY)].x, g_consts.m_cascadeMaxDepth);
+	const F32 minDepth = g_consts.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_unis.m_reprojectionMat, Vec4(ndc, 1.0));
+	return mul(g_consts.m_reprojectionMat, Vec4(ndc, 1.0));
 }
 
 #pragma anki end

AnKi/Shaders/Include/ClusteredShadingTypes.h

@@ -153,7 +153,7 @@ constexpr U32 kSizeof_CommonMatrices = 43u * sizeof(Vec4);
 static_assert(sizeof(CommonMatrices) == kSizeof_CommonMatrices);
 
 /// Common uniforms for light shading passes.
-struct ClusteredShadingUniforms
+struct ClusteredShadingConstants
 {
 	Vec2 m_renderingSize;
 	F32 m_time;

AnKi/Shaders/Include/GpuSceneFunctions.h

@@ -13,7 +13,7 @@ inline GpuSceneRenderableVertex unpackGpuSceneRenderableVertex(UVec4 x)
 {
 	GpuSceneRenderableVertex o;
 	o.m_worldTransformsOffset = x[0];
-	o.m_uniformsOffset = x[1];
+	o.m_constantsOffset = x[1];
 	o.m_meshLodOffset = 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_worldTransformsOffset; ///< First is the crnt transform and the 2nd the previous
-	U32 m_uniformsOffset;
+	U32 m_constantsOffset;
 	U32 m_meshLodsOffset; ///< Points to an array of GpuSceneMeshLod sized kMaxLodCount.
 	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 GpuSceneRenderableVertex
 {
 	U32 m_worldTransformsOffset;
-	U32 m_uniformsOffset;
+	U32 m_constantsOffset;
 	U32 m_meshLodOffset; ///< Points to a single GpuSceneMeshLod and not an array
 	U32 m_boneTransformsOrParticleEmitterOffset;
 };

AnKi/Shaders/Include/GpuVisibilityTypes.h

@@ -9,7 +9,7 @@
 
 ANKI_BEGIN_NAMESPACE
 
-struct FrustumGpuVisibilityUniforms
+struct FrustumGpuVisibilityConstants
 {
 	Vec4 m_clipPlanes[6u];
 
@@ -21,7 +21,7 @@ struct FrustumGpuVisibilityUniforms
 	Mat4 m_viewProjectionMat;
 };
 
-struct DistanceGpuVisibilityUniforms
+struct DistanceGpuVisibilityConstants
 {
 	Vec3 m_pointOfTest;
 	F32 m_testRadius;
@@ -32,12 +32,12 @@ struct DistanceGpuVisibilityUniforms
 	F32 m_padding3;
 };
 
-struct GpuVisibilityNonRenderableUniforms
+struct GpuVisibilityNonRenderableConstants
 {
 	Vec4 m_clipPlanes[6u];
 };
 
-struct GpuVisibilityAccelerationStructuresUniforms
+struct GpuVisibilityAccelerationStructuresConstants
 {
 	Vec4 m_clipPlanes[6u];
 

AnKi/Shaders/Include/MaterialTypes.h

@@ -10,41 +10,14 @@
 ANKI_BEGIN_NAMESPACE
 
 /// Common data for all materials.
-struct MaterialGlobalUniforms
+struct MaterialGlobalConstants
 {
 	Mat4 m_viewProjectionMatrix;
 	Mat4 m_previousViewProjectionMatrix;
 	Mat3x4 m_viewTransform;
 	Mat3x4 m_cameraTransform;
 };
-static_assert(sizeof(MaterialGlobalUniforms) == 14 * sizeof(Vec4));
-
-constexpr U32 kMaterialSetBindless = 0u;
-constexpr U32 kMaterialSetGlobal = 1u;
-constexpr U32 kMaterialSetLocal = 2u;
-
-// Begin global bindings
-constexpr U32 kMaterialBindingTrilinearRepeatSampler = 0u;
-constexpr U32 kMaterialBindingGlobalUniforms = 1u;
-constexpr U32 kMaterialBindingGpuScene = 2u;
-
-// For forward shading:
-constexpr U32 kMaterialBindingLinearClampSampler = 3u;
-constexpr U32 kMaterialBindingDepthRt = 4u;
-constexpr U32 kMaterialBindingLightVolume = 5u;
-constexpr U32 kMaterialBindingClusterShadingUniforms = 6u;
-constexpr U32 kMaterialBindingClusterShadingLights = 7u;
-constexpr U32 kMaterialBindingClusters = 8u;
-constexpr U32 kMaterialBindingShadowSampler = 9u;
-// End global bindings
-
-// Begin local bindings
-constexpr U32 kMaterialBindingLocalUniforms = 0u;
-constexpr U32 kMaterialBindingRenderableGpuView = 1u;
-constexpr U32 kMaterialBindingBoneTransforms = 2u;
-constexpr U32 kMaterialBindingPreviousBoneTransforms = 3u;
-constexpr U32 kMaterialBindingFirstNonStandardLocal = 4u;
-// End local bindings
+static_assert(sizeof(MaterialGlobalConstants) == 14 * sizeof(Vec4));
 
 /// @brief
 enum class MaterialSet : U32
@@ -57,7 +30,7 @@ enum class MaterialSet : U32
 enum class MaterialBinding : U32
 {
 	kTrilinearRepeatSampler,
-	kGlobalUniforms,
+	kGlobalConstants,
 	kGpuScene,
 
 	// Texture buffer bindings pointing to unified geom buffer:
@@ -69,7 +42,7 @@ enum class MaterialBinding : U32
 	kShadowSampler,
 	kDepthRt,
 	kLightVolume,
-	kClusterShadingUniforms,
+	kClusterShadingConstants,
 	kClusterShadingLights,
 	kClusters = kClusterShadingLights + 2,
 

AnKi/Shaders/Include/MiscRendererTypes.h

@@ -10,7 +10,7 @@
 ANKI_BEGIN_NAMESPACE
 
 // RT shadows
-struct RtShadowsDenoiseUniforms
+struct RtShadowsDenoiseConstants
 {
 	Mat4 m_invViewProjMat;
 
@@ -20,7 +20,7 @@ struct RtShadowsDenoiseUniforms
 	F32 m_padding2;
 };
 
-struct RtShadowsSbtBuildUniforms
+struct RtShadowsSbtBuildConstants
 {
 	U32 m_shaderHandleDwordSize;
 	U32 m_sbtRecordDwordSize;
@@ -29,7 +29,7 @@ struct RtShadowsSbtBuildUniforms
 };
 
 // Indirect diffuse
-struct IndirectDiffuseUniforms
+struct IndirectDiffuseConstants
 {
 	UVec2 m_viewportSize;
 	Vec2 m_viewportSizef;
@@ -47,7 +47,7 @@ struct IndirectDiffuseUniforms
 	F32 m_padding2;
 };
 
-struct IndirectDiffuseDenoiseUniforms
+struct IndirectDiffuseDenoiseConstants
 {
 	Mat4 m_invertedViewProjectionJitterMat;
 
@@ -69,7 +69,7 @@ struct LensFlareSprite
 };
 
 // Depth downscale
-struct DepthDownscaleUniforms
+struct DepthDownscaleConstants
 {
 	Vec2 m_srcTexSizeOverOne;
 	U32 m_threadgroupCount;
@@ -77,7 +77,7 @@ struct DepthDownscaleUniforms
 };
 
 // Screen space reflections uniforms
-struct SsrUniforms
+struct SsrConstants
 {
 	UVec2 m_depthBufferSize;
 	UVec2 m_framebufferSize;
@@ -98,7 +98,7 @@ struct SsrUniforms
 };
 
 // Vol fog
-struct VolumetricFogUniforms
+struct VolumetricFogConstants
 {
 	RVec3 m_fogDiffuse;
 	RF32 m_fogScatteringCoeff;
@@ -113,7 +113,7 @@ struct VolumetricFogUniforms
 };
 
 // Vol lighting
-struct VolumetricLightingUniforms
+struct VolumetricLightingConstants
 {
 	RF32 m_densityAtMinHeight;
 	RF32 m_densityAtMaxHeight;

AnKi/Shaders/Include/TraditionalDeferredShadingTypes.h

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

AnKi/Shaders/IndirectDiffuse.hlsl

@@ -20,7 +20,7 @@
 
 ANKI_SPECIALIZATION_CONSTANT_U32(kSampleCount, 0u);
 
-[[vk::binding(0)]] ConstantBuffer<ClusteredShadingUniforms> g_clusteredShading;
+[[vk::binding(0)]] ConstantBuffer<ClusteredShadingConstants> g_clusteredShading;
 [[vk::binding(1)]] StructuredBuffer<GlobalIlluminationProbe> g_giProbes;
 [[vk::binding(2)]] StructuredBuffer<Cluster> g_clusters;
 [[vk::binding(3)]] SamplerState g_linearAnyClampSampler;
@@ -37,12 +37,11 @@ ANKI_SPECIALIZATION_CONSTANT_U32(kSampleCount, 0u);
 
 ANKI_BINDLESS_SET(1)
 
-[[vk::push_constant]] ConstantBuffer<IndirectDiffuseUniforms> g_uniforms;
+[[vk::push_constant]] ConstantBuffer<IndirectDiffuseConstants> g_consts;
 
 Vec4 cheapProject(Vec4 point_)
 {
-	return projectPerspective(point_, g_uniforms.m_projectionMat.x, g_uniforms.m_projectionMat.y, g_uniforms.m_projectionMat.z,
-							  g_uniforms.m_projectionMat.w);
+	return projectPerspective(point_, g_consts.m_projectionMat.x, g_consts.m_projectionMat.y, g_consts.m_projectionMat.z, g_consts.m_projectionMat.w);
 }
 
 #if defined(ANKI_COMPUTE_SHADER)
@@ -52,13 +51,13 @@ RVec3 main([[vk::location(0)]] Vec2 uv : TEXCOORD, Vec4 svPosition : SV_POSITION
 #endif
 {
 #if defined(ANKI_COMPUTE_SHADER)
-	if(svDispatchThreadId.x >= g_uniforms.m_viewportSize.x || svDispatchThreadId.y >= g_uniforms.m_viewportSize.y)
+	if(svDispatchThreadId.x >= g_consts.m_viewportSize.x || svDispatchThreadId.y >= g_consts.m_viewportSize.y)
 	{
 		return;
 	}
 
 	const Vec2 fragCoord = Vec2(svDispatchThreadId.xy) + 0.5;
-	const Vec2 uv = fragCoord / g_uniforms.m_viewportSizef;
+	const Vec2 uv = fragCoord / g_consts.m_viewportSizef;
 #else
 	const Vec2 fragCoord = svPosition.xy;
 #endif
@@ -82,7 +81,7 @@ RVec3 main([[vk::location(0)]] Vec2 uv : TEXCOORD, Vec4 svPosition : SV_POSITION
 	if(ENABLE_SSGI)
 	{
 		// Find the projected radius
-		const RVec3 sphereLimit = viewPos + Vec3(g_uniforms.m_radius, 0.0, 0.0);
+		const RVec3 sphereLimit = viewPos + Vec3(g_consts.m_radius, 0.0, 0.0);
 		const RVec4 projSphereLimit = cheapProject(Vec4(sphereLimit, 1.0));
 		const RVec2 projSphereLimit2 = projSphereLimit.xy / projSphereLimit.w;
 		const RF32 projRadius = length(projSphereLimit2 - ndc);
@@ -94,10 +93,10 @@ RVec3 main([[vk::location(0)]] Vec2 uv : TEXCOORD, Vec4 svPosition : SV_POSITION
 		const UVec2 globalInvocation = UVec2(svPosition.xy);
 #endif
 		const UVec2 random = rand3DPCG16(UVec3(globalInvocation, g_clusteredShading.m_frame)).xy;
-		const F32 aspectRatio = g_uniforms.m_viewportSizef.x / g_uniforms.m_viewportSizef.y;
-		for(U32 i = 0u; i < g_uniforms.m_sampleCount; ++i)
+		const F32 aspectRatio = g_consts.m_viewportSizef.x / g_consts.m_viewportSizef.y;
+		for(U32 i = 0u; i < g_consts.m_sampleCount; ++i)
 		{
-			const Vec2 point_ = uvToNdc(hammersleyRandom16(i, g_uniforms.m_sampleCount, random)) * Vec2(1.0, aspectRatio);
+			const Vec2 point_ = uvToNdc(hammersleyRandom16(i, g_consts.m_sampleCount, random)) * Vec2(1.0, aspectRatio);
 			const Vec2 finalDiskPoint = ndc + point_ * projRadius;
 
 			// Do a cheap unproject in view space
@@ -111,8 +110,8 @@ RVec3 main([[vk::location(0)]] Vec2 uv : TEXCOORD, Vec4 svPosition : SV_POSITION
 			const F32 len = length(dir);
 			const Vec3 n = normalize(dir);
 			const F32 NoL = max(0.0, dot(viewNormal, n));
-			// const F32 distFactor = 1.0 - sin(min(1.0, len / g_uniforms.m_radius) * kPi / 2.0);
-			const F32 distFactor = 1.0 - min(1.0, len / g_uniforms.m_radius);
+			// const F32 distFactor = 1.0 - sin(min(1.0, len / g_consts.m_radius) * kPi / 2.0);
+			const F32 distFactor = 1.0 - min(1.0, len / g_consts.m_radius);
 
 			// Compute the UV for sampling the pyramid
 			const Vec2 crntFrameUv = ndcToUv(finalDiskPoint);
@@ -132,15 +131,15 @@ RVec3 main([[vk::location(0)]] Vec2 uv : TEXCOORD, Vec4 svPosition : SV_POSITION
 			outColor += c * w;
 
 			// Compute SSAO as well
-			ssao += max(dot(viewNormal, dir) + g_uniforms.m_ssaoBias, kEpsilonF32) / max(len * len, kEpsilonF32);
+			ssao += max(dot(viewNormal, dir) + g_consts.m_ssaoBias, kEpsilonF32) / max(len * len, kEpsilonF32);
 		}
 
-		const RF32 scount = 1.0 / g_uniforms.m_sampleCountf;
+		const RF32 scount = 1.0 / g_consts.m_sampleCountf;
 		outColor *= scount * 2.0 * kPi;
 		ssao *= scount;
 	}
 
-	ssao = min(1.0, 1.0 - ssao * g_uniforms.m_ssaoStrength);
+	ssao = min(1.0, 1.0 - ssao * g_consts.m_ssaoStrength);
 
 	if(ENABLE_PROBES)
 	{

AnKi/Shaders/IndirectDiffuseDenoise.hlsl

@@ -19,11 +19,11 @@
 [[vk::binding(3)]] RWTexture2D<RVec4> g_outUav;
 #endif
 
-[[vk::push_constant]] ConstantBuffer<IndirectDiffuseDenoiseUniforms> g_uniforms;
+[[vk::push_constant]] ConstantBuffer<IndirectDiffuseDenoiseConstants> g_consts;
 
 Vec3 unproject(Vec2 ndc, F32 depth)
 {
-	const Vec4 worldPos4 = mul(g_uniforms.m_invertedViewProjectionJitterMat, Vec4(ndc, depth, 1.0));
+	const Vec4 worldPos4 = mul(g_consts.m_invertedViewProjectionJitterMat, Vec4(ndc, depth, 1.0));
 	const Vec3 worldPos = worldPos4.xyz / worldPos4.w;
 	return worldPos;
 }
@@ -35,12 +35,12 @@ RVec3 main([[vk::location(0)]] Vec2 uv : TEXCOORD) : SV_TARGET0
 #endif
 {
 #if defined(ANKI_COMPUTE_SHADER)
-	if(skipOutOfBoundsInvocations(UVec2(THREAD_GROUP_SIZE_SQRT, THREAD_GROUP_SIZE_SQRT), g_uniforms.m_viewportSize, svDispatchThreadId))
+	if(skipOutOfBoundsInvocations(UVec2(THREAD_GROUP_SIZE_SQRT, THREAD_GROUP_SIZE_SQRT), g_consts.m_viewportSize, svDispatchThreadId))
 	{
 		return;
 	}
 
-	const Vec2 uv = (Vec2(svDispatchThreadId.xy) + 0.5) / g_uniforms.m_viewportSizef;
+	const Vec2 uv = (Vec2(svDispatchThreadId.xy) + 0.5) / g_consts.m_viewportSizef;
 #endif
 
 	// Reference
@@ -59,9 +59,9 @@ RVec3 main([[vk::location(0)]] Vec2 uv : TEXCOORD) : SV_TARGET0
 	RF32 weight = kEpsilonRF32;
 	Vec3 color = Vec3(0.0, 0.0, 0.0); // Keep it full precision because it may go to inf
 
-	for(F32 i = -g_uniforms.m_sampleCountDiv2; i <= g_uniforms.m_sampleCountDiv2; i += 1.0)
+	for(F32 i = -g_consts.m_sampleCountDiv2; i <= g_consts.m_sampleCountDiv2; i += 1.0)
 	{
-		const Vec2 texelSize = 1.0 / g_uniforms.m_viewportSizef;
+		const Vec2 texelSize = 1.0 / g_consts.m_viewportSizef;
 #if BLUR_ORIENTATION == 0
 		const Vec2 sampleUv = Vec2(uv.x + i * texelSize.x, uv.y);
 #else
@@ -71,7 +71,7 @@ RVec3 main([[vk::location(0)]] Vec2 uv : TEXCOORD) : SV_TARGET0
 		const F32 depthTap = g_depthTex.SampleLevel(g_linearAnyClampSampler, sampleUv, 0.0).r;
 
 		RF32 w = calculateBilateralWeightDepth(depthCenter, depthTap, 1.0);
-		// w *= gaussianWeight(0.4, abs(F32(i)) / (g_uniforms.m_sampleCountDiv2 * 2.0 + 1.0));
+		// w *= gaussianWeight(0.4, abs(F32(i)) / (g_consts.m_sampleCountDiv2 * 2.0 + 1.0));
 		weight += w;
 
 		color += g_toDenoiseTex.SampleLevel(g_linearAnyClampSampler, sampleUv, 0.0).xyz * w;

AnKi/Shaders/IndirectDiffuseVrsSriGeneration.ankiprog

@@ -27,7 +27,7 @@
 
 [[vk::binding(2)]] RWTexture2D<UVec4> g_sriImg;
 
-struct Uniforms
+struct Constants
 {
 	Vec2 m_oneOverViewportSize;
 	F32 m_thresholdMeters;
@@ -35,7 +35,7 @@ struct Uniforms
 	Mat4 m_invertedProjectionJitter;
 };
 
-[[vk::push_constant]] ConstantBuffer<Uniforms> g_unis;
+[[vk::push_constant]] ConstantBuffer<Constants> g_consts;
 
 #if SHARED_MEMORY
 // Ideally, we'd be able to calculate the min/max/average using subgroup operations, but there's no guarantee
@@ -48,11 +48,11 @@ groupshared U32 s_waveIndexInsideThreadGroup;
 
 F32 sampleViewPositionZ(Vec2 uv, I32 offsetX, I32 offsetY)
 {
-	uv += Vec2(offsetX, offsetY) * g_unis.m_oneOverViewportSize;
+	uv += Vec2(offsetX, offsetY) * g_consts.m_oneOverViewportSize;
 	const Vec2 ndc = uvToNdc(uv);
 	const F32 depth = g_inputTex.SampleLevel(g_nearestClampSampler, uv, 0.0).x;
 
-	const Vec4 v4 = mul(g_unis.m_invertedProjectionJitter, Vec4(ndc, depth, 1.0));
+	const Vec4 v4 = mul(g_consts.m_invertedProjectionJitter, Vec4(ndc, depth, 1.0));
 	return v4.z / v4.w;
 }
 
@@ -65,7 +65,7 @@ F32 sampleViewPositionZ(Vec2 uv, I32 offsetX, I32 offsetY)
 	ANKI_COMPUTE_WAVE_INDEX_INSIDE_THREADGROUP(svGroupIndex, s_waveIndexInsideThreadGroup, waveIndexInsideThreadGroup, wavesPerThreadGroup);
 #endif
 
-	const Vec2 uv = (Vec2(svDispatchThreadId.xy) * Vec2(REGION_SIZE_X, REGION_SIZE_Y) + 0.5) * g_unis.m_oneOverViewportSize;
+	const Vec2 uv = (Vec2(svDispatchThreadId.xy) * Vec2(REGION_SIZE_X, REGION_SIZE_Y) + 0.5) * g_consts.m_oneOverViewportSize;
 
 #if SRI_TEXEL_DIMENSION == 8
 	// Get positions
@@ -148,7 +148,7 @@ F32 sampleViewPositionZ(Vec2 uv, I32 offsetX, I32 offsetY)
 #endif
 
 		// Determine shading rate.
-		const F32 threshold1 = g_unis.m_thresholdMeters;
+		const F32 threshold1 = g_consts.m_thresholdMeters;
 		const F32 threshold2 = threshold1 * 0.4;
 
 		UVec2 rate;

AnKi/Shaders/IndirectSpecular.hlsl

@@ -13,7 +13,7 @@
 #include <AnKi/Shaders/SsRaymarching.hlsl>
 #include <AnKi/Shaders/ClusteredShadingFunctions.hlsl>
 
-[[vk::binding(0)]] ConstantBuffer<SsrUniforms> g_unis;
+[[vk::binding(0)]] ConstantBuffer<SsrConstants> g_consts;
 
 [[vk::binding(1)]] SamplerState g_trilinearClampSampler;
 [[vk::binding(2)]] Texture2D<RVec4> g_gbufferRt1;
@@ -28,7 +28,7 @@
 [[vk::binding(9)]] SamplerState g_trilinearRepeatSampler;
 [[vk::binding(10)]] Texture2D<RVec4> g_noiseTex;
 
-[[vk::binding(11)]] ConstantBuffer<ClusteredShadingUniforms> g_clusteredShading;
+[[vk::binding(11)]] ConstantBuffer<ClusteredShadingConstants> g_clusteredShading;
 [[vk::binding(12)]] StructuredBuffer<ReflectionProbe> g_reflectionProbes;
 [[vk::binding(13)]] StructuredBuffer<Cluster> g_clusters;
 
@@ -47,11 +47,11 @@ RVec3 main(Vec2 uv : TEXCOORD, Vec4 svPosition : SV_POSITION) : SV_TARGET0
 #endif
 {
 #if defined(ANKI_COMPUTE_SHADER)
-	if(any(svDispatchThreadId.xy >= g_unis.m_framebufferSize))
+	if(any(svDispatchThreadId.xy >= g_consts.m_framebufferSize))
 	{
 		return;
 	}
-	const Vec2 uv = (Vec2(svDispatchThreadId.xy) + 0.5) / Vec2(g_unis.m_framebufferSize);
+	const Vec2 uv = (Vec2(svDispatchThreadId.xy) + 0.5) / Vec2(g_consts.m_framebufferSize);
 #endif
 
 	// Read part of the G-buffer
@@ -62,16 +62,16 @@ RVec3 main(Vec2 uv : TEXCOORD, Vec4 svPosition : SV_POSITION) : SV_TARGET0
 	const F32 depth = g_depthRt.SampleLevel(g_trilinearClampSampler, uv, 0.0).r;
 
 	// Rand idx
-	const Vec2 noiseUv = Vec2(g_unis.m_framebufferSize) / kNoiseTexSize * uv;
-	const Vec3 noise = animateBlueNoise(g_noiseTex.SampleLevel(g_trilinearRepeatSampler, noiseUv, 0.0).rgb, g_unis.m_frameCount % 8u);
+	const Vec2 noiseUv = Vec2(g_consts.m_framebufferSize) / kNoiseTexSize * uv;
+	const Vec3 noise = animateBlueNoise(g_noiseTex.SampleLevel(g_trilinearRepeatSampler, noiseUv, 0.0).rgb, g_consts.m_frameCount % 8u);
 
 	// Get view pos
-	const Vec4 viewPos4 = mul(g_unis.m_invProjMat, Vec4(uvToNdc(uv), depth, 1.0));
+	const Vec4 viewPos4 = mul(g_consts.m_invProjMat, Vec4(uvToNdc(uv), depth, 1.0));
 	const Vec3 viewPos = viewPos4.xyz / viewPos4.w;
 
 	// Compute refl vector
 	const Vec3 viewDir = -normalize(viewPos);
-	const Vec3 viewNormal = mul(g_unis.m_normalMat, Vec4(worldNormal, 0.0));
+	const Vec3 viewNormal = mul(g_consts.m_normalMat, Vec4(worldNormal, 0.0));
 #if STOCHASTIC
 	const Vec3 reflDir = sampleReflectionVector(viewDir, viewNormal, roughness, noise.xy);
 #else
@@ -79,19 +79,19 @@ RVec3 main(Vec2 uv : TEXCOORD, Vec4 svPosition : SV_POSITION) : SV_TARGET0
 #endif
 
 	// Is rough enough to deserve SSR?
-	F32 ssrAttenuation = saturate(1.0f - pow(roughness / g_unis.m_roughnessCutoff, 16.0f));
+	F32 ssrAttenuation = saturate(1.0f - pow(roughness / g_consts.m_roughnessCutoff, 16.0f));
 
 	// Do the heavy work
 	Vec3 hitPoint;
 	if(ssrAttenuation > kEpsilonF32)
 	{
 		const U32 lod = 8u; // Use the max LOD for ray marching
-		const U32 step = g_unis.m_firstStepPixels;
+		const U32 step = g_consts.m_firstStepPixels;
 		const F32 stepf = F32(step);
 		const F32 minStepf = stepf / 4.0;
 		F32 hitAttenuation;
-		raymarchGroundTruth(viewPos, reflDir, uv, depth, g_unis.m_projMat, g_unis.m_maxSteps, g_depthRt, g_trilinearClampSampler, F32(lod),
-							g_unis.m_depthBufferSize, step, U32((stepf - minStepf) * noise.x + minStepf), hitPoint, hitAttenuation);
+		raymarchGroundTruth(viewPos, reflDir, uv, depth, g_consts.m_projMat, g_consts.m_maxSteps, g_depthRt, g_trilinearClampSampler, F32(lod),
+							g_consts.m_depthBufferSize, step, U32((stepf - minStepf) * noise.x + minStepf), hitPoint, hitAttenuation);
 
 		ssrAttenuation *= hitAttenuation;
 	}
@@ -105,7 +105,7 @@ RVec3 main(Vec2 uv : TEXCOORD, Vec4 svPosition : SV_POSITION) : SV_TARGET0
 	[branch] if(ssrAttenuation > 0.0)
 	{
 		const Vec3 gbufferNormal = unpackNormalFromGBuffer(g_gbufferRt2.SampleLevel(g_trilinearClampSampler, hitPoint.xy, 0.0));
-		const Vec3 hitNormal = mul(g_unis.m_normalMat, Vec4(gbufferNormal, 0.0));
+		const Vec3 hitNormal = mul(g_consts.m_normalMat, Vec4(gbufferNormal, 0.0));
 		F32 backFaceAttenuation;
 		rejectBackFaces(reflDir, hitNormal, backFaceAttenuation);
 
@@ -116,10 +116,10 @@ RVec3 main(Vec2 uv : TEXCOORD, Vec4 svPosition : SV_POSITION) : SV_TARGET0
 	[branch] if(ssrAttenuation > 0.0)
 	{
 		const F32 depth = g_depthRt.SampleLevel(g_trilinearClampSampler, hitPoint.xy, 0.0).r;
-		Vec4 viewPos4 = mul(g_unis.m_invProjMat, Vec4(uvToNdc(hitPoint.xy), depth, 1.0));
+		Vec4 viewPos4 = mul(g_consts.m_invProjMat, Vec4(uvToNdc(hitPoint.xy), depth, 1.0));
 		const F32 actualZ = viewPos4.z / viewPos4.w;
 
-		viewPos4 = mul(g_unis.m_invProjMat, Vec4(uvToNdc(hitPoint.xy), hitPoint.z, 1.0));
+		viewPos4 = mul(g_consts.m_invProjMat, Vec4(uvToNdc(hitPoint.xy), hitPoint.z, 1.0));
 		const F32 hitZ = viewPos4.z / viewPos4.w;
 
 		const F32 rejectionMeters = 1.0;
@@ -134,7 +134,7 @@ RVec3 main(Vec2 uv : TEXCOORD, Vec4 svPosition : SV_POSITION) : SV_TARGET0
 	[branch] if(ssrAttenuation > 0.0)
 	{
 		// Reproject the UV because you are reading the previous frame
-		const Vec4 v4 = mul(g_unis.m_prevViewProjMatMulInvViewProjMat, Vec4(uvToNdc(hitPoint.xy), hitPoint.z, 1.0));
+		const Vec4 v4 = mul(g_consts.m_prevViewProjMatMulInvViewProjMat, Vec4(uvToNdc(hitPoint.xy), hitPoint.z, 1.0));
 		hitPoint.xy = ndcToUv(v4.xy / v4.w);
 
 #if STOCHASTIC
@@ -142,7 +142,7 @@ RVec3 main(Vec2 uv : TEXCOORD, Vec4 svPosition : SV_POSITION) : SV_TARGET0
 		const F32 lod = 0.0;
 #else
 		// Compute the LOD based on the roughness
-		const F32 lod = F32(g_unis.m_lightBufferMipCount - 1u) * roughness;
+		const F32 lod = F32(g_consts.m_lightBufferMipCount - 1u) * roughness;
 #endif
 
 		// Read the light buffer

AnKi/Shaders/IrradianceDice.ankiprog

@@ -34,13 +34,13 @@ constexpr U32 kWorkgroupSize = U32(WORKGROUP_SIZE_XY) * U32(WORKGROUP_SIZE_XY);
 #if STORE_LOCATION == 0
 [[vk::binding(3)]] RWTexture3D<Vec4> g_irradianceVolume;
 
-struct Uniforms
+struct Constants
 {
 	IVec3 m_volumeTexel;
 	I32 m_nextTexelOffsetInU;
 };
 
-[[vk::push_constant]] ConstantBuffer<Uniforms> g_uniforms;
+[[vk::push_constant]] ConstantBuffer<Constants> g_consts;
 #else
 struct BufferOut
 {
@@ -210,15 +210,15 @@ RVec3 sampleLightShadingTexture(const U32 face, UVec3 svGroupThreadId)
 		g_irradianceVolume.GetDimensions(volumeSize.x, volumeSize.y, volumeSize.z);
 
 		const UVec3 subvolumeSize = UVec3(volumeSize.x / 6u, volumeSize.y, volumeSize.z);
-		const U32 cellIdx = g_uniforms.m_volumeTexel.z * subvolumeSize.x * subvolumeSize.y + g_uniforms.m_volumeTexel.y * subvolumeSize.x
-							+ g_uniforms.m_volumeTexel.x;
+		const U32 cellIdx =
+			g_consts.m_volumeTexel.z * subvolumeSize.x * subvolumeSize.y + g_consts.m_volumeTexel.y * subvolumeSize.x + g_consts.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_uniforms.m_volumeTexel.x + I32(f) * g_uniforms.m_nextTexelOffsetInU, g_uniforms.m_volumeTexel.y, g_uniforms.m_volumeTexel.z);
+			UVec3(g_consts.m_volumeTexel.x + I32(f) * g_consts.m_nextTexelOffsetInU, g_consts.m_volumeTexel.y, g_consts.m_volumeTexel.z);
 		g_irradianceVolume[storeUvw] = Vec4(toStoreValue, 0.0);
 #else
 		g_irradianceDisceResults[0].m_val[f] = toStoreValue.xyzx;

AnKi/Shaders/LightShading.ankiprog

@@ -16,7 +16,7 @@
 ANKI_SPECIALIZATION_CONSTANT_UVEC2(kTileCount, 0u);
 ANKI_SPECIALIZATION_CONSTANT_U32(kZSplitCount, 2u);
 
-[[vk::binding(0)]] ConstantBuffer<ClusteredShadingUniforms> g_clusteredShading;
+[[vk::binding(0)]] ConstantBuffer<ClusteredShadingConstants> g_clusteredShading;
 [[vk::binding(1)]] StructuredBuffer<PointLight> g_pointLights;
 [[vk::binding(1)]] StructuredBuffer<SpotLight> g_spotLights;
 [[vk::binding(2)]] Texture2D<Vec4> g_shadowAtlasTex;

AnKi/Shaders/LightShadingApplyFog.ankiprog

@@ -19,14 +19,14 @@ ANKI_SPECIALIZATION_CONSTANT_U32(kFinalZSplit, 1u);
 [[vk::binding(2)]] Texture2D g_depthRt;
 [[vk::binding(3)]] Texture3D<RVec4> g_fogVolume;
 
-struct Uniforms
+struct Constants
 {
 	Vec2 m_padding;
 	F32 m_near;
 	F32 m_far;
 };
 
-[[vk::push_constant]] ConstantBuffer<Uniforms> g_uniforms;
+[[vk::push_constant]] ConstantBuffer<Constants> g_consts;
 
 RVec4 main([[vk::location(0)]] Vec2 uv : TEXCOORD) : SV_TARGET0
 {
@@ -34,7 +34,7 @@ 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_uniforms.m_near, g_uniforms.m_far);
+	const F32 linearDepth = linearizeDepth(depth, g_consts.m_near, g_consts.m_far);
 	uvw.z = linearDepth * (F32(kZSplitCount) / F32(kFinalZSplit + 1u));
 
 	// Compute UV coordinates

AnKi/Shaders/LightShadingApplyIndirect.ankiprog

@@ -24,9 +24,9 @@
 [[vk::binding(7)]] Texture2D<Vec4> g_gbuffer1Tex;
 [[vk::binding(8)]] Texture2D<Vec4> g_gbuffer2Tex;
 [[vk::binding(9)]] Texture2D<RVec4> g_integrationLut;
-[[vk::binding(10)]] ConstantBuffer<ClusteredShadingUniforms> g_clusteredShading;
+[[vk::binding(10)]] ConstantBuffer<ClusteredShadingConstants> g_clusteredShading;
 
-struct Uniforms
+struct Constants
 {
 	F32 m_near;
 	F32 m_far;
@@ -34,7 +34,7 @@ struct Uniforms
 	F32 m_padding1;
 };
 
-[[vk::push_constant]] ConstantBuffer<Uniforms> g_uniforms;
+[[vk::push_constant]] ConstantBuffer<Constants> g_consts;
 
 RVec3 main([[vk::location(0)]] Vec2 uv : TEXCOORD) : SV_TARGET0
 {
@@ -51,17 +51,17 @@ RVec3 main([[vk::location(0)]] Vec2 uv : TEXCOORD) : SV_TARGET0
 		discard;
 	}
 
-	const F32 linearDepthCenter = linearizeDepth(depthCenter, g_uniforms.m_near, g_uniforms.m_far);
+	const F32 linearDepthCenter = linearizeDepth(depthCenter, g_consts.m_near, g_consts.m_far);
 
 	// Quad depths
 	Vec4 quarterDepths = g_quarterDepthTex.GatherRed(g_nearestAnyClampSampler, uv);
-	quarterDepths = linearizeDepth(quarterDepths, g_uniforms.m_near, g_uniforms.m_far);
+	quarterDepths = linearizeDepth(quarterDepths, g_consts.m_near, g_consts.m_far);
 
 	// Diff
 	const Vec4 diffs = abs(quarterDepths - linearDepthCenter);
 	const F32 maxDiff = max(diffs.x, max(diffs.y, max(diffs.z, diffs.w)));
 
-	const F32 depthThreshold = 0.2 / (g_uniforms.m_far - g_uniforms.m_near);
+	const F32 depthThreshold = 0.2 / (g_consts.m_far - g_consts.m_near);
 
 	// Do a neareset depth upscale
 	RVec3 diffuse = RVec3(0.0, 0.0, 0.0);

AnKi/Shaders/LightShadingSkybox.ankiprog

@@ -32,39 +32,39 @@ VertOut main(U32 vertId : SV_VERTEXID)
 #include <AnKi/Shaders/Functions.hlsl>
 
 #if METHOD == 0
-struct Uniforms
+struct Constants
 {
 	RVec3 m_solidColor;
 	F32 m_padding;
 };
 
-[[vk::push_constant]] ConstantBuffer<Uniforms> g_uniforms;
+[[vk::push_constant]] ConstantBuffer<Constants> g_consts;
 #else
 [[vk::binding(0)]] SamplerState g_trilinearAnySampler;
 [[vk::binding(1)]] Texture2D<RVec4> g_envMapTex;
 
-struct Uniforms
+struct Constants
 {
 	Mat4 m_invertedViewProjectionJitterMat;
 	Vec3 m_cameraPos;
 	F32 m_padding;
 };
 
-[[vk::push_constant]] ConstantBuffer<Uniforms> g_uniforms;
+[[vk::push_constant]] ConstantBuffer<Constants> g_consts;
 #endif
 
 RVec3 main([[vk::location(0)]] Vec2 uv : TEXCOORD) : SV_TARGET0
 {
 #if METHOD == 0
 	ANKI_MAYBE_UNUSED(uv);
-	return g_uniforms.m_solidColor;
+	return g_consts.m_solidColor;
 #else
 	const F32 depth = 1.0;
 	const Vec2 ndc = uvToNdc(uv);
-	const Vec4 worldPos4 = mul(g_uniforms.m_invertedViewProjectionJitterMat, Vec4(ndc, depth, 1.0));
+	const Vec4 worldPos4 = mul(g_consts.m_invertedViewProjectionJitterMat, Vec4(ndc, depth, 1.0));
 	const Vec3 worldPos = worldPos4.xyz / worldPos4.w;
 
-	const Vec3 eyeToFrag = normalize(worldPos - g_uniforms.m_cameraPos);
+	const Vec3 eyeToFrag = normalize(worldPos - g_consts.m_cameraPos);
 
 	const Vec2 uv3 = equirectangularMapping(eyeToFrag);
 

AnKi/Shaders/MaterialShadersCommon.hlsl

@@ -14,7 +14,7 @@
 ANKI_BINDLESS_SET(MaterialSet::kBindless)
 
 [[vk::binding(MaterialBinding::kTrilinearRepeatSampler, MaterialSet::kGlobal)]] SamplerState g_globalSampler;
-[[vk::binding(MaterialBinding::kGlobalUniforms, MaterialSet::kGlobal)]] ConstantBuffer<MaterialGlobalUniforms> g_globalUniforms;
+[[vk::binding(MaterialBinding::kGlobalConstants, MaterialSet::kGlobal)]] ConstantBuffer<MaterialGlobalConstants> g_globalConstants;
 [[vk::binding(MaterialBinding::kGpuScene, MaterialSet::kGlobal)]] ByteAddressBuffer g_gpuScene;
 
 // Unified geom:
@@ -31,7 +31,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::kClusterShadingUniforms, MaterialSet::kGlobal)]] ConstantBuffer<ClusteredShadingUniforms> g_clusteredShading;
+[[vk::binding(MaterialBinding::kClusterShadingConstants, MaterialSet::kGlobal)]] ConstantBuffer<ClusteredShadingConstants> g_clusteredShading;
 [[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.hlsl

@@ -17,14 +17,14 @@ constexpr F32 kMaxHistoryLength = 16.0;
 [[vk::binding(3)]] Texture2D g_velocityTex;
 [[vk::binding(4)]] Texture2D g_historyLengthTex;
 
-struct Uniforms
+struct Constants
 {
 	Mat4 m_reprojectionMat;
 	Mat4 m_viewProjectionInvMat;
 	Mat4 m_prevViewProjectionInvMat;
 };
 
-[[vk::binding(5)]] ConstantBuffer<Uniforms> g_unis;
+[[vk::binding(5)]] ConstantBuffer<Constants> g_consts;
 
 #if defined(ANKI_COMPUTE_SHADER)
 [[vk::binding(6)]] RWTexture2D<Vec2> g_motionVectorsUav;
@@ -78,14 +78,14 @@ F32 computeRejectionFactor(Vec2 uv, Vec2 historyUv)
 {
 	Vec3 boxMin;
 	Vec3 boxMax;
-	getMinMaxWorldPositions(g_currentDepthTex, uv, g_unis.m_viewProjectionInvMat, boxMin, boxMax);
+	getMinMaxWorldPositions(g_currentDepthTex, uv, g_consts.m_viewProjectionInvMat, boxMin, boxMax);
 
 #if 0
 	const F32 historyDepth = g_historyDepthTex.SampleLevel(g_linearAnyClampSampler, historyUv, 0.0).r;
-	const Vec3 historyWorldPos = clipToWorld(Vec4(uvToNdc(historyUv), historyDepth, 1.0), g_unis.m_prevViewProjectionInvMat);
+	const Vec3 historyWorldPos = clipToWorld(Vec4(uvToNdc(historyUv), historyDepth, 1.0), g_consts.m_prevViewProjectionInvMat);
 #else
 	// Average gives more rejection so less ghosting
-	const Vec3 historyWorldPos = getAverageWorldPosition(g_historyDepthTex, historyUv, g_unis.m_prevViewProjectionInvMat);
+	const Vec3 historyWorldPos = getAverageWorldPosition(g_historyDepthTex, historyUv, g_consts.m_prevViewProjectionInvMat);
 #endif
 	const Vec3 clampedHistoryWorldPos = clamp(historyWorldPos, boxMin, boxMax);
 
@@ -137,7 +137,7 @@ FragOut main(Vec2 uv : TEXCOORD)
 	}
 	else
 	{
-		const Vec4 v4 = mul(g_unis.m_reprojectionMat, Vec4(uvToNdc(uv), depth, 1.0));
+		const Vec4 v4 = mul(g_consts.m_reprojectionMat, Vec4(uvToNdc(uv), depth, 1.0));
 		historyUv = ndcToUv(v4.xy / v4.w);
 	}
 

AnKi/Shaders/RtShadowsDenoise.ankiprog

@@ -23,11 +23,11 @@ ANKI_SPECIALIZATION_CONSTANT_U32(kMaxSampleCount, 3u);
 [[vk::binding(5)]] Texture2D<Vec4> g_historyLengthTex;
 [[vk::binding(6)]] RWTexture2D<Vec4> g_outUav;
 
-[[vk::push_constant]] ConstantBuffer<RtShadowsDenoiseUniforms> g_unis;
+[[vk::push_constant]] ConstantBuffer<RtShadowsDenoiseConstants> g_consts;
 
 Vec3 unproject(Vec2 ndc, F32 depth)
 {
-	const Vec4 worldPos4 = mul(g_unis.m_invViewProjMat, Vec4(ndc, depth, 1.0));
+	const Vec4 worldPos4 = mul(g_consts.m_invViewProjMat, Vec4(ndc, depth, 1.0));
 	const Vec3 worldPos = worldPos4.xyz / worldPos4.w;
 	return worldPos;
 }

AnKi/Shaders/RtShadowsHit.ankiprog

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

AnKi/Shaders/RtShadowsRayGen.ankiprog

@@ -17,7 +17,7 @@
 
 #define SET 2u
 
-[[vk::binding(0, SET)]] ConstantBuffer<ClusteredShadingUniforms> g_clusteredShading;
+[[vk::binding(0, SET)]] ConstantBuffer<ClusteredShadingConstants> g_clusteredShading;
 [[vk::binding(1, SET)]] StructuredBuffer<Cluster> g_clusters; // TODO: rm
 
 [[vk::binding(2, SET)]] SamplerState g_trilinearRepeatSampler;

AnKi/Shaders/RtShadowsSbtBuild.ankiprog

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