Some code style refactoring #7

AnKi/Core/GpuMemoryPools.cpp

@@ -28,10 +28,10 @@ Error VertexGpuMemoryPool::init(GenericMemoryPoolAllocator<U8> alloc, GrManager*
 		return Error::kUserData;
 	}
 
-	bufferInit.m_usage = BufferUsageBit::VERTEX | BufferUsageBit::INDEX | BufferUsageBit::TRANSFER_DESTINATION;
+	bufferInit.m_usage = BufferUsageBit::kVertex | BufferUsageBit::kIndex | BufferUsageBit::kTransferDestination;
 	if(gr->getDeviceCapabilities().m_rayTracingEnabled)
 	{
-		bufferInit.m_usage |= BufferUsageBit::ACCELERATION_STRUCTURE_BUILD;
+		bufferInit.m_usage |= BufferUsageBit::kAccelerationStructureBuild;
 	}
 
 	m_vertBuffer = gr->newBuffer(bufferInit);
@@ -87,18 +87,18 @@ Error StagingGpuMemoryPool::init(GrManager* gr, const ConfigSet& cfg)
 	m_perFrameBuffers[StagingGpuMemoryType::TEXTURE].m_size = cfg.getCoreTextureBufferPerFrameMemorySize();
 
 	initBuffer(StagingGpuMemoryType::UNIFORM, gr->getDeviceCapabilities().m_uniformBufferBindOffsetAlignment,
-			   gr->getDeviceCapabilities().m_uniformBufferMaxRange, BufferUsageBit::ALL_UNIFORM, *gr);
+			   gr->getDeviceCapabilities().m_uniformBufferMaxRange, BufferUsageBit::kAllUniform, *gr);
 
 	initBuffer(StagingGpuMemoryType::STORAGE,
 			   max(gr->getDeviceCapabilities().m_storageBufferBindOffsetAlignment,
 				   gr->getDeviceCapabilities().m_sbtRecordAlignment),
-			   gr->getDeviceCapabilities().m_storageBufferMaxRange, BufferUsageBit::ALL_STORAGE | BufferUsageBit::SBT,
+			   gr->getDeviceCapabilities().m_storageBufferMaxRange, BufferUsageBit::kAllStorage | BufferUsageBit::kSBT,
 			   *gr);
 
-	initBuffer(StagingGpuMemoryType::VERTEX, 16, kMaxU32, BufferUsageBit::VERTEX | BufferUsageBit::INDEX, *gr);
+	initBuffer(StagingGpuMemoryType::VERTEX, 16, kMaxU32, BufferUsageBit::kVertex | BufferUsageBit::kIndex, *gr);
 
 	initBuffer(StagingGpuMemoryType::TEXTURE, gr->getDeviceCapabilities().m_textureBufferBindOffsetAlignment,
-			   gr->getDeviceCapabilities().m_textureBufferMaxRange, BufferUsageBit::ALL_TEXTURE, *gr);
+			   gr->getDeviceCapabilities().m_textureBufferMaxRange, BufferUsageBit::kAllTexture, *gr);
 
 	return Error::kNone;
 }

AnKi/Gr/Buffer.h

@@ -19,7 +19,7 @@ class BufferInitInfo : public GrBaseInitInfo
 {
 public:
 	PtrSize m_size = 0;
-	BufferUsageBit m_usage = BufferUsageBit::NONE;
+	BufferUsageBit m_usage = BufferUsageBit::kNone;
 	BufferMapAccessBit m_mapAccess = BufferMapAccessBit::NONE;
 
 	BufferInitInfo(CString name = {})
@@ -108,7 +108,7 @@ public:
 
 protected:
 	PtrSize m_size = 0;
-	BufferUsageBit m_usage = BufferUsageBit::NONE;
+	BufferUsageBit m_usage = BufferUsageBit::kNone;
 	BufferMapAccessBit m_access = BufferMapAccessBit::NONE;
 	U64 m_gpuAddress = 0;
 

AnKi/Gr/Common.h

@@ -597,116 +597,116 @@ ANKI_PURE const ShaderVariableDataTypeInfo& getShaderVariableDataTypeInfo(Shader
 /// Occlusion query result bit.
 enum class OcclusionQueryResultBit : U8
 {
-	NOT_AVAILABLE = 1 << 0,
-	VISIBLE = 1 << 1,
-	NOT_VISIBLE = 1 << 2
+	kNotAvailable = 1 << 0,
+	kVisible = 1 << 1,
+	kNotVisible = 1 << 2
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(OcclusionQueryResultBit)
 
 /// Occlusion query result.
 enum class OcclusionQueryResult : U8
 {
-	NOT_AVAILABLE,
-	VISIBLE,
-	NOT_VISIBLE
+	kNotAvailable,
+	kVisible,
+	kNotVisible
 };
 
 /// Timestamp query result.
 enum class TimestampQueryResult : U8
 {
-	NOT_AVAILABLE,
-	AVAILABLE
+	kNotAvailable,
+	kAvailable
 };
 
 /// Attachment load operation.
 enum class AttachmentLoadOperation : U8
 {
-	LOAD,
-	CLEAR,
-	DONT_CARE
+	kLoad,
+	kClear,
+	kDontCare
 };
 
 /// Attachment store operation.
 enum class AttachmentStoreOperation : U8
 {
-	STORE,
-	DONT_CARE
+	kStore,
+	kDontCare
 };
 
 /// Buffer usage modes.
-/// The graphics work consists of the following pipes: INDIRECT, GEOMETRY (all programmable and fixed function geometry
-/// stages) and finaly FRAGMENT.
-/// The compute from the consists of the following: INDIRECT and COMPUTE.
-/// The trace rays from the: INDIRECT and TRACE_RAYS
+/// The graphics work consists of the following pipes: indirect, geometry (all programmable and fixed function geometry
+/// stages) and finaly fragment.
+/// The compute from the consists of the following: indirect and compute.
+/// The trace rays from the: indirect and trace_rays
 /// !!WARNING!! If you change this remember to change PrivateBufferUsageBit.
 enum class BufferUsageBit : U64
 {
-	NONE = 0,
+	kNone = 0,
 
-	UNIFORM_GEOMETRY = 1ull << 0ull,
-	UNIFORM_FRAGMENT = 1ull << 1ull,
-	UNIFORM_COMPUTE = 1ull << 2ull,
-	UNIFORM_TRACE_RAYS = 1ull << 3ull,
-
-	STORAGE_GEOMETRY_READ = 1ull << 4ull,
-	STORAGE_GEOMETRY_WRITE = 1ull << 5ull,
-	STORAGE_FRAGMENT_READ = 1ull << 6ull,
-	STORAGE_FRAGMENT_WRITE = 1ull << 7ull,
-	STORAGE_COMPUTE_READ = 1ull << 8ull,
-	STORAGE_COMPUTE_WRITE = 1ull << 9ull,
-	STORAGE_TRACE_RAYS_READ = 1ull << 10ull,
-	STORAGE_TRACE_RAYS_WRITE = 1ull << 11ull,
-
-	TEXTURE_GEOMETRY_READ = 1ull << 12ull,
-	TEXTURE_GEOMETRY_WRITE = 1ull << 13ull,
-	TEXTURE_FRAGMENT_READ = 1ull << 14ull,
-	TEXTURE_FRAGMENT_WRITE = 1ull << 15ull,
-	TEXTURE_COMPUTE_READ = 1ull << 16ull,
-	TEXTURE_COMPUTE_WRITE = 1ull << 17ull,
-	TEXTURE_TRACE_RAYS_READ = 1ull << 18ull,
-	TEXTURE_TRACE_RAYS_WRITE = 1ull << 19ull,
-
-	INDEX = 1ull << 20ull,
-	VERTEX = 1ull << 21ull,
-
-	INDIRECT_COMPUTE = 1ull << 22ll,
-	INDIRECT_DRAW = 1ull << 23ull,
-	INDIRECT_TRACE_RAYS = 1ull << 24ull,
-
-	TRANSFER_SOURCE = 1ull << 25ull,
-	TRANSFER_DESTINATION = 1ull << 26ull,
-
-	ACCELERATION_STRUCTURE_BUILD = 1ull << 27ull, ///< Will be used as a position or index buffer in a BLAS build.
-	SBT = 1ull << 28ull, ///< Will be used as SBT in a traceRays() command.
+	kUniformGeometry = 1ull << 0ull,
+	kUniformFragment = 1ull << 1ull,
+	kUniformCompute = 1ull << 2ull,
+	kUniformTraceRays = 1ull << 3ull,
+
+	kStorageGeometryRead = 1ull << 4ull,
+	kStorageGeometryWrite = 1ull << 5ull,
+	kStorageFragmentRead = 1ull << 6ull,
+	kStorageFragmentWrite = 1ull << 7ull,
+	kStorageComputeRead = 1ull << 8ull,
+	kStorageComputeWrite = 1ull << 9ull,
+	kStorageTraceRaysRead = 1ull << 10ull,
+	kStorageTraceRaysWrite = 1ull << 11ull,
+
+	kTextureGeometryRead = 1ull << 12ull,
+	kTextureGeometryWrite = 1ull << 13ull,
+	kTextureFragmentRead = 1ull << 14ull,
+	kTextureFragmentWrite = 1ull << 15ull,
+	kTextureComputeRead = 1ull << 16ull,
+	kTextureComputeWrite = 1ull << 17ull,
+	kTextureTraceRaysRead = 1ull << 18ull,
+	kTextureTraceRaysWrite = 1ull << 19ull,
+
+	kIndex = 1ull << 20ull,
+	kVertex = 1ull << 21ull,
+
+	kIndirectCompute = 1ull << 22ll,
+	kIndirectDraw = 1ull << 23ull,
+	kIndirectTraceRays = 1ull << 24ull,
+
+	kTransferSource = 1ull << 25ull,
+	kTransferDestination = 1ull << 26ull,
+
+	kAccelerationStructureBuild = 1ull << 27ull, ///< Will be used as a position or index buffer in a BLAS build.
+	kSBT = 1ull << 28ull, ///< Will be used as SBT in a traceRays() command.
 
 	// Derived
-	ALL_UNIFORM = UNIFORM_GEOMETRY | UNIFORM_FRAGMENT | UNIFORM_COMPUTE | UNIFORM_TRACE_RAYS,
-	ALL_STORAGE = STORAGE_GEOMETRY_READ | STORAGE_GEOMETRY_WRITE | STORAGE_FRAGMENT_READ | STORAGE_FRAGMENT_WRITE
-				  | STORAGE_COMPUTE_READ | STORAGE_COMPUTE_WRITE | STORAGE_TRACE_RAYS_READ | STORAGE_TRACE_RAYS_WRITE,
-	ALL_TEXTURE = TEXTURE_GEOMETRY_READ | TEXTURE_GEOMETRY_WRITE | TEXTURE_FRAGMENT_READ | TEXTURE_FRAGMENT_WRITE
-				  | TEXTURE_COMPUTE_READ | TEXTURE_COMPUTE_WRITE | TEXTURE_TRACE_RAYS_READ | TEXTURE_TRACE_RAYS_WRITE,
-	ALL_INDIRECT = INDIRECT_COMPUTE | INDIRECT_DRAW | INDIRECT_TRACE_RAYS,
-	ALL_TRANSFER = TRANSFER_SOURCE | TRANSFER_DESTINATION,
-
-	ALL_GEOMETRY = UNIFORM_GEOMETRY | STORAGE_GEOMETRY_READ | STORAGE_GEOMETRY_WRITE | TEXTURE_GEOMETRY_READ
-				   | TEXTURE_GEOMETRY_WRITE | INDEX | VERTEX,
-	ALL_FRAGMENT = UNIFORM_FRAGMENT | STORAGE_FRAGMENT_READ | STORAGE_FRAGMENT_WRITE | TEXTURE_FRAGMENT_READ
-				   | TEXTURE_FRAGMENT_WRITE,
-	ALL_GRAPHICS = ALL_GEOMETRY | ALL_FRAGMENT | INDIRECT_DRAW,
-	ALL_COMPUTE = UNIFORM_COMPUTE | STORAGE_COMPUTE_READ | STORAGE_COMPUTE_WRITE | TEXTURE_COMPUTE_READ
-				  | TEXTURE_COMPUTE_WRITE | INDIRECT_COMPUTE,
-	ALL_TRACE_RAYS = UNIFORM_TRACE_RAYS | STORAGE_TRACE_RAYS_READ | STORAGE_TRACE_RAYS_WRITE | TEXTURE_TRACE_RAYS_READ
-					 | TEXTURE_TRACE_RAYS_WRITE | INDIRECT_TRACE_RAYS | SBT,
-
-	ALL_RAY_TRACING = ALL_TRACE_RAYS | ACCELERATION_STRUCTURE_BUILD,
-	ALL_READ = ALL_UNIFORM | STORAGE_GEOMETRY_READ | STORAGE_FRAGMENT_READ | STORAGE_COMPUTE_READ
-			   | STORAGE_TRACE_RAYS_READ | TEXTURE_GEOMETRY_READ | TEXTURE_FRAGMENT_READ | TEXTURE_COMPUTE_READ
-			   | TEXTURE_TRACE_RAYS_READ | INDEX | VERTEX | INDIRECT_COMPUTE | INDIRECT_DRAW | INDIRECT_TRACE_RAYS
-			   | TRANSFER_SOURCE | ACCELERATION_STRUCTURE_BUILD | SBT,
-	ALL_WRITE = STORAGE_GEOMETRY_WRITE | STORAGE_FRAGMENT_WRITE | STORAGE_COMPUTE_WRITE | STORAGE_TRACE_RAYS_WRITE
-				| TEXTURE_GEOMETRY_WRITE | TEXTURE_FRAGMENT_WRITE | TEXTURE_COMPUTE_WRITE | TEXTURE_TRACE_RAYS_WRITE
-				| TRANSFER_DESTINATION,
-	ALL = ALL_READ | ALL_WRITE,
+	kAllUniform = kUniformGeometry | kUniformFragment | kUniformCompute | kUniformTraceRays,
+	kAllStorage = kStorageGeometryRead | kStorageGeometryWrite | kStorageFragmentRead | kStorageFragmentWrite
+				  | kStorageComputeRead | kStorageComputeWrite | kStorageTraceRaysRead | kStorageTraceRaysWrite,
+	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,
+	kAllGraphics = kAllGeometry | kAllFragment | kIndirectDraw,
+	kAllCompute = kUniformCompute | kStorageComputeRead | kStorageComputeWrite | kTextureComputeRead
+				  | kTextureComputeWrite | kIndirectCompute,
+	kAllTraceRays = kUniformTraceRays | kStorageTraceRaysRead | kStorageTraceRaysWrite | kTextureTraceRaysRead
+					| kTextureTraceRaysWrite | kIndirectTraceRays | kSBT,
+
+	kAllRayTracing = kAllTraceRays | kAccelerationStructureBuild,
+	kAllRead = kAllUniform | kStorageGeometryRead | kStorageFragmentRead | kStorageComputeRead | kStorageTraceRaysRead
+			   | kTextureGeometryRead | kTextureFragmentRead | kTextureComputeRead | kTextureTraceRaysRead | kIndex
+			   | kVertex | kIndirectCompute | kIndirectDraw | kIndirectTraceRays | kTransferSource
+			   | kAccelerationStructureBuild | kSBT,
+	kAllWrite = kStorageGeometryWrite | kStorageFragmentWrite | kStorageComputeWrite | kStorageTraceRaysWrite
+				| kTextureGeometryWrite | kTextureFragmentWrite | kTextureComputeWrite | kTextureTraceRaysWrite
+				| kTransferDestination,
+	kAll = kAllRead | kAllWrite,
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(BufferUsageBit)
 
@@ -1040,8 +1040,8 @@ class BufferBarrierInfo
 {
 public:
 	Buffer* m_buffer = nullptr;
-	BufferUsageBit m_previousUsage = BufferUsageBit::NONE;
-	BufferUsageBit m_nextUsage = BufferUsageBit::NONE;
+	BufferUsageBit m_previousUsage = BufferUsageBit::kNone;
+	BufferUsageBit m_nextUsage = BufferUsageBit::kNone;
 	PtrSize m_offset = 0;
 	PtrSize m_size = 0;
 };

AnKi/Gr/Framebuffer.h

@@ -19,11 +19,11 @@ class FramebufferAttachmentInfo
 public:
 	TextureViewPtr m_textureView;
 
-	AttachmentLoadOperation m_loadOperation = AttachmentLoadOperation::CLEAR;
-	AttachmentStoreOperation m_storeOperation = AttachmentStoreOperation::STORE;
+	AttachmentLoadOperation m_loadOperation = AttachmentLoadOperation::kClear;
+	AttachmentStoreOperation m_storeOperation = AttachmentStoreOperation::kStore;
 
-	AttachmentLoadOperation m_stencilLoadOperation = AttachmentLoadOperation::CLEAR;
-	AttachmentStoreOperation m_stencilStoreOperation = AttachmentStoreOperation::STORE;
+	AttachmentLoadOperation m_stencilLoadOperation = AttachmentLoadOperation::kClear;
+	AttachmentStoreOperation m_stencilStoreOperation = AttachmentStoreOperation::kStore;
 
 	ClearValue m_clearValue;
 };

AnKi/Gr/Gl/BufferImpl.cpp

@@ -22,12 +22,12 @@ void BufferImpl::init()
 	// This is a guess, not very important since DSA doesn't care about it on creation
 	m_target = GL_ARRAY_BUFFER;
 
-	if((usage & BufferUsageBit::UNIFORM_ALL) != BufferUsageBit::NONE)
+	if((usage & BufferUsageBit::UNIFORM_ALL) != BufferUsageBit::kNone)
 	{
 		m_target = GL_UNIFORM_BUFFER;
 	}
 
-	if((usage & BufferUsageBit::STORAGE_ALL) != BufferUsageBit::NONE)
+	if((usage & BufferUsageBit::STORAGE_ALL) != BufferUsageBit::kNone)
 	{
 		m_target = GL_SHADER_STORAGE_BUFFER;
 	}
@@ -37,7 +37,7 @@ void BufferImpl::init()
 	//
 	GLbitfield flags = 0;
 	Bool shouldMap = false;
-	if((usage & BufferUsageBit::TRANSFER_ALL) != BufferUsageBit::NONE)
+	if((usage & BufferUsageBit::TRANSFER_ALL) != BufferUsageBit::kNone)
 	{
 		flags |= GL_DYNAMIC_STORAGE_BIT;
 	}

AnKi/Gr/Gl/CommandBuffer.cpp

@@ -1317,12 +1317,12 @@ void CommandBuffer::setBufferBarrier(BufferPtr buff, BufferUsageBit prevUsage, B
 		d |= GL_SHADER_STORAGE_BARRIER_BIT;
 	}
 
-	if(!!(all & BufferUsageBit::INDEX))
+	if(!!(all & BufferUsageBit::kIndex))
 	{
 		d |= GL_ELEMENT_ARRAY_BARRIER_BIT;
 	}
 
-	if(!!(all & BufferUsageBit::VERTEX))
+	if(!!(all & BufferUsageBit::kVertex))
 	{
 		d |= GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT;
 	}

AnKi/Gr/Gl/FramebufferImpl.cpp

@@ -37,7 +37,7 @@ Error FramebufferImpl::init(const FramebufferInitInfo& init)
 
 		m_drawBuffers[i] = binding;
 
-		if(att.m_loadOperation == AttachmentLoadOperation::DONT_CARE)
+		if(att.m_loadOperation == AttachmentLoadOperation::kDontCare)
 		{
 			m_invalidateBuffers[m_invalidateBuffersCount++] = binding;
 		}
@@ -78,7 +78,7 @@ Error FramebufferImpl::init(const FramebufferInitInfo& init)
 
 		attachTextureInternal(binding, viewImpl, att);
 
-		if(att.m_loadOperation == AttachmentLoadOperation::DONT_CARE)
+		if(att.m_loadOperation == AttachmentLoadOperation::kDontCare)
 		{
 			m_invalidateBuffers[m_invalidateBuffersCount++] = binding;
 		}
@@ -96,10 +96,10 @@ Error FramebufferImpl::init(const FramebufferInitInfo& init)
 
 		// Misc
 		m_clearDepth = !!(viewImpl.getSubresource().m_depthStencilAspect & DepthStencilAspectBit::kDepth)
-					   && att.m_loadOperation == AttachmentLoadOperation::CLEAR;
+					   && att.m_loadOperation == AttachmentLoadOperation::kClear;
 
 		m_clearStencil = !!(viewImpl.getSubresource().m_depthStencilAspect & DepthStencilAspectBit::STENCIL)
-						 && att.m_stencilLoadOperation == AttachmentLoadOperation::CLEAR;
+						 && att.m_stencilLoadOperation == AttachmentLoadOperation::kClear;
 	}
 
 	// Check completeness
@@ -187,7 +187,7 @@ void FramebufferImpl::bind(const GlState& state, U32 minx, U32 miny, U32 width,
 	{
 		const FramebufferAttachmentInfo& att = m_in.m_colorAttachments[i];
 
-		if(att.m_loadOperation == AttachmentLoadOperation::CLEAR)
+		if(att.m_loadOperation == AttachmentLoadOperation::kClear)
 		{
 			// Enable write mask in case a pipeline changed it (else no clear will happen) and then restore state
 			Bool restore = false;

AnKi/Gr/Gl/OcclusionQueryImpl.cpp

@@ -28,14 +28,14 @@ void OcclusionQueryImpl::end()
 OcclusionQueryResult OcclusionQueryImpl::getResult() const
 {
 	ANKI_ASSERT(isCreated());
-	OcclusionQueryResult result = OcclusionQueryResult::NOT_AVAILABLE;
+	OcclusionQueryResult result = OcclusionQueryResult::kNotAvailable;
 	GLuint params;
 	glGetQueryObjectuiv(m_glName, GL_QUERY_RESULT_AVAILABLE, &params);
 
 	if(params != 0)
 	{
 		glGetQueryObjectuiv(m_glName, GL_QUERY_RESULT, &params);
-		result = (params == 1) ? OcclusionQueryResult::VISIBLE : OcclusionQueryResult::NOT_VISIBLE;
+		result = (params == 1) ? OcclusionQueryResult::kVisible : OcclusionQueryResult::kNotVisible;
 	}
 
 	return result;

AnKi/Gr/RenderGraph.cpp

@@ -606,7 +606,7 @@ Bool RenderGraph::passADependsOnB(const RenderPassDescriptionBase& a, const Rend
 						continue;
 					}
 
-					if(!((aDep.m_buffer.m_usage | bDep.m_buffer.m_usage) & BufferUsageBit::ALL_WRITE))
+					if(!((aDep.m_buffer.m_usage | bDep.m_buffer.m_usage) & BufferUsageBit::kAllWrite))
 					{
 						// Don't care about read to read deps
 						continue;
@@ -1439,10 +1439,10 @@ void RenderGraph::getStatistics(RenderGraphStatistics& statistics) const
 	{
 		Second start, end;
 		[[maybe_unused]] TimestampQueryResult res = m_statistics.m_timestamps[oldFrame * 2]->getResult(start);
-		ANKI_ASSERT(res == TimestampQueryResult::AVAILABLE);
+		ANKI_ASSERT(res == TimestampQueryResult::kAvailable);
 
 		res = m_statistics.m_timestamps[oldFrame * 2 + 1]->getResult(end);
-		ANKI_ASSERT(res == TimestampQueryResult::AVAILABLE);
+		ANKI_ASSERT(res == TimestampQueryResult::kAvailable);
 
 		const Second diff = end - start;
 		statistics.m_gpuTime = diff;
@@ -1513,26 +1513,26 @@ StringAuto RenderGraph::bufferUsageToStr(StackAllocator<U8>& alloc, BufferUsageB
 			slist.pushBackSprintf("%s", #u); \
 		}
 
-	ANKI_BUFF_USAGE(UNIFORM_GEOMETRY);
-	ANKI_BUFF_USAGE(UNIFORM_FRAGMENT);
-	ANKI_BUFF_USAGE(UNIFORM_COMPUTE);
-	ANKI_BUFF_USAGE(UNIFORM_TRACE_RAYS);
-	ANKI_BUFF_USAGE(STORAGE_GEOMETRY_READ);
-	ANKI_BUFF_USAGE(STORAGE_GEOMETRY_WRITE);
-	ANKI_BUFF_USAGE(STORAGE_FRAGMENT_READ);
-	ANKI_BUFF_USAGE(STORAGE_FRAGMENT_WRITE);
-	ANKI_BUFF_USAGE(STORAGE_COMPUTE_READ);
-	ANKI_BUFF_USAGE(STORAGE_COMPUTE_WRITE);
-	ANKI_BUFF_USAGE(STORAGE_TRACE_RAYS_READ);
-	ANKI_BUFF_USAGE(STORAGE_TRACE_RAYS_WRITE);
-	ANKI_BUFF_USAGE(TEXTURE_GEOMETRY_READ);
-	ANKI_BUFF_USAGE(TEXTURE_GEOMETRY_WRITE);
-	ANKI_BUFF_USAGE(TEXTURE_FRAGMENT_READ);
-	ANKI_BUFF_USAGE(TEXTURE_FRAGMENT_WRITE);
-	ANKI_BUFF_USAGE(TEXTURE_COMPUTE_READ);
-	ANKI_BUFF_USAGE(TEXTURE_COMPUTE_WRITE);
-	ANKI_BUFF_USAGE(TEXTURE_TRACE_RAYS_READ);
-	ANKI_BUFF_USAGE(TEXTURE_TRACE_RAYS_WRITE);
+	ANKI_BUFF_USAGE(kUniformGeometry);
+	ANKI_BUFF_USAGE(kUniformFragment);
+	ANKI_BUFF_USAGE(kUniformCompute);
+	ANKI_BUFF_USAGE(kUniformTraceRays);
+	ANKI_BUFF_USAGE(kStorageGeometryRead);
+	ANKI_BUFF_USAGE(kStorageGeometryWrite);
+	ANKI_BUFF_USAGE(kStorageFragmentRead);
+	ANKI_BUFF_USAGE(kStorageFragmentWrite);
+	ANKI_BUFF_USAGE(kStorageComputeRead);
+	ANKI_BUFF_USAGE(kStorageComputeWrite);
+	ANKI_BUFF_USAGE(kStorageTraceRaysRead);
+	ANKI_BUFF_USAGE(kStorageTraceRaysWrite);
+	ANKI_BUFF_USAGE(kTextureGeometryRead);
+	ANKI_BUFF_USAGE(kTextureGeometryWrite);
+	ANKI_BUFF_USAGE(kTextureFragmentRead);
+	ANKI_BUFF_USAGE(kTextureFragmentWrite);
+	ANKI_BUFF_USAGE(kTextureComputeRead);
+	ANKI_BUFF_USAGE(kTextureComputeWrite);
+	ANKI_BUFF_USAGE(kTextureTraceRaysRead);
+	ANKI_BUFF_USAGE(kTextureTraceRaysWrite);
 	ANKI_BUFF_USAGE(INDEX);
 	ANKI_BUFF_USAGE(VERTEX);
 	ANKI_BUFF_USAGE(INDIRECT_COMPUTE);

AnKi/Gr/RenderGraph.h

@@ -395,12 +395,12 @@ class FramebufferDescriptionAttachment
 {
 public:
 	TextureSurfaceInfo m_surface;
-	AttachmentLoadOperation m_loadOperation = AttachmentLoadOperation::DONT_CARE;
-	AttachmentStoreOperation m_storeOperation = AttachmentStoreOperation::STORE;
+	AttachmentLoadOperation m_loadOperation = AttachmentLoadOperation::kDontCare;
+	AttachmentStoreOperation m_storeOperation = AttachmentStoreOperation::kStore;
 	ClearValue m_clearValue;
 
-	AttachmentLoadOperation m_stencilLoadOperation = AttachmentLoadOperation::DONT_CARE;
-	AttachmentStoreOperation m_stencilStoreOperation = AttachmentStoreOperation::STORE;
+	AttachmentLoadOperation m_stencilLoadOperation = AttachmentLoadOperation::kDontCare;
+	AttachmentStoreOperation m_stencilStoreOperation = AttachmentStoreOperation::kStore;
 
 	DepthStencilAspectBit m_aspect = DepthStencilAspectBit::kNone; ///< Relevant only for depth stencil textures.
 };

AnKi/Gr/RenderGraph.inl.h

@@ -84,14 +84,14 @@ inline void RenderPassDescriptionBase::validateDep(const RenderPassDependency& d
 		[[maybe_unused]] const BufferUsageBit usage = dep.m_buffer.m_usage;
 		if(m_type == Type::GRAPHICS)
 		{
-			ANKI_ASSERT(!(usage & BufferUsageBit::ALL_COMPUTE));
+			ANKI_ASSERT(!(usage & BufferUsageBit::kAllCompute));
 		}
 		else
 		{
-			ANKI_ASSERT(!(usage & BufferUsageBit::ALL_GRAPHICS));
+			ANKI_ASSERT(!(usage & BufferUsageBit::kAllGraphics));
 		}
 
-		ANKI_ASSERT(!!(usage & BufferUsageBit::ALL_READ) || !!(usage & BufferUsageBit::ALL_WRITE));
+		ANKI_ASSERT(!!(usage & BufferUsageBit::kAllRead) || !!(usage & BufferUsageBit::kAllWrite));
 	}
 	else
 	{
@@ -133,12 +133,12 @@ inline void RenderPassDescriptionBase::newDependency(const RenderPassDependency&
 	{
 		m_buffDeps.emplaceBack(m_alloc, dep);
 
-		if(!!(dep.m_buffer.m_usage & BufferUsageBit::ALL_READ))
+		if(!!(dep.m_buffer.m_usage & BufferUsageBit::kAllRead))
 		{
 			m_readBuffMask.set(dep.m_buffer.m_handle.m_idx);
 		}
 
-		if(!!(dep.m_buffer.m_usage & BufferUsageBit::ALL_WRITE))
+		if(!!(dep.m_buffer.m_usage & BufferUsageBit::kAllWrite))
 		{
 			m_writeBuffMask.set(dep.m_buffer.m_handle.m_idx);
 		}

AnKi/Gr/Vulkan/BufferImpl.cpp

@@ -49,14 +49,14 @@ Error BufferImpl::init(const BufferInitInfo& inf)
 {
 	ANKI_ASSERT(!isCreated());
 	const Bool exposeGpuAddress = !!(getGrManagerImpl().getExtensions() & VulkanExtensions::KHR_BUFFER_DEVICE_ADDRESS)
-								  && !!(inf.m_usage & ~BufferUsageBit::ALL_TRANSFER);
+								  && !!(inf.m_usage & ~BufferUsageBit::kAllTransfer);
 
 	PtrSize size = inf.m_size;
 	BufferMapAccessBit access = inf.m_mapAccess;
 	BufferUsageBit usage = inf.m_usage;
 
 	ANKI_ASSERT(size > 0);
-	ANKI_ASSERT(usage != BufferUsageBit::NONE);
+	ANKI_ASSERT(usage != BufferUsageBit::kNone);
 
 	m_mappedMemoryRangeAlignment = getGrManagerImpl().getPhysicalDeviceProperties().limits.nonCoherentAtomSize;
 
@@ -97,7 +97,7 @@ Error BufferImpl::init(const BufferInitInfo& inf)
 
 		if(isDiscreteGpu)
 		{
-			if((usage & (~BufferUsageBit::ALL_TRANSFER)) != BufferUsageBit::NONE)
+			if((usage & (~BufferUsageBit::kAllTransfer)) != BufferUsageBit::kNone)
 			{
 				// Will be used for something other than transfer, try to put it in the device
 				prefer |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
@@ -121,7 +121,7 @@ Error BufferImpl::init(const BufferInitInfo& inf)
 			{
 				ANKI_VK_LOGW("Using a fallback mode for write-only buffer");
 
-				if((usage & (~BufferUsageBit::ALL_TRANSFER)) == BufferUsageBit::NONE)
+				if((usage & (~BufferUsageBit::kAllTransfer)) == BufferUsageBit::kNone)
 				{
 					// Will be used only for transfers, don't want it in the device
 					avoid |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
@@ -250,43 +250,43 @@ VkPipelineStageFlags BufferImpl::computePplineStage(BufferUsageBit usage)
 {
 	VkPipelineStageFlags stageMask = 0;
 
-	if(!!(usage & BufferUsageBit::ALL_INDIRECT))
+	if(!!(usage & BufferUsageBit::kAllIndirect))
 	{
 		stageMask |= VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT;
 	}
 
-	if(!!(usage & (BufferUsageBit::INDEX | BufferUsageBit::VERTEX)))
+	if(!!(usage & (BufferUsageBit::kIndex | BufferUsageBit::kVertex)))
 	{
 		stageMask |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
 	}
 
-	if(!!(usage & BufferUsageBit::ALL_GEOMETRY))
+	if(!!(usage & BufferUsageBit::kAllGeometry))
 	{
 		stageMask |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT
 					 | VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT | VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
 	}
 
-	if(!!(usage & BufferUsageBit::ALL_FRAGMENT))
+	if(!!(usage & BufferUsageBit::kAllFragment))
 	{
 		stageMask |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
 	}
 
-	if(!!(usage & (BufferUsageBit::ALL_COMPUTE & ~BufferUsageBit::INDIRECT_COMPUTE)))
+	if(!!(usage & (BufferUsageBit::kAllCompute & ~BufferUsageBit::kIndirectCompute)))
 	{
 		stageMask |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
 	}
 
-	if(!!(usage & BufferUsageBit::ACCELERATION_STRUCTURE_BUILD))
+	if(!!(usage & BufferUsageBit::kAccelerationStructureBuild))
 	{
 		stageMask |= VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR;
 	}
 
-	if(!!(usage & (BufferUsageBit::ALL_TRACE_RAYS & ~BufferUsageBit::INDIRECT_TRACE_RAYS)))
+	if(!!(usage & (BufferUsageBit::kAllTraceRays & ~BufferUsageBit::kIndirectTraceRays)))
 	{
 		stageMask |= VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
 	}
 
-	if(!!(usage & BufferUsageBit::ALL_TRANSFER))
+	if(!!(usage & BufferUsageBit::kAllTransfer))
 	{
 		stageMask |= VK_PIPELINE_STAGE_TRANSFER_BIT;
 	}
@@ -304,19 +304,19 @@ VkAccessFlags BufferImpl::computeAccessMask(BufferUsageBit usage)
 {
 	VkAccessFlags mask = 0;
 
-	constexpr BufferUsageBit SHADER_READ =
-		BufferUsageBit::STORAGE_GEOMETRY_READ | BufferUsageBit::STORAGE_FRAGMENT_READ
-		| BufferUsageBit::STORAGE_COMPUTE_READ | BufferUsageBit::STORAGE_TRACE_RAYS_READ
-		| BufferUsageBit::TEXTURE_GEOMETRY_READ | BufferUsageBit::TEXTURE_FRAGMENT_READ
-		| BufferUsageBit::TEXTURE_COMPUTE_READ | BufferUsageBit::TEXTURE_TRACE_RAYS_READ;
+	constexpr BufferUsageBit SHADER_READ = BufferUsageBit::kStorageGeometryRead | BufferUsageBit::kStorageFragmentRead
+										   | BufferUsageBit::kStorageComputeRead | BufferUsageBit::kStorageTraceRaysRead
+										   | BufferUsageBit::kTextureGeometryRead | BufferUsageBit::kTextureFragmentRead
+										   | BufferUsageBit::kTextureComputeRead
+										   | BufferUsageBit::kTextureTraceRaysRead;
 
 	constexpr BufferUsageBit SHADER_WRITE =
-		BufferUsageBit::STORAGE_GEOMETRY_WRITE | BufferUsageBit::STORAGE_FRAGMENT_WRITE
-		| BufferUsageBit::STORAGE_COMPUTE_WRITE | BufferUsageBit::STORAGE_TRACE_RAYS_WRITE
-		| BufferUsageBit::TEXTURE_GEOMETRY_WRITE | BufferUsageBit::TEXTURE_FRAGMENT_WRITE
-		| BufferUsageBit::TEXTURE_COMPUTE_WRITE | BufferUsageBit::TEXTURE_TRACE_RAYS_WRITE;
+		BufferUsageBit::kStorageGeometryWrite | BufferUsageBit::kStorageFragmentWrite
+		| BufferUsageBit::kStorageComputeWrite | BufferUsageBit::kStorageTraceRaysWrite
+		| BufferUsageBit::kTextureGeometryWrite | BufferUsageBit::kTextureFragmentWrite
+		| BufferUsageBit::kTextureComputeWrite | BufferUsageBit::kTextureTraceRaysWrite;
 
-	if(!!(usage & BufferUsageBit::ALL_UNIFORM))
+	if(!!(usage & BufferUsageBit::kAllUniform))
 	{
 		mask |= VK_ACCESS_UNIFORM_READ_BIT;
 	}
@@ -331,32 +331,32 @@ VkAccessFlags BufferImpl::computeAccessMask(BufferUsageBit usage)
 		mask |= VK_ACCESS_SHADER_WRITE_BIT;
 	}
 
-	if(!!(usage & BufferUsageBit::INDEX))
+	if(!!(usage & BufferUsageBit::kIndex))
 	{
 		mask |= VK_ACCESS_INDEX_READ_BIT;
 	}
 
-	if(!!(usage & BufferUsageBit::VERTEX))
+	if(!!(usage & BufferUsageBit::kVertex))
 	{
 		mask |= VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
 	}
 
-	if(!!(usage & BufferUsageBit::ALL_INDIRECT))
+	if(!!(usage & BufferUsageBit::kAllIndirect))
 	{
 		mask |= VK_ACCESS_INDIRECT_COMMAND_READ_BIT;
 	}
 
-	if(!!(usage & BufferUsageBit::TRANSFER_DESTINATION))
+	if(!!(usage & BufferUsageBit::kTransferDestination))
 	{
 		mask |= VK_ACCESS_TRANSFER_WRITE_BIT;
 	}
 
-	if(!!(usage & BufferUsageBit::TRANSFER_SOURCE))
+	if(!!(usage & BufferUsageBit::kTransferSource))
 	{
 		mask |= VK_ACCESS_TRANSFER_READ_BIT;
 	}
 
-	if(!!(usage & BufferUsageBit::ACCELERATION_STRUCTURE_BUILD))
+	if(!!(usage & BufferUsageBit::kAccelerationStructureBuild))
 	{
 		mask |= VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR;
 	}
@@ -386,7 +386,7 @@ VkBufferView BufferImpl::getOrCreateBufferView(Format fmt, PtrSize offset, PtrSi
 	}
 
 	// Checks
-	ANKI_ASSERT(!!(m_usage & BufferUsageBit::ALL_TEXTURE));
+	ANKI_ASSERT(!!(m_usage & BufferUsageBit::kAllTexture));
 	ANKI_ASSERT(offset + range <= m_size);
 
 	ANKI_ASSERT(isAligned(getGrManagerImpl().getDeviceCapabilities().m_textureBufferBindOffsetAlignment,

AnKi/Gr/Vulkan/CommandBufferImpl.inl.h

@@ -315,7 +315,7 @@ inline void CommandBufferImpl::drawArraysIndirectInternal(PrimitiveTopology topo
 	m_state.setPrimitiveTopology(topology);
 	drawcallCommon();
 	const BufferImpl& impl = static_cast<const BufferImpl&>(*buff);
-	ANKI_ASSERT(impl.usageValid(BufferUsageBit::INDIRECT_DRAW));
+	ANKI_ASSERT(impl.usageValid(BufferUsageBit::kIndirectDraw));
 	ANKI_ASSERT((offset % 4) == 0);
 	ANKI_ASSERT((offset + sizeof(DrawArraysIndirectInfo) * drawCount) <= impl.getSize());
 
@@ -329,7 +329,7 @@ inline void CommandBufferImpl::drawElementsIndirectInternal(PrimitiveTopology to
 	m_state.setPrimitiveTopology(topology);
 	drawcallCommon();
 	const BufferImpl& impl = static_cast<const BufferImpl&>(*buff);
-	ANKI_ASSERT(impl.usageValid(BufferUsageBit::INDIRECT_DRAW));
+	ANKI_ASSERT(impl.usageValid(BufferUsageBit::kIndirectDraw));
 	ANKI_ASSERT((offset % 4) == 0);
 	ANKI_ASSERT((offset + sizeof(DrawElementsIndirectInfo) * drawCount) <= impl.getSize());
 
@@ -800,7 +800,7 @@ inline void CommandBufferImpl::fillBufferInternal(const BufferPtr& buff, PtrSize
 	commandCommon();
 	ANKI_ASSERT(!insideRenderPass());
 	const BufferImpl& impl = static_cast<const BufferImpl&>(*buff);
-	ANKI_ASSERT(impl.usageValid(BufferUsageBit::TRANSFER_DESTINATION));
+	ANKI_ASSERT(impl.usageValid(BufferUsageBit::kTransferDestination));
 
 	ANKI_ASSERT(offset < impl.getSize());
 	ANKI_ASSERT((offset % 4) == 0 && "Should be multiple of 4");
@@ -822,7 +822,7 @@ inline void CommandBufferImpl::writeOcclusionQueryResultToBufferInternal(const O
 	ANKI_ASSERT(!insideRenderPass());
 
 	const BufferImpl& impl = static_cast<const BufferImpl&>(*buff);
-	ANKI_ASSERT(impl.usageValid(BufferUsageBit::TRANSFER_DESTINATION));
+	ANKI_ASSERT(impl.usageValid(BufferUsageBit::kTransferDestination));
 	ANKI_ASSERT((offset % 4) == 0);
 	ANKI_ASSERT((offset + sizeof(U32)) <= impl.getSize());
 
@@ -908,8 +908,8 @@ inline void CommandBufferImpl::bindShaderProgramInternal(const ShaderProgramPtr&
 inline void CommandBufferImpl::copyBufferToBufferInternal(const BufferPtr& src, PtrSize srcOffset, const BufferPtr& dst,
 														  PtrSize dstOffset, PtrSize range)
 {
-	ANKI_ASSERT(static_cast<const BufferImpl&>(*src).usageValid(BufferUsageBit::TRANSFER_SOURCE));
-	ANKI_ASSERT(static_cast<const BufferImpl&>(*dst).usageValid(BufferUsageBit::TRANSFER_DESTINATION));
+	ANKI_ASSERT(static_cast<const BufferImpl&>(*src).usageValid(BufferUsageBit::kTransferSource));
+	ANKI_ASSERT(static_cast<const BufferImpl&>(*dst).usageValid(BufferUsageBit::kTransferDestination));
 	ANKI_ASSERT(srcOffset + range <= src->getSize());
 	ANKI_ASSERT(dstOffset + range <= dst->getSize());
 

AnKi/Gr/Vulkan/Common.cpp

@@ -224,13 +224,13 @@ VkAttachmentLoadOp convertLoadOp(AttachmentLoadOperation ak)
 
 	switch(ak)
 	{
-	case AttachmentLoadOperation::LOAD:
+	case AttachmentLoadOperation::kLoad:
 		out = VK_ATTACHMENT_LOAD_OP_LOAD;
 		break;
-	case AttachmentLoadOperation::CLEAR:
+	case AttachmentLoadOperation::kClear:
 		out = VK_ATTACHMENT_LOAD_OP_CLEAR;
 		break;
-	case AttachmentLoadOperation::DONT_CARE:
+	case AttachmentLoadOperation::kDontCare:
 		out = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
 		break;
 	default:
@@ -246,10 +246,10 @@ VkAttachmentStoreOp convertStoreOp(AttachmentStoreOperation ak)
 
 	switch(ak)
 	{
-	case AttachmentStoreOperation::STORE:
+	case AttachmentStoreOperation::kStore:
 		out = VK_ATTACHMENT_STORE_OP_STORE;
 		break;
-	case AttachmentStoreOperation::DONT_CARE:
+	case AttachmentStoreOperation::kDontCare:
 		out = VK_ATTACHMENT_STORE_OP_DONT_CARE;
 		break;
 	default:
@@ -263,52 +263,52 @@ VkBufferUsageFlags convertBufferUsageBit(BufferUsageBit usageMask)
 {
 	VkBufferUsageFlags out = 0;
 
-	if(!!(usageMask & BufferUsageBit::ALL_UNIFORM))
+	if(!!(usageMask & BufferUsageBit::kAllUniform))
 	{
 		out |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
 	}
 
-	if(!!(usageMask & BufferUsageBit::ALL_STORAGE))
+	if(!!(usageMask & BufferUsageBit::kAllStorage))
 	{
 		out |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
 	}
 
-	if(!!(usageMask & BufferUsageBit::INDEX))
+	if(!!(usageMask & BufferUsageBit::kIndex))
 	{
 		out |= VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
 	}
 
-	if(!!(usageMask & BufferUsageBit::VERTEX))
+	if(!!(usageMask & BufferUsageBit::kVertex))
 	{
 		out |= VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
 	}
 
-	if(!!(usageMask & BufferUsageBit::ALL_INDIRECT))
+	if(!!(usageMask & BufferUsageBit::kAllIndirect))
 	{
 		out |= VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
 	}
 
-	if(!!(usageMask & BufferUsageBit::TRANSFER_DESTINATION))
+	if(!!(usageMask & BufferUsageBit::kTransferDestination))
 	{
 		out |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
 	}
 
-	if(!!(usageMask & BufferUsageBit::TRANSFER_SOURCE))
+	if(!!(usageMask & BufferUsageBit::kTransferSource))
 	{
 		out |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
 	}
 
-	if(!!(usageMask & (BufferUsageBit::ALL_TEXTURE & BufferUsageBit::ALL_READ)))
+	if(!!(usageMask & (BufferUsageBit::kAllTexture & BufferUsageBit::kAllRead)))
 	{
 		out |= VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT;
 	}
 
-	if(!!(usageMask & (BufferUsageBit::ALL_TEXTURE & BufferUsageBit::ALL_WRITE)))
+	if(!!(usageMask & (BufferUsageBit::kAllTexture & BufferUsageBit::kAllWrite)))
 	{
 		out |= VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT;
 	}
 
-	if(!!(usageMask & BufferUsageBit::ACCELERATION_STRUCTURE_BUILD))
+	if(!!(usageMask & BufferUsageBit::kAccelerationStructureBuild))
 	{
 		out |= VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR;
 	}
@@ -323,7 +323,7 @@ VkBufferUsageFlags convertBufferUsageBit(BufferUsageBit usageMask)
 		out |= VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR;
 	}
 
-	if(!!(usageMask & BufferUsageBit::SBT))
+	if(!!(usageMask & BufferUsageBit::kSBT))
 	{
 		out |= VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR;
 	}

AnKi/Gr/Vulkan/Common.h

@@ -127,7 +127,7 @@ public:
 
 	static constexpr BufferUsageBit ALL_PRIVATE = ACCELERATION_STRUCTURE_BUILD_SCRATCH | ACCELERATION_STRUCTURE;
 };
-static_assert(!(BufferUsageBit::ALL & PrivateBufferUsageBit::ALL_PRIVATE), "Update the bits in PrivateBufferUsageBit");
+static_assert(!(BufferUsageBit::kAll & PrivateBufferUsageBit::ALL_PRIVATE), "Update the bits in PrivateBufferUsageBit");
 
 /// Check if a vulkan function failed. It will abort on failure.
 #define ANKI_VK_CHECKF(x) \

AnKi/Gr/Vulkan/FramebufferImpl.cpp

@@ -67,7 +67,7 @@ void FramebufferImpl::initClearValues(const FramebufferInitInfo& init)
 {
 	for(U i = 0; i < m_colorAttCount; ++i)
 	{
-		if(init.m_colorAttachments[i].m_loadOperation == AttachmentLoadOperation::CLEAR)
+		if(init.m_colorAttachments[i].m_loadOperation == AttachmentLoadOperation::kClear)
 		{
 			F32* col = &m_clearVals[i].color.float32[0];
 			col[0] = init.m_colorAttachments[i].m_clearValue.m_colorf[0];
@@ -83,8 +83,8 @@ void FramebufferImpl::initClearValues(const FramebufferInitInfo& init)
 
 	if(hasDepthStencil())
 	{
-		if(init.m_depthStencilAttachment.m_loadOperation == AttachmentLoadOperation::CLEAR
-		   || init.m_depthStencilAttachment.m_stencilLoadOperation == AttachmentLoadOperation::CLEAR)
+		if(init.m_depthStencilAttachment.m_loadOperation == AttachmentLoadOperation::kClear
+		   || init.m_depthStencilAttachment.m_stencilLoadOperation == AttachmentLoadOperation::kClear)
 		{
 			m_clearVals[m_colorAttCount].depthStencil.depth =
 				init.m_depthStencilAttachment.m_clearValue.m_depthStencil.m_depth;

AnKi/Gr/Vulkan/OcclusionQueryImpl.cpp

@@ -33,14 +33,14 @@ OcclusionQueryResult OcclusionQueryImpl::getResultInternal() const
 											   VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT
 												   | VK_QUERY_RESULT_PARTIAL_BIT));
 
-	OcclusionQueryResult qout = OcclusionQueryResult::NOT_AVAILABLE;
+	OcclusionQueryResult qout = OcclusionQueryResult::kNotAvailable;
 	if(res == VK_SUCCESS)
 	{
-		qout = (out) ? OcclusionQueryResult::VISIBLE : OcclusionQueryResult::NOT_VISIBLE;
+		qout = (out) ? OcclusionQueryResult::kVisible : OcclusionQueryResult::kNotVisible;
 	}
 	else if(res == VK_NOT_READY)
 	{
-		qout = OcclusionQueryResult::NOT_AVAILABLE;
+		qout = OcclusionQueryResult::kNotAvailable;
 	}
 	else
 	{

AnKi/Gr/Vulkan/TimestampQueryImpl.cpp

@@ -35,16 +35,16 @@ TimestampQueryResult TimestampQueryImpl::getResultInternal(Second& timestamp) co
 	ANKI_VK_CHECKF(res = vkGetQueryPoolResults(getDevice(), m_handle.getQueryPool(), m_handle.getQueryIndex(), 1,
 											   sizeof(value), &value, sizeof(value), VK_QUERY_RESULT_64_BIT));
 
-	TimestampQueryResult qout = TimestampQueryResult::NOT_AVAILABLE;
+	TimestampQueryResult qout = TimestampQueryResult::kNotAvailable;
 	if(res == VK_SUCCESS)
 	{
 		value *= m_timestampPeriod;
 		timestamp = Second(value) / Second(1000000000);
-		qout = TimestampQueryResult::AVAILABLE;
+		qout = TimestampQueryResult::kAvailable;
 	}
 	else if(res == VK_NOT_READY)
 	{
-		qout = TimestampQueryResult::NOT_AVAILABLE;
+		qout = TimestampQueryResult::kNotAvailable;
 	}
 	else
 	{

AnKi/Renderer/ClusterBinning.cpp

@@ -56,7 +56,7 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 	writeClustererBuffers(ctx);
 
 	ctx.m_clusteredShading.m_clustersBufferHandle = ctx.m_renderGraphDescr.importBuffer(
-		ctx.m_clusteredShading.m_clustersToken.m_buffer, BufferUsageBit::NONE,
+		ctx.m_clusteredShading.m_clustersToken.m_buffer, BufferUsageBit::kNone,
 		ctx.m_clusteredShading.m_clustersToken.m_offset, ctx.m_clusteredShading.m_clustersToken.m_range);
 
 	const RenderQueue& rqueue = *ctx.m_renderQueue;
@@ -68,7 +68,7 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("Cluster Binning");
 
 		pass.newDependency(
-			RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::STORAGE_COMPUTE_WRITE));
+			RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::kStorageComputeWrite));
 
 		pass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
 			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;

AnKi/Renderer/Dbg.cpp

@@ -37,9 +37,9 @@ Error Dbg::init()
 
 	// Create FB descr
 	m_fbDescr.m_colorAttachmentCount = 1;
-	m_fbDescr.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::CLEAR;
-	m_fbDescr.m_depthStencilAttachment.m_loadOperation = AttachmentLoadOperation::LOAD;
-	m_fbDescr.m_depthStencilAttachment.m_stencilLoadOperation = AttachmentLoadOperation::DONT_CARE;
+	m_fbDescr.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::kClear;
+	m_fbDescr.m_depthStencilAttachment.m_loadOperation = AttachmentLoadOperation::kLoad;
+	m_fbDescr.m_depthStencilAttachment.m_stencilLoadOperation = AttachmentLoadOperation::kDontCare;
 	m_fbDescr.m_depthStencilAttachment.m_aspect = DepthStencilAspectBit::kDepth;
 	m_fbDescr.bake();
 

AnKi/Renderer/DepthDownscale.cpp

@@ -104,7 +104,7 @@ Error DepthDownscale::initInternal()
 	{
 		BufferInitInfo buffInit("HiZCounterBuffer");
 		buffInit.m_size = sizeof(U32);
-		buffInit.m_usage = BufferUsageBit::STORAGE_COMPUTE_WRITE | BufferUsageBit::TRANSFER_DESTINATION;
+		buffInit.m_usage = BufferUsageBit::kStorageComputeWrite | BufferUsageBit::kTransferDestination;
 		m_counterBuffer = getGrManager().newBuffer(buffInit);
 	}
 
@@ -114,7 +114,7 @@ Error DepthDownscale::initInternal()
 		BufferInitInfo buffInit("HiZ Client");
 		buffInit.m_mapAccess = BufferMapAccessBit::READ;
 		buffInit.m_size = PtrSize(m_lastMipSize.y()) * PtrSize(m_lastMipSize.x()) * sizeof(F32);
-		buffInit.m_usage = BufferUsageBit::STORAGE_COMPUTE_WRITE | BufferUsageBit::STORAGE_FRAGMENT_WRITE;
+		buffInit.m_usage = BufferUsageBit::kStorageComputeWrite | BufferUsageBit::kStorageFragmentWrite;
 		m_clientBuffer = getGrManager().newBuffer(buffInit);
 
 		m_clientBufferAddr = m_clientBuffer->map(0, buffInit.m_size, BufferMapAccessBit::READ);
@@ -250,8 +250,8 @@ void DepthDownscale::runCompute(RenderPassWorkContext& rgraphCtx)
 
 		cmdb->fillBuffer(m_counterBuffer, 0, kMaxPtrSize, 0);
 
-		const BufferBarrierInfo barrier = {m_counterBuffer.get(), BufferUsageBit::TRANSFER_DESTINATION,
-										   BufferUsageBit::STORAGE_COMPUTE_WRITE, 0, kMaxPtrSize};
+		const BufferBarrierInfo barrier = {m_counterBuffer.get(), BufferUsageBit::kTransferDestination,
+										   BufferUsageBit::kStorageComputeWrite, 0, kMaxPtrSize};
 		cmdb->setPipelineBarrier({}, {&barrier, 1}, {});
 	}
 

AnKi/Renderer/ForwardShading.cpp

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

AnKi/Renderer/GBuffer.cpp

@@ -57,9 +57,9 @@ Error GBuffer::initInternal()
 	}
 
 	// FB descr
-	AttachmentLoadOperation loadop = AttachmentLoadOperation::DONT_CARE;
+	AttachmentLoadOperation loadop = AttachmentLoadOperation::kDontCare;
 #if ANKI_EXTRA_CHECKS
-	loadop = AttachmentLoadOperation::CLEAR;
+	loadop = AttachmentLoadOperation::kClear;
 #endif
 
 	m_fbDescr.m_colorAttachmentCount = kGBufferColorRenderTargetCount;
@@ -69,10 +69,10 @@ Error GBuffer::initInternal()
 		m_fbDescr.m_colorAttachments[i].m_clearValue.m_colorf = {1.0f, 0.0f, 1.0f, 0.0f};
 	}
 
-	m_fbDescr.m_colorAttachments[3].m_loadOperation = AttachmentLoadOperation::CLEAR;
+	m_fbDescr.m_colorAttachments[3].m_loadOperation = AttachmentLoadOperation::kClear;
 	m_fbDescr.m_colorAttachments[3].m_clearValue.m_colorf = {1.0f, 1.0f, 1.0f, 1.0f};
 
-	m_fbDescr.m_depthStencilAttachment.m_loadOperation = AttachmentLoadOperation::CLEAR;
+	m_fbDescr.m_depthStencilAttachment.m_loadOperation = AttachmentLoadOperation::kClear;
 	m_fbDescr.m_depthStencilAttachment.m_clearValue.m_depthStencil.m_depth = 1.0f;
 	m_fbDescr.m_depthStencilAttachment.m_aspect = DepthStencilAspectBit::kDepth;
 

AnKi/Renderer/GBufferPost.cpp

@@ -42,8 +42,8 @@ Error GBufferPost::initInternal()
 
 	// Create FB descr
 	m_fbDescr.m_colorAttachmentCount = 2;
-	m_fbDescr.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::LOAD;
-	m_fbDescr.m_colorAttachments[1].m_loadOperation = AttachmentLoadOperation::LOAD;
+	m_fbDescr.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::kLoad;
+	m_fbDescr.m_colorAttachments[1].m_loadOperation = AttachmentLoadOperation::kLoad;
 	m_fbDescr.bake();
 
 	return Error::kNone;
@@ -73,7 +73,7 @@ void GBufferPost::populateRenderGraph(RenderingContext& ctx)
 	rpass.newDependency(RenderPassDependency(m_r->getGBuffer().getDepthRt(), TextureUsageBit::kSampledFragment,
 											 TextureSubresourceInfo(DepthStencilAspectBit::kDepth)));
 	rpass.newDependency(
-		RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::STORAGE_FRAGMENT_READ));
+		RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::kStorageFragmentRead));
 }
 
 void GBufferPost::run(const RenderingContext& ctx, RenderPassWorkContext& rgraphCtx)

AnKi/Renderer/IndirectDiffuseProbes.cpp

@@ -151,11 +151,11 @@ Error IndirectDiffuseProbes::initGBuffer()
 
 		for(U j = 0; j < kGBufferColorRenderTargetCount; ++j)
 		{
-			m_gbuffer.m_fbDescr.m_colorAttachments[j].m_loadOperation = AttachmentLoadOperation::CLEAR;
+			m_gbuffer.m_fbDescr.m_colorAttachments[j].m_loadOperation = AttachmentLoadOperation::kClear;
 		}
 
 		m_gbuffer.m_fbDescr.m_depthStencilAttachment.m_aspect = DepthStencilAspectBit::kDepth;
-		m_gbuffer.m_fbDescr.m_depthStencilAttachment.m_loadOperation = AttachmentLoadOperation::CLEAR;
+		m_gbuffer.m_fbDescr.m_depthStencilAttachment.m_loadOperation = AttachmentLoadOperation::kClear;
 		m_gbuffer.m_fbDescr.m_depthStencilAttachment.m_clearValue.m_depthStencil.m_depth = 1.0f;
 
 		m_gbuffer.m_fbDescr.bake();
@@ -178,7 +178,7 @@ Error IndirectDiffuseProbes::initShadowMapping()
 	m_shadowMapping.m_fbDescr.m_colorAttachmentCount = 0;
 	m_shadowMapping.m_fbDescr.m_depthStencilAttachment.m_aspect = DepthStencilAspectBit::kDepth;
 	m_shadowMapping.m_fbDescr.m_depthStencilAttachment.m_clearValue.m_depthStencil.m_depth = 1.0f;
-	m_shadowMapping.m_fbDescr.m_depthStencilAttachment.m_loadOperation = AttachmentLoadOperation::CLEAR;
+	m_shadowMapping.m_fbDescr.m_depthStencilAttachment.m_loadOperation = AttachmentLoadOperation::kClear;
 	m_shadowMapping.m_fbDescr.bake();
 
 	return Error::kNone;
@@ -196,7 +196,7 @@ Error IndirectDiffuseProbes::initLightShading()
 	// Create FB descr
 	{
 		m_lightShading.m_fbDescr.m_colorAttachmentCount = 1;
-		m_lightShading.m_fbDescr.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::CLEAR;
+		m_lightShading.m_fbDescr.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::kClear;
 		m_lightShading.m_fbDescr.bake();
 	}
 

AnKi/Renderer/LensFlare.cpp

@@ -64,7 +64,7 @@ Error LensFlare::initOcclusion()
 	GrManager& gr = getGrManager();
 
 	m_indirectBuff = gr.newBuffer(BufferInitInfo(m_maxFlares * sizeof(DrawArraysIndirectInfo),
-												 BufferUsageBit::INDIRECT_DRAW | BufferUsageBit::STORAGE_COMPUTE_WRITE,
+												 BufferUsageBit::kIndirectDraw | BufferUsageBit::kStorageComputeWrite,
 												 BufferMapAccessBit::NONE, "LensFlares"));
 
 	ANKI_CHECK(getResourceManager().loadResource("ShaderBinaries/LensFlareUpdateIndirectInfo.ankiprogbin",
@@ -116,7 +116,7 @@ void LensFlare::populateRenderGraph(RenderingContext& ctx)
 	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
 
 	// Import buffer
-	m_runCtx.m_indirectBuffHandle = rgraph.importBuffer(m_indirectBuff, BufferUsageBit::NONE);
+	m_runCtx.m_indirectBuffHandle = rgraph.importBuffer(m_indirectBuff, BufferUsageBit::kNone);
 
 	// Update the indirect buffer
 	{
@@ -126,7 +126,7 @@ void LensFlare::populateRenderGraph(RenderingContext& ctx)
 			updateIndirectInfo(ctx, rgraphCtx);
 		});
 
-		rpass.newDependency({m_runCtx.m_indirectBuffHandle, BufferUsageBit::STORAGE_COMPUTE_WRITE});
+		rpass.newDependency({m_runCtx.m_indirectBuffHandle, BufferUsageBit::kStorageComputeWrite});
 		rpass.newDependency(
 			{m_r->getDepthDownscale().getHiZRt(), TextureUsageBit::kSampledCompute, kHiZQuarterSurface});
 	}

AnKi/Renderer/LightShading.cpp

@@ -86,8 +86,8 @@ Error LightShading::initLightShading()
 
 	// Create FB descr
 	m_lightShading.m_fbDescr.m_colorAttachmentCount = 1;
-	m_lightShading.m_fbDescr.m_depthStencilAttachment.m_loadOperation = AttachmentLoadOperation::LOAD;
-	m_lightShading.m_fbDescr.m_depthStencilAttachment.m_stencilLoadOperation = AttachmentLoadOperation::DONT_CARE;
+	m_lightShading.m_fbDescr.m_depthStencilAttachment.m_loadOperation = AttachmentLoadOperation::kLoad;
+	m_lightShading.m_fbDescr.m_depthStencilAttachment.m_stencilLoadOperation = AttachmentLoadOperation::kDontCare;
 	m_lightShading.m_fbDescr.m_depthStencilAttachment.m_aspect = DepthStencilAspectBit::kDepth;
 
 	if(getGrManager().getDeviceCapabilities().m_vrs && getConfig().getRVrs())
@@ -394,7 +394,7 @@ void LightShading::populateRenderGraph(RenderingContext& ctx)
 		pass.newDependency(RenderPassDependency(m_r->getShadowmapsResolve().getRt(), readUsage));
 	}
 	pass.newDependency(
-		RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::STORAGE_FRAGMENT_READ));
+		RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::kStorageFragmentRead));
 
 	// Apply indirect
 	pass.newDependency(RenderPassDependency(m_r->getIndirectDiffuse().getRt(), readUsage));

AnKi/Renderer/ProbeReflections.cpp

@@ -95,11 +95,11 @@ Error ProbeReflections::initGBuffer()
 
 		for(U j = 0; j < kGBufferColorRenderTargetCount; ++j)
 		{
-			m_gbuffer.m_fbDescr.m_colorAttachments[j].m_loadOperation = AttachmentLoadOperation::CLEAR;
+			m_gbuffer.m_fbDescr.m_colorAttachments[j].m_loadOperation = AttachmentLoadOperation::kClear;
 		}
 
 		m_gbuffer.m_fbDescr.m_depthStencilAttachment.m_aspect = DepthStencilAspectBit::kDepth;
-		m_gbuffer.m_fbDescr.m_depthStencilAttachment.m_loadOperation = AttachmentLoadOperation::CLEAR;
+		m_gbuffer.m_fbDescr.m_depthStencilAttachment.m_loadOperation = AttachmentLoadOperation::kClear;
 		m_gbuffer.m_fbDescr.m_depthStencilAttachment.m_clearValue.m_depthStencil.m_depth = 1.0f;
 
 		m_gbuffer.m_fbDescr.bake();
@@ -158,7 +158,7 @@ Error ProbeReflections::initIrradiance()
 	// Create buff
 	{
 		BufferInitInfo init;
-		init.m_usage = BufferUsageBit::ALL_STORAGE;
+		init.m_usage = BufferUsageBit::kAllStorage;
 		init.m_size = 6 * sizeof(Vec4);
 		m_irradiance.m_diceValuesBuff = getGrManager().newBuffer(init);
 	}
@@ -194,7 +194,7 @@ Error ProbeReflections::initShadowMapping()
 	m_shadowMapping.m_fbDescr.m_colorAttachmentCount = 0;
 	m_shadowMapping.m_fbDescr.m_depthStencilAttachment.m_aspect = DepthStencilAspectBit::kDepth;
 	m_shadowMapping.m_fbDescr.m_depthStencilAttachment.m_clearValue.m_depthStencil.m_depth = 1.0f;
-	m_shadowMapping.m_fbDescr.m_depthStencilAttachment.m_loadOperation = AttachmentLoadOperation::CLEAR;
+	m_shadowMapping.m_fbDescr.m_depthStencilAttachment.m_loadOperation = AttachmentLoadOperation::kClear;
 	m_shadowMapping.m_fbDescr.bake();
 
 	return Error::kNone;
@@ -212,7 +212,7 @@ void ProbeReflections::initCacheEntry(U32 cacheEntryIdx)
 		fbDescr.m_colorAttachmentCount = 1;
 		fbDescr.m_colorAttachments[0].m_surface.m_layer = cacheEntryIdx;
 		fbDescr.m_colorAttachments[0].m_surface.m_face = faceIdx;
-		fbDescr.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::CLEAR;
+		fbDescr.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::kClear;
 		fbDescr.bake();
 	}
 }
@@ -632,7 +632,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 	// Irradiance passes
 	{
 		m_ctx.m_irradianceDiceValuesBuffHandle =
-			rgraph.importBuffer(m_irradiance.m_diceValuesBuff, BufferUsageBit::NONE);
+			rgraph.importBuffer(m_irradiance.m_diceValuesBuff, BufferUsageBit::kNone);
 
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("CubeRefl Irradiance");
 
@@ -646,7 +646,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 		readSubresource.m_firstLayer = probeToUpdateCacheEntryIdx;
 		pass.newDependency({m_ctx.m_lightShadingRt, TextureUsageBit::kSampledCompute, readSubresource});
 
-		pass.newDependency({m_ctx.m_irradianceDiceValuesBuffHandle, BufferUsageBit::STORAGE_COMPUTE_WRITE});
+		pass.newDependency({m_ctx.m_irradianceDiceValuesBuffHandle, BufferUsageBit::kStorageComputeWrite});
 	}
 
 	// Write irradiance back to refl
@@ -668,7 +668,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 		pass.newDependency({m_ctx.m_lightShadingRt,
 							TextureUsageBit::kImageComputeRead | TextureUsageBit::kImageComputeWrite, subresource});
 
-		pass.newDependency({m_ctx.m_irradianceDiceValuesBuffHandle, BufferUsageBit::STORAGE_COMPUTE_READ});
+		pass.newDependency({m_ctx.m_irradianceDiceValuesBuffHandle, BufferUsageBit::kStorageComputeRead});
 	}
 
 	// Mipmapping "passes"

AnKi/Renderer/Renderer.cpp

@@ -166,7 +166,7 @@ Error Renderer::initInternal(UVec2 swapchainResolution)
 		m_dummyTexView3d = getGrManager().newTextureView(viewinit);
 
 		m_dummyBuff = getGrManager().newBuffer(BufferInitInfo(
-			1024, BufferUsageBit::ALL_UNIFORM | BufferUsageBit::ALL_STORAGE, BufferMapAccessBit::NONE, "Dummy"));
+			1024, BufferUsageBit::kAllUniform | BufferUsageBit::kAllStorage, BufferMapAccessBit::NONE, "Dummy"));
 	}
 
 	// Init the stages. Careful with the order!!!!!!!!!!
@@ -506,8 +506,8 @@ TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, Text
 						TextureViewPtr view = getGrManager().newTextureView(TextureViewInitInfo(tex, surf, aspect));
 
 						fbInit.m_depthStencilAttachment.m_textureView = view;
-						fbInit.m_depthStencilAttachment.m_loadOperation = AttachmentLoadOperation::CLEAR;
-						fbInit.m_depthStencilAttachment.m_stencilLoadOperation = AttachmentLoadOperation::CLEAR;
+						fbInit.m_depthStencilAttachment.m_loadOperation = AttachmentLoadOperation::kClear;
+						fbInit.m_depthStencilAttachment.m_stencilLoadOperation = AttachmentLoadOperation::kClear;
 						fbInit.m_depthStencilAttachment.m_clearValue = clearVal;
 
 						dsUsage = TextureUsageBit::kFramebufferWrite;
@@ -518,7 +518,7 @@ TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, Text
 
 						fbInit.m_colorAttachmentCount = 1;
 						fbInit.m_colorAttachments[0].m_textureView = view;
-						fbInit.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::CLEAR;
+						fbInit.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::kClear;
 						fbInit.m_colorAttachments[0].m_clearValue = clearVal;
 
 						colUsage[0] = TextureUsageBit::kFramebufferWrite;

AnKi/Renderer/RtShadows.cpp

@@ -261,8 +261,8 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 		rpass.newDependency(RenderPassDependency(m_runCtx.m_prevMomentsRt, TextureUsageBit::kSampledTraceRays));
 		rpass.newDependency(RenderPassDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kImageTraceRaysWrite));
 
-		rpass.newDependency(RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle,
-												 BufferUsageBit::STORAGE_TRACE_RAYS_READ));
+		rpass.newDependency(
+			RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::kStorageTraceRaysRead));
 	}
 
 	// Denoise pass horizontal

AnKi/Renderer/ShadowMapping.cpp

@@ -81,7 +81,7 @@ Error ShadowMapping::initScratch()
 		m_scratch.m_rtDescr.bake();
 
 		// FB
-		m_scratch.m_fbDescr.m_depthStencilAttachment.m_loadOperation = AttachmentLoadOperation::CLEAR;
+		m_scratch.m_fbDescr.m_depthStencilAttachment.m_loadOperation = AttachmentLoadOperation::kClear;
 		m_scratch.m_fbDescr.m_depthStencilAttachment.m_clearValue.m_depthStencil.m_depth = 1.0f;
 		m_scratch.m_fbDescr.m_depthStencilAttachment.m_aspect = DepthStencilAspectBit::kDepth;
 		m_scratch.m_fbDescr.bake();
@@ -138,7 +138,7 @@ Error ShadowMapping::initAtlas()
 	}
 
 	m_atlas.m_fbDescr.m_colorAttachmentCount = 1;
-	m_atlas.m_fbDescr.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::LOAD;
+	m_atlas.m_fbDescr.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::kLoad;
 	m_atlas.m_fbDescr.bake();
 
 	return Error::kNone;

AnKi/Renderer/ShadowmapsResolve.cpp

@@ -83,7 +83,7 @@ void ShadowmapsResolve::populateRenderGraph(RenderingContext& ctx)
 			RenderPassDependency(m_r->getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledCompute));
 
 		rpass.newDependency(
-			RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::STORAGE_COMPUTE_READ));
+			RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::kStorageComputeRead));
 	}
 	else
 	{
@@ -102,7 +102,7 @@ void ShadowmapsResolve::populateRenderGraph(RenderingContext& ctx)
 			RenderPassDependency(m_r->getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledFragment));
 
 		rpass.newDependency(
-			RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::STORAGE_FRAGMENT_READ));
+			RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::kStorageFragmentRead));
 	}
 }
 

AnKi/Renderer/VolumetricLightingAccumulation.cpp

@@ -93,7 +93,7 @@ void VolumetricLightingAccumulation::populateRenderGraph(RenderingContext& ctx)
 		RenderPassDependency(m_r->getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledCompute));
 
 	pass.newDependency(
-		RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::STORAGE_COMPUTE_READ));
+		RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::kStorageComputeRead));
 
 	m_r->getIndirectDiffuseProbes().setRenderGraphDependencies(ctx, pass, TextureUsageBit::kSampledCompute);
 }

AnKi/Resource/MeshResource.cpp

@@ -181,8 +181,8 @@ Error MeshResource::load(const ResourceFilename& filename, Bool async)
 		cmdb->fillBuffer(m_vertexBuffer, m_vertexBuffersOffset, m_vertexBuffersSize, 0);
 		cmdb->fillBuffer(m_vertexBuffer, m_indexBufferOffset, indexBufferSize, 0);
 
-		const BufferBarrierInfo barrier = {m_vertexBuffer.get(), BufferUsageBit::TRANSFER_DESTINATION,
-										   BufferUsageBit::VERTEX, 0, kMaxPtrSize};
+		const BufferBarrierInfo barrier = {m_vertexBuffer.get(), BufferUsageBit::kTransferDestination,
+										   BufferUsageBit::kVertex, 0, kMaxPtrSize};
 
 		cmdb->setPipelineBarrier({}, {&barrier, 1}, {});
 
@@ -280,8 +280,8 @@ Error MeshResource::loadAsync(MeshBinaryLoader& loader) const
 	CommandBufferPtr cmdb = gr.newCommandBuffer(cmdbinit);
 
 	// Set barriers
-	const BufferBarrierInfo barrier = {m_vertexBuffer.get(), BufferUsageBit::VERTEX,
-									   BufferUsageBit::TRANSFER_DESTINATION, 0, kMaxPtrSize};
+	const BufferBarrierInfo barrier = {m_vertexBuffer.get(), BufferUsageBit::kVertex,
+									   BufferUsageBit::kTransferDestination, 0, kMaxPtrSize};
 	cmdb->setPipelineBarrier({}, {&barrier, 1}, {});
 
 	// Write index buffer
@@ -325,9 +325,9 @@ Error MeshResource::loadAsync(MeshBinaryLoader& loader) const
 	// Build the BLAS
 	if(gr.getDeviceCapabilities().m_rayTracingEnabled)
 	{
-		const BufferBarrierInfo buffBarrier = {m_vertexBuffer.get(), BufferUsageBit::TRANSFER_DESTINATION,
-											   BufferUsageBit::ACCELERATION_STRUCTURE_BUILD | BufferUsageBit::VERTEX
-												   | BufferUsageBit::INDEX,
+		const BufferBarrierInfo buffBarrier = {m_vertexBuffer.get(), BufferUsageBit::kTransferDestination,
+											   BufferUsageBit::kAccelerationStructureBuild | BufferUsageBit::kVertex
+												   | BufferUsageBit::kIndex,
 											   0, kMaxPtrSize};
 		const AccelerationStructureBarrierInfo asBarrier = {m_blas.get(), AccelerationStructureUsageBit::NONE,
 															AccelerationStructureUsageBit::BUILD};
@@ -343,8 +343,8 @@ Error MeshResource::loadAsync(MeshBinaryLoader& loader) const
 	}
 	else
 	{
-		const BufferBarrierInfo buffBarrier = {m_vertexBuffer.get(), BufferUsageBit::TRANSFER_DESTINATION,
-											   BufferUsageBit::VERTEX | BufferUsageBit::INDEX, 0, kMaxPtrSize};
+		const BufferBarrierInfo buffBarrier = {m_vertexBuffer.get(), BufferUsageBit::kTransferDestination,
+											   BufferUsageBit::kVertex | BufferUsageBit::kIndex, 0, kMaxPtrSize};
 
 		cmdb->setPipelineBarrier({}, {&buffBarrier, 1}, {});
 	}

AnKi/Resource/TransferGpuAllocator.cpp

@@ -15,7 +15,7 @@ Error TransferGpuAllocator::StackAllocatorBuilderInterface::allocateChunk(PtrSiz
 {
 	out = m_parent->m_alloc.newInstance<Chunk>();
 
-	BufferInitInfo bufferInit(size, BufferUsageBit::TRANSFER_SOURCE, BufferMapAccessBit::WRITE, "Transfer");
+	BufferInitInfo bufferInit(size, BufferUsageBit::kTransferSource, BufferMapAccessBit::WRITE, "Transfer");
 	out->m_buffer = m_parent->m_gr->newBuffer(bufferInit);
 
 	out->m_mappedBuffer = out->m_buffer->map(0, kMaxPtrSize, BufferMapAccessBit::WRITE);

AnKi/Scene/Components/GpuParticleEmitterComponent.cpp

@@ -52,7 +52,7 @@ Error GpuParticleEmitterComponent::loadParticleEmitterResource(CString filename)
 	{
 		BufferInitInfo buffInit("GpuParticlesProps");
 		buffInit.m_mapAccess = BufferMapAccessBit::WRITE;
-		buffInit.m_usage = BufferUsageBit::UNIFORM_COMPUTE;
+		buffInit.m_usage = BufferUsageBit::kUniformCompute;
 		buffInit.m_size = sizeof(GpuParticleEmitterProperties);
 		m_propsBuff = m_node->getSceneGraph().getGrManager().newBuffer(buffInit);
 		GpuParticleEmitterProperties* props =
@@ -78,7 +78,7 @@ Error GpuParticleEmitterComponent::loadParticleEmitterResource(CString filename)
 	{
 		BufferInitInfo buffInit("GpuParticles");
 		buffInit.m_mapAccess = BufferMapAccessBit::WRITE;
-		buffInit.m_usage = BufferUsageBit::ALL_STORAGE;
+		buffInit.m_usage = BufferUsageBit::kAllStorage;
 		buffInit.m_size = sizeof(GpuParticle) * m_maxParticleCount;
 		m_particlesBuff = m_node->getSceneGraph().getGrManager().newBuffer(buffInit);
 
@@ -98,7 +98,7 @@ Error GpuParticleEmitterComponent::loadParticleEmitterResource(CString filename)
 	{
 		BufferInitInfo buffInit("GpuParticlesRand");
 		buffInit.m_mapAccess = BufferMapAccessBit::WRITE;
-		buffInit.m_usage = BufferUsageBit::ALL_STORAGE;
+		buffInit.m_usage = BufferUsageBit::kAllStorage;
 		buffInit.m_size = sizeof(U32) + MAX_RAND_FACTORS * sizeof(F32);
 		m_randFactorsBuff = m_node->getSceneGraph().getGrManager().newBuffer(buffInit);
 

AnKi/Scene/DebugDrawer.cpp

@@ -71,7 +71,7 @@ Error DebugDrawer2::init(ResourceManager* rsrcManager)
 
 	{
 		BufferInitInfo bufferInit("DebugCube");
-		bufferInit.m_usage = BufferUsageBit::VERTEX;
+		bufferInit.m_usage = BufferUsageBit::kVertex;
 		bufferInit.m_size = sizeof(Vec3) * 8;
 		bufferInit.m_mapAccess = BufferMapAccessBit::WRITE;
 		m_cubePositionsBuffer = rsrcManager->getGrManager().newBuffer(bufferInit);
@@ -96,7 +96,7 @@ Error DebugDrawer2::init(ResourceManager* rsrcManager)
 		constexpr U INDEX_COUNT = 12 * 2;
 
 		BufferInitInfo bufferInit("DebugCube");
-		bufferInit.m_usage = BufferUsageBit::VERTEX;
+		bufferInit.m_usage = BufferUsageBit::kVertex;
 		bufferInit.m_size = sizeof(U16) * INDEX_COUNT;
 		bufferInit.m_mapAccess = BufferMapAccessBit::WRITE;
 		m_cubeIndicesBuffer = rsrcManager->getGrManager().newBuffer(bufferInit);

AnKi/Ui/Font.cpp

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

Samples/PhysicsPlayground/Main.cpp

@@ -402,7 +402,8 @@ Error MyApp::userMainLoop(Bool& quit, [[maybe_unused]] Second elapsedTime)
 	return Error::kNone;
 }
 
-int main(int argc, char* argv[])
+ANKI_MAIN_FUNCTION(myMain)
+int myMain(int argc, char* argv[])
 {
 	Error err = Error::kNone;
 

Tests/Gr/Gr.cpp

@@ -359,13 +359,13 @@ static void createCube(GrManager& gr, BufferPtr& verts, BufferPtr& indices)
 	static const Array<U16, 6 * 2 * 3> idx = {
 		{0, 1, 3, 3, 1, 2, 1, 5, 6, 1, 6, 2, 7, 4, 0, 7, 0, 3, 6, 5, 7, 7, 5, 4, 0, 4, 5, 0, 5, 1, 3, 2, 6, 3, 6, 7}};
 
-	verts = gr.newBuffer(BufferInitInfo(sizeof(pos), BufferUsageBit::VERTEX, BufferMapAccessBit::WRITE));
+	verts = gr.newBuffer(BufferInitInfo(sizeof(pos), BufferUsageBit::kVertex, BufferMapAccessBit::WRITE));
 
 	void* mapped = verts->map(0, sizeof(pos), BufferMapAccessBit::WRITE);
 	memcpy(mapped, &pos[0], sizeof(pos));
 	verts->unmap();
 
-	indices = gr.newBuffer(BufferInitInfo(sizeof(idx), BufferUsageBit::INDEX, BufferMapAccessBit::WRITE));
+	indices = gr.newBuffer(BufferInitInfo(sizeof(idx), BufferUsageBit::kIndex, BufferMapAccessBit::WRITE));
 	mapped = indices->map(0, sizeof(idx), BufferMapAccessBit::WRITE);
 	memcpy(mapped, &idx[0], sizeof(idx));
 	indices->unmap();
@@ -686,13 +686,13 @@ ANKI_TEST(Gr, Buffer)
 
 	BufferInitInfo buffInit("a");
 	buffInit.m_size = 512;
-	buffInit.m_usage = BufferUsageBit::ALL_UNIFORM;
+	buffInit.m_usage = BufferUsageBit::kAllUniform;
 	buffInit.m_mapAccess = BufferMapAccessBit::NONE;
 	BufferPtr a = gr->newBuffer(buffInit);
 
 	buffInit.setName("b");
 	buffInit.m_size = 64;
-	buffInit.m_usage = BufferUsageBit::ALL_STORAGE;
+	buffInit.m_usage = BufferUsageBit::kAllStorage;
 	buffInit.m_mapAccess = BufferMapAccessBit::WRITE | BufferMapAccessBit::READ;
 	BufferPtr b = gr->newBuffer(buffInit);
 
@@ -717,7 +717,7 @@ ANKI_TEST(Gr, DrawWithUniforms)
 
 	// A non-uploaded buffer
 	BufferPtr b =
-		gr->newBuffer(BufferInitInfo(sizeof(Vec4) * 3, BufferUsageBit::ALL_UNIFORM, BufferMapAccessBit::WRITE));
+		gr->newBuffer(BufferInitInfo(sizeof(Vec4) * 3, BufferUsageBit::kAllUniform, BufferMapAccessBit::WRITE));
 
 	Vec4* ptr = static_cast<Vec4*>(b->map(0, sizeof(Vec4) * 3, BufferMapAccessBit::WRITE));
 	ANKI_TEST_EXPECT_NEQ(ptr, nullptr);
@@ -787,7 +787,7 @@ ANKI_TEST(Gr, DrawWithVertex)
 	};
 	static_assert(sizeof(Vert) == sizeof(Vec4), "See file");
 
-	BufferPtr b = gr->newBuffer(BufferInitInfo(sizeof(Vert) * 3, BufferUsageBit::VERTEX, BufferMapAccessBit::WRITE));
+	BufferPtr b = gr->newBuffer(BufferInitInfo(sizeof(Vert) * 3, BufferUsageBit::kVertex, BufferMapAccessBit::WRITE));
 
 	Vert* ptr = static_cast<Vert*>(b->map(0, sizeof(Vert) * 3, BufferMapAccessBit::WRITE));
 	ANKI_TEST_EXPECT_NEQ(ptr, nullptr);
@@ -801,7 +801,7 @@ ANKI_TEST(Gr, DrawWithVertex)
 	ptr[2].m_color = {{0, 0, 255}};
 	b->unmap();
 
-	BufferPtr c = gr->newBuffer(BufferInitInfo(sizeof(Vec3) * 3, BufferUsageBit::VERTEX, BufferMapAccessBit::WRITE));
+	BufferPtr c = gr->newBuffer(BufferInitInfo(sizeof(Vec3) * 3, BufferUsageBit::kVertex, BufferMapAccessBit::WRITE));
 
 	Vec3* otherColor = static_cast<Vec3*>(c->map(0, sizeof(Vec3) * 3, BufferMapAccessBit::WRITE));
 
@@ -1774,7 +1774,7 @@ void main()
 
 	// Create the buffer to copy to the texture
 	BufferPtr uploadBuff = gr->newBuffer(BufferInitInfo(PtrSize(texInit.m_width) * texInit.m_height * 3,
-														BufferUsageBit::ALL_TRANSFER, BufferMapAccessBit::WRITE));
+														BufferUsageBit::kAllTransfer, BufferMapAccessBit::WRITE));
 	U8* data = static_cast<U8*>(uploadBuff->map(0, uploadBuff->getSize(), BufferMapAccessBit::WRITE));
 	for(U32 i = 0; i < texInit.m_width * texInit.m_height; ++i)
 	{
@@ -1786,7 +1786,7 @@ void main()
 	uploadBuff->unmap();
 
 	BufferPtr uploadBuff2 = gr->newBuffer(BufferInitInfo(PtrSize(texInit.m_width >> 1) * (texInit.m_height >> 1) * 3,
-														 BufferUsageBit::ALL_TRANSFER, BufferMapAccessBit::WRITE));
+														 BufferUsageBit::kAllTransfer, BufferMapAccessBit::WRITE));
 	data = static_cast<U8*>(uploadBuff2->map(0, uploadBuff2->getSize(), BufferMapAccessBit::WRITE));
 	for(U i = 0; i < (texInit.m_width >> 1) * (texInit.m_height >> 1); ++i)
 	{
@@ -1799,7 +1799,7 @@ void main()
 
 	// Create the result buffer
 	BufferPtr resultBuff =
-		gr->newBuffer(BufferInitInfo(sizeof(UVec4), BufferUsageBit::STORAGE_COMPUTE_WRITE, BufferMapAccessBit::READ));
+		gr->newBuffer(BufferInitInfo(sizeof(UVec4), BufferUsageBit::kStorageComputeWrite, BufferMapAccessBit::READ));
 
 	// Upload data and test them
 	CommandBufferInitInfo cmdbInit;
@@ -1820,7 +1820,7 @@ void main()
 	cmdb->bindStorageBuffer(0, 1, resultBuff, 0, resultBuff->getSize());
 	cmdb->dispatchCompute(1, 1, 1);
 
-	cmdb->setBufferBarrier(resultBuff, BufferUsageBit::STORAGE_COMPUTE_WRITE, BufferUsageBit::STORAGE_COMPUTE_WRITE, 0,
+	cmdb->setBufferBarrier(resultBuff, BufferUsageBit::kStorageComputeWrite, BufferUsageBit::kStorageComputeWrite, 0,
 						   resultBuff->getSize());
 
 	cmdb->flush();
@@ -1912,7 +1912,7 @@ void main()
 
 	// Create the result buffer
 	BufferPtr resultBuff =
-		gr->newBuffer(BufferInitInfo(sizeof(UVec4), BufferUsageBit::STORAGE_COMPUTE_WRITE, BufferMapAccessBit::READ));
+		gr->newBuffer(BufferInitInfo(sizeof(UVec4), BufferUsageBit::kStorageComputeWrite, BufferMapAccessBit::READ));
 
 	// Draw
 
@@ -2025,7 +2025,7 @@ void main()
 
 	// Create the result buffer
 	BufferPtr resultBuff = gr->newBuffer(BufferInitInfo(
-		sizeof(UVec4), BufferUsageBit::ALL_STORAGE | BufferUsageBit::TRANSFER_DESTINATION, BufferMapAccessBit::READ));
+		sizeof(UVec4), BufferUsageBit::kAllStorage | BufferUsageBit::kTransferDestination, BufferMapAccessBit::READ));
 
 	// Draw
 	CommandBufferInitInfo cinit;
@@ -2033,7 +2033,7 @@ void main()
 	CommandBufferPtr cmdb = gr->newCommandBuffer(cinit);
 
 	cmdb->fillBuffer(resultBuff, 0, resultBuff->getSize(), 0);
-	cmdb->setBufferBarrier(resultBuff, BufferUsageBit::TRANSFER_DESTINATION, BufferUsageBit::STORAGE_FRAGMENT_WRITE, 0,
+	cmdb->setBufferBarrier(resultBuff, BufferUsageBit::kTransferDestination, BufferUsageBit::kStorageFragmentWrite, 0,
 						   resultBuff->getSize());
 
 	cmdb->setViewport(0, 0, WIDTH, HEIGHT);
@@ -2079,13 +2079,13 @@ ANKI_TEST(Gr, BindingWithArray)
 
 	// Create result buffer
 	BufferPtr resBuff =
-		gr->newBuffer(BufferInitInfo(sizeof(Vec4), BufferUsageBit::ALL_COMPUTE, BufferMapAccessBit::READ));
+		gr->newBuffer(BufferInitInfo(sizeof(Vec4), BufferUsageBit::kAllCompute, BufferMapAccessBit::READ));
 
 	Array<BufferPtr, 4> uniformBuffers;
 	F32 count = 1.0f;
 	for(BufferPtr& ptr : uniformBuffers)
 	{
-		ptr = gr->newBuffer(BufferInitInfo(sizeof(Vec4), BufferUsageBit::ALL_COMPUTE, BufferMapAccessBit::WRITE));
+		ptr = gr->newBuffer(BufferInitInfo(sizeof(Vec4), BufferUsageBit::kAllCompute, BufferMapAccessBit::WRITE));
 
 		Vec4* mapped = static_cast<Vec4*>(ptr->map(0, sizeof(Vec4), BufferMapAccessBit::WRITE));
 		*mapped = Vec4(count, count + 1.0f, count + 2.0f, count + 3.0f);
@@ -2181,7 +2181,7 @@ ANKI_TEST(Gr, Bindless)
 
 	// Create result buffer
 	BufferPtr resBuff =
-		gr->newBuffer(BufferInitInfo(sizeof(UVec4), BufferUsageBit::ALL_COMPUTE, BufferMapAccessBit::READ));
+		gr->newBuffer(BufferInitInfo(sizeof(UVec4), BufferUsageBit::kAllCompute, BufferMapAccessBit::READ));
 
 	// Create program A
 	static const char* PROG_SRC = R"(
@@ -2312,7 +2312,7 @@ void main()
 	// Create buffers
 	BufferInitInfo info;
 	info.m_size = sizeof(Vec4) * 2;
-	info.m_usage = BufferUsageBit::ALL_COMPUTE;
+	info.m_usage = BufferUsageBit::kAllCompute;
 	info.m_mapAccess = BufferMapAccessBit::WRITE;
 	BufferPtr ptrBuff = gr->newBuffer(info);
 
@@ -2324,7 +2324,7 @@ void main()
 	ptrBuff->unmap();
 
 	BufferPtr resBuff =
-		gr->newBuffer(BufferInitInfo(sizeof(Vec4), BufferUsageBit::ALL_COMPUTE, BufferMapAccessBit::READ));
+		gr->newBuffer(BufferInitInfo(sizeof(Vec4), BufferUsageBit::kAllCompute, BufferMapAccessBit::READ));
 
 	// Run
 	CommandBufferInitInfo cinit;
@@ -2372,7 +2372,7 @@ ANKI_TEST(Gr, RayQuery)
 		Array<U16, 3> indices = {0, 1, 2};
 		BufferInitInfo init;
 		init.m_mapAccess = BufferMapAccessBit::WRITE;
-		init.m_usage = BufferUsageBit::INDEX;
+		init.m_usage = BufferUsageBit::kIndex;
 		init.m_size = sizeof(indices);
 		idxBuffer = gr->newBuffer(init);
 
@@ -2389,7 +2389,7 @@ ANKI_TEST(Gr, RayQuery)
 
 		BufferInitInfo init;
 		init.m_mapAccess = BufferMapAccessBit::WRITE;
-		init.m_usage = BufferUsageBit::VERTEX;
+		init.m_usage = BufferUsageBit::kVertex;
 		init.m_size = sizeof(verts);
 		vertBuffer = gr->newBuffer(init);
 
@@ -2631,7 +2631,7 @@ static void createCubeBuffers(GrManager& gr, Vec3 min, Vec3 max, BufferPtr& inde
 {
 	BufferInitInfo inf;
 	inf.m_mapAccess = BufferMapAccessBit::WRITE;
-	inf.m_usage = BufferUsageBit::INDEX | BufferUsageBit::VERTEX | BufferUsageBit::STORAGE_TRACE_RAYS_READ;
+	inf.m_usage = BufferUsageBit::kIndex | BufferUsageBit::kVertex | BufferUsageBit::kStorageTraceRaysRead;
 	inf.m_size = sizeof(Vec3) * 8;
 	vertBuffer = gr.newBuffer(inf);
 	WeakArray<Vec3, PtrSize> positions = vertBuffer->map<Vec3>(0, 8, BufferMapAccessBit::WRITE);
@@ -2893,7 +2893,7 @@ void main()
 	{
 		BufferInitInfo inf;
 		inf.m_mapAccess = BufferMapAccessBit::WRITE;
-		inf.m_usage = BufferUsageBit::ALL_STORAGE;
+		inf.m_usage = BufferUsageBit::kAllStorage;
 		inf.m_size = sizeof(Model) * U32(GeomWhat::kCount);
 
 		modelBuffer = gr->newBuffer(inf);
@@ -3305,7 +3305,7 @@ void main()
 
 		BufferInitInfo inf;
 		inf.m_mapAccess = BufferMapAccessBit::WRITE;
-		inf.m_usage = BufferUsageBit::SBT;
+		inf.m_usage = BufferUsageBit::kSBT;
 		inf.m_size = sbtRecordSize * recordCount;
 
 		sbt = gr->newBuffer(inf);
@@ -3371,7 +3371,7 @@ void main()
 	{
 		BufferInitInfo inf;
 		inf.m_mapAccess = BufferMapAccessBit::WRITE;
-		inf.m_usage = BufferUsageBit::ALL_STORAGE;
+		inf.m_usage = BufferUsageBit::kAllStorage;
 		inf.m_size = sizeof(Light) * lightCount;
 
 		lightBuffer = gr->newBuffer(inf);
@@ -3562,7 +3562,7 @@ void main()
 	// Create buffers
 	BufferInitInfo info;
 	info.m_size = sizeof(U32) * ARRAY_SIZE;
-	info.m_usage = BufferUsageBit::ALL_COMPUTE;
+	info.m_usage = BufferUsageBit::kAllCompute;
 	info.m_mapAccess = BufferMapAccessBit::WRITE | BufferMapAccessBit::READ;
 	BufferPtr atomicsBuffer = gr->newBuffer(info);
 	U32* values =

Tests/Gr/GrTextureBuffer.cpp

@@ -38,7 +38,7 @@ void main()
 		BufferInitInfo buffInit;
 		buffInit.m_mapAccess = BufferMapAccessBit::WRITE;
 		buffInit.m_size = sizeof(U8) * 4;
-		buffInit.m_usage = BufferUsageBit::ALL_TEXTURE;
+		buffInit.m_usage = BufferUsageBit::kAllTexture;
 		BufferPtr texBuff = gr->newBuffer(buffInit);
 
 		I8* data = static_cast<I8*>(texBuff->map(0, kMaxPtrSize, BufferMapAccessBit::WRITE));
@@ -52,7 +52,7 @@ void main()
 
 		buffInit.m_mapAccess = BufferMapAccessBit::READ;
 		buffInit.m_size = sizeof(F32) * 4;
-		buffInit.m_usage = BufferUsageBit::ALL_STORAGE;
+		buffInit.m_usage = BufferUsageBit::kAllStorage;
 		BufferPtr storageBuff = gr->newBuffer(buffInit);
 
 		CommandBufferInitInfo cmdbInit;