Some code style refactoring

AnKi/Core/App.cpp

@@ -268,7 +268,7 @@ Error App::initInternal(AllocAlignedCallback allocCb, void* allocCbUserData)
 	//
 	// Mali HW counters
 	//
-	if(m_gr->getDeviceCapabilities().m_gpuVendor == GpuVendor::ARM && m_config->getCoreMaliHwCounters())
+	if(m_gr->getDeviceCapabilities().m_gpuVendor == GpuVendor::kArm && m_config->getCoreMaliHwCounters())
 	{
 		m_maliHwCounters = m_heapAlloc.newInstance<MaliHwCounters>(m_heapAlloc);
 	}

AnKi/Gr/AccelerationStructure.h

@@ -26,13 +26,13 @@ public:
 	BufferPtr m_positionBuffer;
 	PtrSize m_positionBufferOffset = 0;
 	U32 m_positionStride = 0;
-	Format m_positionsFormat = Format::NONE;
+	Format m_positionsFormat = Format::kNone;
 	U32 m_positionCount = 0;
 
 	Bool isValid() const
 	{
 		if(m_indexBuffer.get() == nullptr || m_indexCount == 0 || m_indexType == IndexType::COUNT
-		   || m_positionBuffer.get() == nullptr || m_positionStride == 0 || m_positionsFormat == Format::NONE
+		   || m_positionBuffer.get() == nullptr || m_positionStride == 0 || m_positionsFormat == Format::kNone
 		   || m_positionCount == 0)
 		{
 			return false;

AnKi/Gr/CommandBuffer.h

@@ -40,7 +40,7 @@ class CommandBufferInitInfo : public GrBaseInitInfo
 public:
 	FramebufferPtr m_framebuffer; ///< For second level command buffers.
 	Array<TextureUsageBit, MAX_COLOR_ATTACHMENTS> m_colorAttachmentUsages = {};
-	TextureUsageBit m_depthStencilAttachmentUsage = TextureUsageBit::NONE;
+	TextureUsageBit m_depthStencilAttachmentUsage = TextureUsageBit::kNone;
 
 	CommandBufferFlag m_flags = CommandBufferFlag::NONE;
 
@@ -68,7 +68,7 @@ public:
 
 	/// Bind vertex buffer.
 	void bindVertexBuffer(U32 binding, const BufferPtr& buff, PtrSize offset, PtrSize stride,
-						  VertexStepRate stepRate = VertexStepRate::VERTEX);
+						  VertexStepRate stepRate = VertexStepRate::kVertex);
 
 	/// Setup a vertex attribute.
 	void setVertexAttribute(U32 location, U32 buffBinding, Format fmt, PtrSize relativeOffset);
@@ -292,7 +292,7 @@ public:
 				   U32 rayTypeCount, U32 width, U32 height, U32 depth);
 
 	/// Generate mipmaps for non-3D textures. You have to transition all the mip levels of this face and layer to
-	/// TextureUsageBit::GENERATE_MIPMAPS before calling this method.
+	/// TextureUsageBit::kGenerateMipmaps before calling this method.
 	/// @param texView The texture view to generate mips. It should point to a subresource that contains the whole
 	///                mip chain and only one face and one layer.
 	void generateMipmaps2d(const TextureViewPtr& texView);

AnKi/Gr/Common.cpp

@@ -31,14 +31,14 @@ FormatInfo getFormatInfo(Format fmt)
 	{
 #define ANKI_FORMAT_DEF(type, id, componentCount, texelSize, blockWidth, blockHeight, blockSize, shaderType, \
 						depthStencil) \
-	case Format::type: \
+	case Format::k##type: \
 		out = {componentCount, \
 			   texelSize, \
 			   blockWidth, \
 			   blockHeight, \
 			   blockSize, \
 			   shaderType, \
-			   DepthStencilAspectBit::depthStencil, \
+			   DepthStencilAspectBit::k##depthStencil, \
 			   ANKI_STRINGIZE(type)}; \
 		break;
 #include <AnKi/Gr/Format.defs.h>
@@ -56,7 +56,7 @@ PtrSize computeSurfaceSize(U32 width32, U32 height32, Format fmt)
 	const PtrSize width = width32;
 	const PtrSize height = height32;
 	ANKI_ASSERT(width > 0 && height > 0);
-	ANKI_ASSERT(fmt != Format::NONE);
+	ANKI_ASSERT(fmt != Format::kNone);
 
 	const FormatInfo inf = getFormatInfo(fmt);
 
@@ -79,7 +79,7 @@ PtrSize computeVolumeSize(U32 width32, U32 height32, U32 depth32, Format fmt)
 	const PtrSize height = height32;
 	const PtrSize depth = depth32;
 	ANKI_ASSERT(width > 0 && height > 0 && depth > 0);
-	ANKI_ASSERT(fmt != Format::NONE);
+	ANKI_ASSERT(fmt != Format::kNone);
 
 	const FormatInfo inf = getFormatInfo(fmt);
 

AnKi/Gr/Common.h

@@ -103,17 +103,17 @@ public:
 /// Knowing the vendor allows some optimizations
 enum class GpuVendor : U8
 {
-	UNKNOWN,
-	ARM,
-	NVIDIA,
-	AMD,
-	INTEL,
-	QUALCOMM,
-	COUNT
+	kUnknown,
+	kArm,
+	kNvidia,
+	kAMD,
+	kIntel,
+	kQualcomm,
+	kCount
 };
 
-inline constexpr Array<CString, U(GpuVendor::COUNT)> GPU_VENDOR_STR = {"UNKNOWN", "ARM",   "NVIDIA",
-																	   "AMD",     "INTEL", "QUALCOMM"};
+inline constexpr Array<CString, U(GpuVendor::kCount)> GPU_VENDOR_STR = {"unknown", "ARM",   "nVidia",
+																		"AMD",     "Intel", "Qualcomm"};
 
 /// Device capabilities.
 ANKI_BEGIN_PACKED_STRUCT
@@ -160,7 +160,7 @@ public:
 	U32 m_minShadingRateImageTexelSize = 0;
 
 	/// GPU vendor.
-	GpuVendor m_gpuVendor = GpuVendor::UNKNOWN;
+	GpuVendor m_gpuVendor = GpuVendor::kUnknown;
 
 	/// Descrete or integrated GPU.
 	Bool m_discreteGpu = false;
@@ -245,117 +245,117 @@ private:
 
 enum class ColorBit : U8
 {
-	NONE = 0,
-	RED = 1 << 0,
-	GREEN = 1 << 1,
-	BLUE = 1 << 2,
-	ALPHA = 1 << 3,
-	ALL = RED | GREEN | BLUE | ALPHA
+	kNone = 0,
+	kRed = 1 << 0,
+	kGreen = 1 << 1,
+	kBlue = 1 << 2,
+	kAlpha = 1 << 3,
+	kAll = kRed | kGreen | kBlue | kAlpha
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(ColorBit)
 
 enum class PrimitiveTopology : U8
 {
-	POINTS,
-	LINES,
-	LINE_STRIP,
-	TRIANGLES,
-	TRIANGLE_STRIP,
-	PATCHES
+	kPoints,
+	kLines,
+	kLineStip,
+	kTriangles,
+	kTriangleStrip,
+	kPatchs
 };
 
 enum class FillMode : U8
 {
-	POINTS,
-	WIREFRAME,
-	SOLID,
-	COUNT
+	kPoints,
+	kWireframe,
+	kSolid,
+	kCount
 };
 
 enum class FaceSelectionBit : U8
 {
-	NONE = 0,
-	FRONT = 1 << 0,
-	BACK = 1 << 1,
-	FRONT_AND_BACK = FRONT | BACK
+	kNone = 0,
+	kFront = 1 << 0,
+	kBack = 1 << 1,
+	kFrontAndBack = kFront | kBack
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(FaceSelectionBit)
 
 enum class CompareOperation : U8
 {
-	ALWAYS,
-	LESS,
-	EQUAL,
-	LESS_EQUAL,
-	GREATER,
-	GREATER_EQUAL,
-	NOT_EQUAL,
-	NEVER,
-	COUNT
+	kAlways,
+	kLess,
+	kEqual,
+	kLessEqual,
+	kGreater,
+	kGreaterEqual,
+	kNotEqual,
+	kNever,
+	kCount
 };
 
 enum class StencilOperation : U8
 {
-	KEEP,
-	ZERO,
-	REPLACE,
-	INCREMENT_AND_CLAMP,
-	DECREMENT_AND_CLAMP,
-	INVERT,
-	INCREMENT_AND_WRAP,
-	DECREMENT_AND_WRAP,
-	COUNT
+	kKeep,
+	kZero,
+	kReplace,
+	kIncrementAndClamp,
+	kDecrementAndClamp,
+	kInvert,
+	kIncrementAndWrap,
+	kDecrementAndWrap,
+	kCount
 };
 
 enum class BlendFactor : U8
 {
-	ZERO,
-	ONE,
-	SRC_COLOR,
-	ONE_MINUS_SRC_COLOR,
-	DST_COLOR,
-	ONE_MINUS_DST_COLOR,
-	SRC_ALPHA,
-	ONE_MINUS_SRC_ALPHA,
-	DST_ALPHA,
-	ONE_MINUS_DST_ALPHA,
-	CONSTANT_COLOR,
-	ONE_MINUS_CONSTANT_COLOR,
-	CONSTANT_ALPHA,
-	ONE_MINUS_CONSTANT_ALPHA,
-	SRC_ALPHA_SATURATE,
-	SRC1_COLOR,
-	ONE_MINUS_SRC1_COLOR,
-	SRC1_ALPHA,
-	ONE_MINUS_SRC1_ALPHA,
-	COUNT
+	kZero,
+	kOne,
+	kSrcColor,
+	kOneMinusSrcColor,
+	kDstColor,
+	kOneMinusDstColor,
+	kSrcAlpha,
+	kOneMinusSrcAlpha,
+	kDstAlpha,
+	kOneMinusDstAlpha,
+	kConstantColor,
+	kOneMinusConstantColor,
+	kConstantAlpha,
+	kOneMinusConstantAlpha,
+	kSrcAlphaSaturate,
+	kSrc1Color,
+	kOneMinusSrc1Color,
+	kSrc1Alpha,
+	kOneMinusSrc1Alpha,
+	kCount
 };
 
 enum class BlendOperation : U8
 {
-	ADD,
-	SUBTRACT,
-	REVERSE_SUBTRACT,
-	MIN,
-	MAX,
-	COUNT
+	kAdd,
+	kSubtract,
+	kReverseSubtract,
+	kMin,
+	kMax,
+	kCount
 };
 
 enum class VertexStepRate : U8
 {
-	VERTEX,
-	INSTANCE,
-	DRAW,
-	COUNT
+	kVertex,
+	kInstance,
+	kDraw,
+	kCount
 };
 
 /// A way to distinguish the aspect of a depth stencil texture.
 enum class DepthStencilAspectBit : U8
 {
-	NONE = 0,
-	DEPTH = 1 << 0,
-	STENCIL = 1 << 1,
-	DEPTH_STENCIL = DEPTH | STENCIL
+	kNone = 0,
+	kDepth = 1 << 0,
+	kStencil = 1 << 1,
+	kDepthStencil = kDepth | kStencil
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(DepthStencilAspectBit)
 
@@ -363,11 +363,11 @@ ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(DepthStencilAspectBit)
 /// WARNING: Keep it the same as vulkan (one conversion less).
 enum class Format : U32
 {
-	NONE = 0,
+	kNone = 0,
 
 #define ANKI_FORMAT_DEF(type, id, componentCount, texelSize, blockWidth, blockHeight, blockSize, shaderType, \
 						depthStencil) \
-	type = id,
+	k##type = id,
 #include <AnKi/Gr/Format.defs.h>
 #undef ANKI_FORMAT_DEF
 };
@@ -388,17 +388,17 @@ public:
 
 	Bool isDepthStencil() const
 	{
-		return m_depthStencil != DepthStencilAspectBit::NONE;
+		return m_depthStencil != DepthStencilAspectBit::kNone;
 	}
 
 	Bool isDepth() const
 	{
-		return !!(m_depthStencil & DepthStencilAspectBit::DEPTH);
+		return !!(m_depthStencil & DepthStencilAspectBit::kDepth);
 	}
 
 	Bool isStencil() const
 	{
-		return !!(m_depthStencil & DepthStencilAspectBit::STENCIL);
+		return !!(m_depthStencil & DepthStencilAspectBit::kStencil);
 	}
 
 	Bool isCompressed() const
@@ -419,137 +419,131 @@ ANKI_PURE PtrSize computeVolumeSize(U32 width, U32 height, U32 depth, Format fmt
 /// Texture type.
 enum class TextureType : U8
 {
-	_1D,
-	_2D,
-	_3D,
-	_2D_ARRAY,
-	CUBE,
-	CUBE_ARRAY,
-	COUNT
+	k1D,
+	k2D,
+	k3D,
+	k2DArray,
+	kCube,
+	kCubeArray,
+	kCount
 };
 
 inline Bool textureTypeIsCube(const TextureType t)
 {
-	return t == TextureType::CUBE || t == TextureType::CUBE_ARRAY;
+	return t == TextureType::kCube || t == TextureType::kCubeArray;
 }
 
 /// Texture usage hints. They are very important.
 enum class TextureUsageBit : U32
 {
-	NONE = 0,
+	kNone = 0,
 
-	SAMPLED_GEOMETRY = 1 << 0,
-	SAMPLED_FRAGMENT = 1 << 1,
-	SAMPLED_COMPUTE = 1 << 2,
-	SAMPLED_TRACE_RAYS = 1 << 3,
+	kSampledGeometry = 1 << 0,
+	kSampledFragment = 1 << 1,
+	kSampledCompute = 1 << 2,
+	kSampledTraceRays = 1 << 3,
 
-	IMAGE_GEOMETRY_READ = 1 << 4,
-	IMAGE_GEOMETRY_WRITE = 1 << 5,
-	IMAGE_FRAGMENT_READ = 1 << 6,
-	IMAGE_FRAGMENT_WRITE = 1 << 7,
-	IMAGE_COMPUTE_READ = 1 << 8,
-	IMAGE_COMPUTE_WRITE = 1 << 9,
-	IMAGE_TRACE_RAYS_READ = 1 << 10,
-	IMAGE_TRACE_RAYS_WRITE = 1 << 11,
+	kImageGeometryRead = 1 << 4,
+	kImageGeometryWrite = 1 << 5,
+	kImageFragmentRead = 1 << 6,
+	kImageFragmentWrite = 1 << 7,
+	kImageComputeRead = 1 << 8,
+	kImageComputeWrite = 1 << 9,
+	kImageTraceRaysRead = 1 << 10,
+	kImageTraceRaysWrite = 1 << 11,
 
-	FRAMEBUFFER_ATTACHMENT_READ = 1 << 12,
-	FRAMEBUFFER_ATTACHMENT_WRITE = 1 << 13,
-	FRAMEBUFFER_SHADING_RATE = 1 << 14,
+	kFramebufferRead = 1 << 12,
+	kFramebufferWrite = 1 << 13,
+	kFramebufferShadingRate = 1 << 14,
 
-	TRANSFER_DESTINATION = 1 << 15,
-	GENERATE_MIPMAPS = 1 << 16,
+	kTransferDestination = 1 << 15,
+	kGenerateMipmaps = 1 << 16,
 
-	PRESENT = 1 << 17,
+	kPresent = 1 << 17,
 
 	// Derived
-	ALL_SAMPLED = SAMPLED_GEOMETRY | SAMPLED_FRAGMENT | SAMPLED_COMPUTE | SAMPLED_TRACE_RAYS,
-	ALL_IMAGE = IMAGE_GEOMETRY_READ | IMAGE_GEOMETRY_WRITE | IMAGE_FRAGMENT_READ | IMAGE_FRAGMENT_WRITE
-				| IMAGE_COMPUTE_READ | IMAGE_COMPUTE_WRITE | IMAGE_TRACE_RAYS_READ | IMAGE_TRACE_RAYS_WRITE,
-	ALL_FRAMEBUFFER_ATTACHMENT = FRAMEBUFFER_ATTACHMENT_READ | FRAMEBUFFER_ATTACHMENT_WRITE,
-
-	ALL_GRAPHICS = SAMPLED_GEOMETRY | SAMPLED_FRAGMENT | IMAGE_GEOMETRY_READ | IMAGE_GEOMETRY_WRITE
-				   | IMAGE_FRAGMENT_READ | IMAGE_FRAGMENT_WRITE | FRAMEBUFFER_ATTACHMENT_READ
-				   | FRAMEBUFFER_ATTACHMENT_WRITE | FRAMEBUFFER_SHADING_RATE,
-	ALL_COMPUTE = SAMPLED_COMPUTE | IMAGE_COMPUTE_READ | IMAGE_COMPUTE_WRITE,
-	ALL_TRANSFER = TRANSFER_DESTINATION | GENERATE_MIPMAPS,
-
-	ALL_READ = ALL_SAMPLED | IMAGE_GEOMETRY_READ | IMAGE_FRAGMENT_READ | IMAGE_COMPUTE_READ | IMAGE_TRACE_RAYS_READ
-			   | FRAMEBUFFER_ATTACHMENT_READ | FRAMEBUFFER_SHADING_RATE | PRESENT | GENERATE_MIPMAPS,
-	ALL_WRITE = IMAGE_GEOMETRY_WRITE | IMAGE_FRAGMENT_WRITE | IMAGE_COMPUTE_WRITE | IMAGE_TRACE_RAYS_WRITE
-				| FRAMEBUFFER_ATTACHMENT_WRITE | TRANSFER_DESTINATION | GENERATE_MIPMAPS,
-
-	/// Make GR upscaling usage equal to ALL_IMAGE to force GENERAL layout because who knows.
-	ALL_GR_UPSCALING = ALL_IMAGE,
-	ALL_GR_UPSCALING_READ = ALL_GR_UPSCALING & ALL_READ,
-	ALL_GR_UPSCALING_WRITE = ALL_GR_UPSCALING & ALL_WRITE,
+	kAllSampled = kSampledGeometry | kSampledFragment | kSampledCompute | kSampledTraceRays,
+	kAllImage = kImageGeometryRead | kImageGeometryWrite | kImageFragmentRead | kImageFragmentWrite | kImageComputeRead
+				| kImageComputeWrite | kImageTraceRaysRead | kImageTraceRaysWrite,
+	kAllFramebuffer = kFramebufferRead | kFramebufferWrite,
+
+	kAllGraphics = kSampledGeometry | kSampledFragment | kImageGeometryRead | kImageGeometryWrite | kImageFragmentRead
+				   | kImageFragmentWrite | kFramebufferRead | kFramebufferWrite | kFramebufferShadingRate,
+	kAllCompute = kSampledCompute | kImageComputeRead | kImageComputeWrite,
+	kAllTransfer = kTransferDestination | kGenerateMipmaps,
+
+	kAllRead = kAllSampled | kImageGeometryRead | kImageFragmentRead | kImageComputeRead | kImageTraceRaysRead
+			   | kFramebufferRead | kFramebufferShadingRate | kPresent | kGenerateMipmaps,
+	kAllWrite = kImageGeometryWrite | kImageFragmentWrite | kImageComputeWrite | kImageTraceRaysWrite
+				| kFramebufferWrite | kTransferDestination | kGenerateMipmaps,
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(TextureUsageBit)
 
 enum class SamplingFilter : U8
 {
-	NEAREST,
-	LINEAR,
-	MIN, ///< It calculates the min of a 2x2 quad. Only if GpuDeviceCapabilities::m_samplingFilterMinMax is supported.
-	MAX, ///< It calculates the max of a 2x2 quad. Only if GpuDeviceCapabilities::m_samplingFilterMinMax is supported.
-	BASE ///< Only for mipmaps.
+	kNearest,
+	kLinear,
+	kMin, ///< It calculates the min of a 2x2 quad. Only if GpuDeviceCapabilities::m_samplingFilterMinMax is supported.
+	kMax, ///< It calculates the max of a 2x2 quad. Only if GpuDeviceCapabilities::m_samplingFilterMinMax is supported.
+	kBase ///< Only for mipmaps.
 };
 
 enum class SamplingAddressing : U8
 {
-	CLAMP,
-	REPEAT,
-	BLACK,
-	WHITE,
-
-	COUNT,
-	FIRST = 0,
-	LAST = COUNT - 1,
+	kClamp,
+	kRepeat,
+	kBlack,
+	kWhite,
+
+	kCount,
+	kFirst = 0,
+	kLast = kCount - 1,
 };
 
 enum class ShaderType : U16
 {
-	VERTEX,
-	TESSELLATION_CONTROL,
-	TESSELLATION_EVALUATION,
-	GEOMETRY,
-	FRAGMENT,
-	COMPUTE,
-	RAY_GEN,
-	ANY_HIT,
-	CLOSEST_HIT,
-	MISS,
-	INTERSECTION,
-	CALLABLE,
-
-	COUNT,
-	FIRST = 0,
-	LAST = COUNT - 1,
-	FIRST_GRAPHICS = VERTEX,
-	LAST_GRAPHICS = FRAGMENT,
-	FIRST_RAY_TRACING = RAY_GEN,
-	LAST_RAY_TRACING = CALLABLE,
+	kVertex,
+	kTessellationControl,
+	kTessellationEvaluation,
+	kGeometry,
+	kFragment,
+	kCompute,
+	kRayGen,
+	kAnyHit,
+	kClosestHit,
+	kMiss,
+	kIntersection,
+	kCallable,
+
+	kCount,
+	kFirst = 0,
+	kLast = kCount - 1,
+	kFirstGraphics = kVertex,
+	kLastGraphics = kFragment,
+	kFirstRayTracing = kRayGen,
+	kLastRayTracing = kCallable,
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(ShaderType)
 
 enum class ShaderTypeBit : U16
 {
-	VERTEX = 1 << 0,
-	TESSELLATION_CONTROL = 1 << 1,
-	TESSELLATION_EVALUATION = 1 << 2,
-	GEOMETRY = 1 << 3,
-	FRAGMENT = 1 << 4,
-	COMPUTE = 1 << 5,
-	RAY_GEN = 1 << 6,
-	ANY_HIT = 1 << 7,
-	CLOSEST_HIT = 1 << 8,
-	MISS = 1 << 9,
-	INTERSECTION = 1 << 10,
-	CALLABLE = 1 << 11,
-
-	NONE = 0,
-	ALL_GRAPHICS = VERTEX | TESSELLATION_CONTROL | TESSELLATION_EVALUATION | GEOMETRY | FRAGMENT,
-	ALL_RAY_TRACING = RAY_GEN | ANY_HIT | CLOSEST_HIT | MISS | INTERSECTION | CALLABLE,
-	ALL = ALL_GRAPHICS | COMPUTE | ALL_RAY_TRACING,
+	kVertex = 1 << 0,
+	kTessellationControl = 1 << 1,
+	kTessellationEvaluation = 1 << 2,
+	kGeometry = 1 << 3,
+	kFragment = 1 << 4,
+	kCompute = 1 << 5,
+	kRayGen = 1 << 6,
+	kAnyHit = 1 << 7,
+	kClosestHit = 1 << 8,
+	kMiss = 1 << 9,
+	kIntersection = 1 << 10,
+	kCallable = 1 << 11,
+
+	kNone = 0,
+	kAllGraphics = kVertex | kTessellationControl | kTessellationEvaluation | kGeometry | kFragment,
+	kAllRayTracing = kRayGen | kAnyHit | kClosestHit | kMiss | kIntersection | kCallable,
+	kAll = kAllGraphics | kCompute | kAllRayTracing,
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(ShaderTypeBit)
 
@@ -962,11 +956,11 @@ public:
 	U8 m_firstFace = 0;
 	U8 m_faceCount = 1;
 
-	DepthStencilAspectBit m_depthStencilAspect = DepthStencilAspectBit::NONE;
+	DepthStencilAspectBit m_depthStencilAspect = DepthStencilAspectBit::kNone;
 
 	U8 _m_padding[1] = {0};
 
-	constexpr TextureSubresourceInfo(DepthStencilAspectBit aspect = DepthStencilAspectBit::NONE)
+	constexpr TextureSubresourceInfo(DepthStencilAspectBit aspect = DepthStencilAspectBit::kNone)
 		: m_depthStencilAspect(aspect)
 	{
 	}
@@ -974,7 +968,7 @@ public:
 	TextureSubresourceInfo(const TextureSubresourceInfo&) = default;
 
 	constexpr TextureSubresourceInfo(const TextureSurfaceInfo& surf,
-									 DepthStencilAspectBit aspect = DepthStencilAspectBit::NONE)
+									 DepthStencilAspectBit aspect = DepthStencilAspectBit::kNone)
 		: m_firstMipmap(surf.m_level)
 		, m_mipmapCount(1)
 		, m_firstLayer(surf.m_layer)
@@ -986,7 +980,7 @@ public:
 	}
 
 	constexpr TextureSubresourceInfo(const TextureVolumeInfo& vol,
-									 DepthStencilAspectBit aspect = DepthStencilAspectBit::NONE)
+									 DepthStencilAspectBit aspect = DepthStencilAspectBit::kNone)
 		: m_firstMipmap(vol.m_level)
 		, m_mipmapCount(1)
 		, m_firstLayer(0)
@@ -1023,8 +1017,8 @@ public:
 			return (beginA < beginB) ? (beginA + countA > beginB) : (beginB + countB > beginA);
 		};
 
-		const Bool depthStencilOverlaps = (m_depthStencilAspect == DepthStencilAspectBit::NONE
-										   && b.m_depthStencilAspect == DepthStencilAspectBit::NONE)
+		const Bool depthStencilOverlaps = (m_depthStencilAspect == DepthStencilAspectBit::kNone
+										   && b.m_depthStencilAspect == DepthStencilAspectBit::kNone)
 										  || !!(m_depthStencilAspect & b.m_depthStencilAspect);
 
 		return overlaps(m_firstMipmap, m_mipmapCount, b.m_firstMipmap, b.m_mipmapCount)
@@ -1037,8 +1031,8 @@ class TextureBarrierInfo
 {
 public:
 	Texture* m_texture = nullptr;
-	TextureUsageBit m_previousUsage = TextureUsageBit::NONE;
-	TextureUsageBit m_nextUsage = TextureUsageBit::NONE;
+	TextureUsageBit m_previousUsage = TextureUsageBit::kNone;
+	TextureUsageBit m_nextUsage = TextureUsageBit::kNone;
 	TextureSubresourceInfo m_subresource;
 };
 

AnKi/Gr/Format.defs.h

@@ -15,203 +15,203 @@
 // 9) Aspect
 
 // clang-format off
-//              Name                                 ID  CC  TS  BW  BH  BS  ST         ASPECT
-ANKI_FORMAT_DEF(R4G4_UNORM_PACK8,                     1,  2,  1,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R4G4B4A4_UNORM_PACK16,                2,  4,  2,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(B4G4R4A4_UNORM_PACK16,                3,  4,  2,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R5G6B5_UNORM_PACK16,                  4,  3,  2,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(B5G6R5_UNORM_PACK16,                  5,  3,  2,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R5G5B5A1_UNORM_PACK16,                6,  4,  2,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(B5G5R5A1_UNORM_PACK16,                7,  4,  2,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(A1R5G5B5_UNORM_PACK16,                8,  4,  2,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R8_UNORM,                             9,  1,  1,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R8_SNORM,                            10,  1,  1,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R8_USCALED,                          11,  1,  1,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(R8_SSCALED,                          12,  1,  1,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(R8_UINT,                             13,  1,  1,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(R8_SINT,                             14,  1,  1,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(R8_SRGB,                             15,  1,  1,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R8G8_UNORM,                          16,  2,  2,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R8G8_SNORM,                          17,  2,  2,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R8G8_USCALED,                        18,  2,  2,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(R8G8_SSCALED,                        19,  2,  2,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(R8G8_UINT,                           20,  2,  2,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(R8G8_SINT,                           21,  2,  2,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(R8G8_SRGB,                           22,  2,  2,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R8G8B8_UNORM,                        23,  3,  3,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R8G8B8_SNORM,                        24,  3,  3,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R8G8B8_USCALED,                      25,  3,  3,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(R8G8B8_SSCALED,                      26,  3,  3,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(R8G8B8_UINT,                         27,  3,  3,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(R8G8B8_SINT,                         28,  3,  3,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(R8G8B8_SRGB,                         29,  3,  3,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(B8G8R8_UNORM,                        30,  3,  3,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(B8G8R8_SNORM,                        31,  3,  3,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(B8G8R8_USCALED,                      32,  3,  3,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(B8G8R8_SSCALED,                      33,  3,  3,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(B8G8R8_UINT,                         34,  3,  3,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(B8G8R8_SINT,                         35,  3,  3,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(B8G8R8_SRGB,                         36,  3,  3,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R8G8B8A8_UNORM,                      37,  4,  4,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R8G8B8A8_SNORM,                      38,  4,  4,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R8G8B8A8_USCALED,                    39,  4,  4,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(R8G8B8A8_SSCALED,                    40,  4,  4,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(R8G8B8A8_UINT,                       41,  4,  4,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(R8G8B8A8_SINT,                       42,  4,  4,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(R8G8B8A8_SRGB,                       43,  4,  4,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(B8G8R8A8_UNORM,                      44,  4,  4,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(B8G8R8A8_SNORM,                      45,  4,  4,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(B8G8R8A8_USCALED,                    46,  4,  4,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(B8G8R8A8_SSCALED,                    47,  4,  4,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(B8G8R8A8_UINT,                       48,  4,  4,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(B8G8R8A8_SINT,                       49,  4,  4,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(B8G8R8A8_SRGB,                       50,  4,  4,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(A8B8G8R8_UNORM_PACK32,               51,  4,  4,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(A8B8G8R8_SNORM_PACK32,               52,  4,  4,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(A8B8G8R8_USCALED_PACK32,             53,  4,  4,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(A8B8G8R8_SSCALED_PACK32,             54,  4,  4,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(A8B8G8R8_UINT_PACK32,                55,  4,  4,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(A8B8G8R8_SINT_PACK32,                56,  4,  4,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(A8B8G8R8_SRGB_PACK32,                57,  4,  4,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(A2R10G10B10_UNORM_PACK32,            58,  4,  4,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(A2R10G10B10_SNORM_PACK32,            59,  4,  4,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(A2R10G10B10_USCALED_PACK32,          60,  4,  4,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(A2R10G10B10_SSCALED_PACK32,          61,  4,  4,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(A2R10G10B10_UINT_PACK32,             62,  4,  4,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(A2R10G10B10_SINT_PACK32,             63,  4,  4,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(A2B10G10R10_UNORM_PACK32,            64,  4,  4,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(A2B10G10R10_SNORM_PACK32,            65,  4,  4,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(A2B10G10R10_USCALED_PACK32,          66,  4,  4,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(A2B10G10R10_SSCALED_PACK32,          67,  4,  4,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(A2B10G10R10_UINT_PACK32,             68,  4,  4,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(A2B10G10R10_SINT_PACK32,             69,  4,  4,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(R16_UNORM,                           70,  1,  2,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R16_SNORM,                           71,  1,  2,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R16_USCALED,                         72,  1,  2,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(R16_SSCALED,                         73,  1,  2,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(R16_UINT,                            74,  1,  2,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(R16_SINT,                            75,  1,  2,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(R16_SFLOAT,                          76,  1,  2,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R16G16_UNORM,                        77,  2,  4,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R16G16_SNORM,                        78,  2,  4,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R16G16_USCALED,                      79,  2,  4,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(R16G16_SSCALED,                      80,  2,  4,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(R16G16_UINT,                         81,  2,  4,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(R16G16_SINT,                         82,  2,  4,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(R16G16_SFLOAT,                       83,  2,  4,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R16G16B16_UNORM,                     84,  3,  6,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R16G16B16_SNORM,                     85,  3,  6,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R16G16B16_USCALED,                   86,  3,  6,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(R16G16B16_SSCALED,                   87,  3,  6,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(R16G16B16_UINT,                      88,  3,  6,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(R16G16B16_SINT,                      89,  3,  6,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(R16G16B16_SFLOAT,                    90,  3,  6,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R16G16B16A16_UNORM,                  91,  4,  8,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R16G16B16A16_SNORM,                  92,  4,  8,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R16G16B16A16_USCALED,                93,  4,  8,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(R16G16B16A16_SSCALED,                94,  4,  8,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(R16G16B16A16_UINT,                   95,  4,  8,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(R16G16B16A16_SINT,                   96,  4,  8,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(R16G16B16A16_SFLOAT,                 97,  4,  8,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R32_UINT,                            98,  1,  4,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(R32_SINT,                            99,  1,  4,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(R32_SFLOAT,                         100,  1,  4,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R32G32_UINT,                        101,  2,  8,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(R32G32_SINT,                        102,  2,  8,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(R32G32_SFLOAT,                      103,  2,  8,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R32G32B32_UINT,                     104,  3, 12,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(R32G32B32_SINT,                     105,  3, 12,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(R32G32B32_SFLOAT,                   106,  3, 12,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R32G32B32A32_UINT,                  107,  4, 16,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(R32G32B32A32_SINT,                  108,  4, 16,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(R32G32B32A32_SFLOAT,                109,  4, 16,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R64_UINT,                           110,  1,  8,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(R64_SINT,                           111,  1,  8,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(R64_SFLOAT,                         112,  1,  8,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R64G64_UINT,                        113,  2, 16,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(R64G64_SINT,                        114,  2, 16,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(R64G64_SFLOAT,                      115,  2, 16,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R64G64B64_UINT,                     116,  3, 24,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(R64G64B64_SINT,                     117,  3, 24,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(R64G64B64_SFLOAT,                   118,  3, 24,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(R64G64B64A64_UINT,                  119,  4, 32,  0,  0,  0,  1,          NONE)
-ANKI_FORMAT_DEF(R64G64B64A64_SINT,                  120,  4, 32,  0,  0,  0,  2,          NONE)
-ANKI_FORMAT_DEF(R64G64B64A64_SFLOAT,                121,  4, 32,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(B10G11R11_UFLOAT_PACK32,            122,  3,  4,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(E5B9G9R9_UFLOAT_PACK32,             123,  3,  4,  0,  0,  0,  0,          NONE)
-ANKI_FORMAT_DEF(D16_UNORM,                          124,  0,  2,  0,  0,  0,  0,         DEPTH)
-ANKI_FORMAT_DEF(X8_D24_UNORM_PACK32,                125,  0,  4,  0,  0,  0,  0,         DEPTH)
-ANKI_FORMAT_DEF(D32_SFLOAT,                         126,  0,  4,  0,  0,  0,  0,         DEPTH)
-ANKI_FORMAT_DEF(S8_UINT,                            127,  0,  1,  0,  0,  0,  1,       STENCIL)
-ANKI_FORMAT_DEF(D16_UNORM_S8_UINT,                  128,  0,  3,  0,  0,  0,  0, DEPTH_STENCIL)
-ANKI_FORMAT_DEF(D24_UNORM_S8_UINT,                  129,  0,  4,  0,  0,  0,  0, DEPTH_STENCIL)
-ANKI_FORMAT_DEF(D32_SFLOAT_S8_UINT,                 130,  0,  0,  0,  0,  0,  0, DEPTH_STENCIL)
-ANKI_FORMAT_DEF(BC1_RGB_UNORM_BLOCK,                131,  3,  0,  4,  4,  8,  0,          NONE)
-ANKI_FORMAT_DEF(BC1_RGB_SRGB_BLOCK,                 132,  3,  0,  4,  4,  8,  0,          NONE)
-ANKI_FORMAT_DEF(BC1_RGBA_UNORM_BLOCK,               133,  4,  0,  4,  4,  8,  0,          NONE)
-ANKI_FORMAT_DEF(BC1_RGBA_SRGB_BLOCK,                134,  4,  0,  4,  4,  8,  0,          NONE)
-ANKI_FORMAT_DEF(BC2_UNORM_BLOCK,                    135,  4,  0,  4,  4, 16,  0,          NONE)
-ANKI_FORMAT_DEF(BC2_SRGB_BLOCK,                     136,  4,  0,  4,  4, 16,  0,          NONE)
-ANKI_FORMAT_DEF(BC3_UNORM_BLOCK,                    137,  4,  0,  4,  4, 16,  0,          NONE)
-ANKI_FORMAT_DEF(BC3_SRGB_BLOCK,                     138,  4,  0,  4,  4, 16,  0,          NONE)
-ANKI_FORMAT_DEF(BC4_UNORM_BLOCK,                    139,  1,  0,  4,  4,  8,  0,          NONE)
-ANKI_FORMAT_DEF(BC4_SNORM_BLOCK,                    140,  1,  0,  4,  4,  8,  0,          NONE)
-ANKI_FORMAT_DEF(BC5_UNORM_BLOCK,                    141,  2,  0,  4,  4, 16,  0,          NONE)
-ANKI_FORMAT_DEF(BC5_SNORM_BLOCK,                    142,  2,  0,  4,  4, 16,  0,          NONE)
-ANKI_FORMAT_DEF(BC6H_UFLOAT_BLOCK,                  143,  3,  0,  4,  4, 16,  0,          NONE)
-ANKI_FORMAT_DEF(BC6H_SFLOAT_BLOCK,                  144,  3,  0,  4,  4, 16,  0,          NONE)
-ANKI_FORMAT_DEF(BC7_UNORM_BLOCK,                    145,  4,  0,  4,  4, 16,  0,          NONE)
-ANKI_FORMAT_DEF(BC7_SRGB_BLOCK,                     146,  4,  0,  4,  4, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ETC2_R8G8B8_UNORM_BLOCK,            147,  3,  0,  4,  4,  8,  0,          NONE)
-ANKI_FORMAT_DEF(ETC2_R8G8B8_SRGB_BLOCK,             148,  3,  0,  4,  4,  8,  0,          NONE)
-ANKI_FORMAT_DEF(ETC2_R8G8B8A1_UNORM_BLOCK,          149,  4,  0,  4,  4,  8,  0,          NONE)
-ANKI_FORMAT_DEF(ETC2_R8G8B8A1_SRGB_BLOCK,           150,  4,  0,  4,  4,  8,  0,          NONE)
-ANKI_FORMAT_DEF(ETC2_R8G8B8A8_UNORM_BLOCK,          151,  4,  0,  4,  4, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ETC2_R8G8B8A8_SRGB_BLOCK,           152,  4,  0,  4,  4, 16,  0,          NONE)
-ANKI_FORMAT_DEF(EAC_R11_UNORM_BLOCK,                153,  1,  0,  4,  4,  8,  0,          NONE)
-ANKI_FORMAT_DEF(EAC_R11_SNORM_BLOCK,                154,  1,  0,  4,  4,  8,  0,          NONE)
-ANKI_FORMAT_DEF(EAC_R11G11_UNORM_BLOCK,             155,  2,  0,  4,  4, 16,  0,          NONE)
-ANKI_FORMAT_DEF(EAC_R11G11_SNORM_BLOCK,             156,  2,  0,  4,  4, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_4x4_UNORM_BLOCK,               157,  4,  0,  4,  4, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_4x4_SRGB_BLOCK,                158,  4,  0,  4,  4, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_5x4_UNORM_BLOCK,               159,  4,  0,  5,  4, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_5x4_SRGB_BLOCK,                160,  4,  0,  5,  4, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_5x5_UNORM_BLOCK,               161,  4,  0,  5,  5, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_5x5_SRGB_BLOCK,                162,  4,  0,  5,  5, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_6x5_UNORM_BLOCK,               163,  4,  0,  6,  5, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_6x5_SRGB_BLOCK,                164,  4,  0,  6,  5, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_6x6_UNORM_BLOCK,               165,  4,  0,  6,  6, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_6x6_SRGB_BLOCK,                166,  4,  0,  6,  6, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_8x5_UNORM_BLOCK,               167,  4,  0,  8,  5, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_8x5_SRGB_BLOCK,                168,  4,  0,  8,  5, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_8x6_UNORM_BLOCK,               169,  4,  0,  8,  6, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_8x6_SRGB_BLOCK,                170,  4,  0,  8,  6, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_8x8_UNORM_BLOCK,               171,  4,  0,  8,  8, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_8x8_SRGB_BLOCK,                172,  4,  0,  8,  8, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_10x5_UNORM_BLOCK,              173,  4,  0, 10,  5, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_10x5_SRGB_BLOCK,               174,  4,  0, 10,  5, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_10x6_UNORM_BLOCK,              175,  4,  0, 10,  6, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_10x6_SRGB_BLOCK,               176,  4,  0, 10,  6, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_10x8_UNORM_BLOCK,              177,  4,  0, 10,  8, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_10x8_SRGB_BLOCK,               178,  4,  0, 10,  8, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_10x10_UNORM_BLOCK,             179,  4,  0, 10, 10, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_10x10_SRGB_BLOCK,              180,  4,  0, 10, 10, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_12x10_UNORM_BLOCK,             181,  4,  0, 12, 10, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_12x10_SRGB_BLOCK,              182,  4,  0, 12, 10, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_12x12_UNORM_BLOCK,             183,  4,  0, 12, 12, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_12x12_SRGB_BLOCK,              184,  4,  0, 12, 12, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_4x4_SFLOAT_BLOCK_EXT,   1000066000,  4,  0,  4,  4, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_5x4_SFLOAT_BLOCK_EXT,   1000066001,  4,  0,  5,  4, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_5x5_SFLOAT_BLOCK_EXT,   1000066002,  4,  0,  5,  5, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_6x5_SFLOAT_BLOCK_EXT,   1000066003,  4,  0,  6,  8, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_6x6_SFLOAT_BLOCK_EXT,   1000066004,  4,  0,  6,  6, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_8x5_SFLOAT_BLOCK_EXT,   1000066005,  4,  0,  8,  5, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_8x6_SFLOAT_BLOCK_EXT,   1000066006,  4,  0,  8,  6, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_8x8_SFLOAT_BLOCK_EXT,   1000066007,  4,  0,  8,  8, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_10x5_SFLOAT_BLOCK_EXT,  1000066008,  4,  0, 10,  5, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_10x6_SFLOAT_BLOCK_EXT,  1000066009,  4,  0, 10,  6, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_10x8_SFLOAT_BLOCK_EXT,  1000066010,  4,  0, 10,  8, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_10x10_SFLOAT_BLOCK_EXT, 1000066011,  4,  0, 10, 10, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_12x10_SFLOAT_BLOCK_EXT, 1000066012,  4,  0, 12, 10, 16,  0,          NONE)
-ANKI_FORMAT_DEF(ASTC_12x12_SFLOAT_BLOCK_EXT, 1000066013,  4,  0, 12, 12, 16,  0,          NONE)
+//              Name                                 ID  CC  TS  BW  BH  BS  ST        ASPECT
+ANKI_FORMAT_DEF(R4G4_Unorm_Pack8,                     1,  2,  1,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R4G4B4A4_Unorm_Pack16,                2,  4,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B4G4R4A4_Unorm_Pack16,                3,  4,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R5G6B5_Unorm_Pack16,                  4,  3,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B5G6R5_Unorm_Pack16,                  5,  3,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R5G5B5A1_Unorm_Pack16,                6,  4,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B5G5R5A1_Unorm_Pack16,                7,  4,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(A1R5G5B5_Unorm_Pack16,                8,  4,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8_Unorm,                             9,  1,  1,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8_Snorm,                            10,  1,  1,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8_Uscaled,                          11,  1,  1,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R8_Sscaled,                          12,  1,  1,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R8_Uint,                             13,  1,  1,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R8_Sint,                             14,  1,  1,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R8_SRGB,                             15,  1,  1,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8G8_Unorm,                          16,  2,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8G8_Snorm,                          17,  2,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8G8_Uscaled,                        18,  2,  2,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R8G8_Sscaled,                        19,  2,  2,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R8G8_Uint,                           20,  2,  2,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R8G8_Sint,                           21,  2,  2,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R8G8_SRGB,                           22,  2,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8G8B8_Unorm,                        23,  3,  3,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8G8B8_Snorm,                        24,  3,  3,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8G8B8_Uscaled,                      25,  3,  3,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R8G8B8_Sscaled,                      26,  3,  3,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R8G8B8_Uint,                         27,  3,  3,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R8G8B8_Sint,                         28,  3,  3,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R8G8B8_SRGB,                         29,  3,  3,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B8G8R8_Unorm,                        30,  3,  3,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B8G8R8_Snorm,                        31,  3,  3,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B8G8R8_Uscaled,                      32,  3,  3,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(B8G8R8_Sscaled,                      33,  3,  3,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(B8G8R8_Uint,                         34,  3,  3,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(B8G8R8_Sint,                         35,  3,  3,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(B8G8R8_SRGB,                         36,  3,  3,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8G8B8A8_Unorm,                      37,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8G8B8A8_Snorm,                      38,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8G8B8A8_Uscaled,                    39,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R8G8B8A8_Sscaled,                    40,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R8G8B8A8_Uint,                       41,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R8G8B8A8_Sint,                       42,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R8G8B8A8_SRGB,                       43,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B8G8R8A8_Unorm,                      44,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B8G8R8A8_Snorm,                      45,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B8G8R8A8_Uscaled,                    46,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(B8G8R8A8_Sscaled,                    47,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(B8G8R8A8_Uint,                       48,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(B8G8R8A8_Sint,                       49,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(B8G8R8A8_SRGB,                       50,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(A8B8G8R8_Unorm_Pack32,               51,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(A8B8G8R8_Snorm_Pack32,               52,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(A8B8G8R8_Uscaled_Pack32,             53,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(A8B8G8R8_Sscaled_Pack32,             54,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(A8B8G8R8_Uint_Pack32,                55,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(A8B8G8R8_Sint_Pack32,                56,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(A8B8G8R8_SRGB_Pack32,                57,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(A2R10G10B10_Unorm_Pack32,            58,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(A2R10G10B10_Snorm_Pack32,            59,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(A2R10G10B10_Uscaled_Pack32,          60,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(A2R10G10B10_Sscaled_Pack32,          61,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(A2R10G10B10_Uint_Pack32,             62,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(A2R10G10B10_Sint_Pack32,             63,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(A2B10G10R10_Unorm_Pack32,            64,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(A2B10G10R10_Snorm_Pack32,            65,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(A2B10G10R10_Uscaled_Pack32,          66,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(A2B10G10R10_Sscaled_Pack32,          67,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(A2B10G10R10_Uint_Pack32,             68,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(A2B10G10R10_Sint_Pack32,             69,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R16_Unorm,                           70,  1,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16_Snorm,                           71,  1,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16_Uscaled,                         72,  1,  2,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R16_Sscaled,                         73,  1,  2,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R16_Uint,                            74,  1,  2,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R16_Sint,                            75,  1,  2,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R16_Sfloat,                          76,  1,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16G16_Unorm,                        77,  2,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16G16_Snorm,                        78,  2,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16G16_Uscaled,                      79,  2,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R16G16_Sscaled,                      80,  2,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R16G16_Uint,                         81,  2,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R16G16_Sint,                         82,  2,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R16G16_Sfloat,                       83,  2,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16G16B16_Unorm,                     84,  3,  6,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16G16B16_Snorm,                     85,  3,  6,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16G16B16_Uscaled,                   86,  3,  6,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R16G16B16_Sscaled,                   87,  3,  6,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R16G16B16_Uint,                      88,  3,  6,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R16G16B16_Sint,                      89,  3,  6,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R16G16B16_Sfloat,                    90,  3,  6,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16G16B16A16_Unorm,                  91,  4,  8,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16G16B16A16_Snorm,                  92,  4,  8,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16G16B16A16_Uscaled,                93,  4,  8,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R16G16B16A16_Sscaled,                94,  4,  8,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R16G16B16A16_Uint,                   95,  4,  8,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R16G16B16A16_Sint,                   96,  4,  8,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R16G16B16A16_Sfloat,                 97,  4,  8,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R32_Uint,                            98,  1,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R32_Sint,                            99,  1,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R32_Sfloat,                         100,  1,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R32G32_Uint,                        101,  2,  8,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R32G32_Sint,                        102,  2,  8,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R32G32_Sfloat,                      103,  2,  8,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R32G32B32_Uint,                     104,  3, 12,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R32G32B32_Sint,                     105,  3, 12,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R32G32B32_Sfloat,                   106,  3, 12,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R32G32B32A32_Uint,                  107,  4, 16,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R32G32B32A32_Sint,                  108,  4, 16,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R32G32B32A32_Sfloat,                109,  4, 16,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R64_Uint,                           110,  1,  8,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R64_Sint,                           111,  1,  8,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R64_Sfloat,                         112,  1,  8,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R64G64_Uint,                        113,  2, 16,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R64G64_Sint,                        114,  2, 16,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R64G64_Sfloat,                      115,  2, 16,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R64G64B64_Uint,                     116,  3, 24,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R64G64B64_Sint,                     117,  3, 24,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R64G64B64_Sfloat,                   118,  3, 24,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R64G64B64A64_Uint,                  119,  4, 32,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R64G64B64A64_Sint,                  120,  4, 32,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R64G64B64A64_Sfloat,                121,  4, 32,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B10G11R11_Ufloat_Pack32,            122,  3,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(E5B9G9R9_Ufloat_Pack32,             123,  3,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(D16_Unorm,                          124,  0,  2,  0,  0,  0,  0,        Depth)
+ANKI_FORMAT_DEF(X8_D24_Unorm_Pack32,                125,  0,  4,  0,  0,  0,  0,        Depth)
+ANKI_FORMAT_DEF(D32_Sfloat,                         126,  0,  4,  0,  0,  0,  0,        Depth)
+ANKI_FORMAT_DEF(S8_Uint,                            127,  0,  1,  0,  0,  0,  1,      Stencil)
+ANKI_FORMAT_DEF(D16_Unorm_S8_Uint,                  128,  0,  3,  0,  0,  0,  0, DepthStencil)
+ANKI_FORMAT_DEF(D24_Unorm_S8_Uint,                  129,  0,  4,  0,  0,  0,  0, DepthStencil)
+ANKI_FORMAT_DEF(D32_Sfloat_S8_Uint,                 130,  0,  0,  0,  0,  0,  0, DepthStencil)
+ANKI_FORMAT_DEF(BC1_RGB_Unorm_Block,                131,  3,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(BC1_RGB_SRGB_Block,                 132,  3,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(BC1_RGBA_Unorm_Block,               133,  4,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(BC1_RGBA_SRGB_Block,                134,  4,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(BC2_Unorm_Block,                    135,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(BC2_SRGB_Block,                     136,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(BC3_Unorm_Block,                    137,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(BC3_SRGB_Block,                     138,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(BC4_Unorm_Block,                    139,  1,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(BC4_Snorm_Block,                    140,  1,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(BC5_Unorm_Block,                    141,  2,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(BC5_Snorm_Block,                    142,  2,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(BC6H_Ufloat_Block,                  143,  3,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(BC6H_Sfloat_Block,                  144,  3,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(BC7_Unorm_Block,                    145,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(BC7_SRGB_Block,                     146,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(ETC2_R8G8B8_Unorm_Block,            147,  3,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(ETC2_R8G8B8_SRGB_Block,             148,  3,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(ETC2_R8G8B8A1_Unorm_Block,          149,  4,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(ETC2_R8G8B8A1_SRGB_Block,           150,  4,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(ETC2_R8G8B8A8_Unorm_Block,          151,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(ETC2_R8G8B8A8_SRGB_Block,           152,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(EAC_R11_Unorm_Block,                153,  1,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(EAC_R11_Snorm_Block,                154,  1,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(EAC_R11G11_Unorm_Block,             155,  2,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(EAC_R11G11_Snorm_Block,             156,  2,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_4x4_Unorm_Block,               157,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_4x4_SRGB_Block,                158,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_5x4_Unorm_Block,               159,  4,  0,  5,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_5x4_SRGB_Block,                160,  4,  0,  5,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_5x5_Unorm_Block,               161,  4,  0,  5,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_5x5_SRGB_Block,                162,  4,  0,  5,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_6x5_Unorm_Block,               163,  4,  0,  6,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_6x5_SRGB_Block,                164,  4,  0,  6,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_6x6_Unorm_Block,               165,  4,  0,  6,  6, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_6x6_SRGB_Block,                166,  4,  0,  6,  6, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_8x5_Unorm_Block,               167,  4,  0,  8,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_8x5_SRGB_Block,                168,  4,  0,  8,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_8x6_Unorm_Block,               169,  4,  0,  8,  6, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_8x6_SRGB_Block,                170,  4,  0,  8,  6, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_8x8_Unorm_Block,               171,  4,  0,  8,  8, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_8x8_SRGB_Block,                172,  4,  0,  8,  8, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_10x5_Unorm_Block,              173,  4,  0, 10,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_10x5_SRGB_Block,               174,  4,  0, 10,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_10x6_Unorm_Block,              175,  4,  0, 10,  6, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_10x6_SRGB_Block,               176,  4,  0, 10,  6, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_10x8_Unorm_Block,              177,  4,  0, 10,  8, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_10x8_SRGB_Block,               178,  4,  0, 10,  8, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_10x10_Unorm_Block,             179,  4,  0, 10, 10, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_10x10_SRGB_Block,              180,  4,  0, 10, 10, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_12x10_Unorm_Block,             181,  4,  0, 12, 10, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_12x10_SRGB_Block,              182,  4,  0, 12, 10, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_12x12_Unorm_Block,             183,  4,  0, 12, 12, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_12x12_SRGB_Block,              184,  4,  0, 12, 12, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_4x4_Sfloat_Block,       1000066000,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_5x4_Sfloat_Block,       1000066001,  4,  0,  5,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_5x5_Sfloat_Block,       1000066002,  4,  0,  5,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_6x5_Sfloat_Block,       1000066003,  4,  0,  6,  8, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_6x6_Sfloat_Block,       1000066004,  4,  0,  6,  6, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_8x5_Sfloat_Block,       1000066005,  4,  0,  8,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_8x6_Sfloat_Block,       1000066006,  4,  0,  8,  6, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_8x8_Sfloat_Block,       1000066007,  4,  0,  8,  8, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_10x5_Sfloat_Block,      1000066008,  4,  0, 10,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_10x6_Sfloat_Block,      1000066009,  4,  0, 10,  6, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_10x8_Sfloat_Block,      1000066010,  4,  0, 10,  8, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_10x10_Sfloat_Block,     1000066011,  4,  0, 10, 10, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_12x10_Sfloat_Block,     1000066012,  4,  0, 12, 10, 16,  0,         None)
+ANKI_FORMAT_DEF(ASTC_12x12_Sfloat_Block,     1000066013,  4,  0, 12, 12, 16,  0,         None)
 // clang-format on

AnKi/Gr/Gl/CommandBuffer.cpp

@@ -1395,7 +1395,7 @@ void CommandBuffer::setTextureBarrier(TexturePtr tex, TextureUsageBit prevUsage,
 		e |= GL_SHADER_IMAGE_ACCESS_BARRIER_BIT;
 	}
 
-	if(!!(usage & TextureUsageBit::TRANSFER_DESTINATION))
+	if(!!(usage & TextureUsageBit::kTransferDestination))
 	{
 		e |= GL_TEXTURE_UPDATE_BARRIER_BIT;
 	}
@@ -1411,7 +1411,7 @@ void CommandBuffer::setTextureBarrier(TexturePtr tex, TextureUsageBit prevUsage,
 		// No idea
 	}
 
-	if(!!(usage & TextureUsageBit::GENERATE_MIPMAPS))
+	if(!!(usage & TextureUsageBit::kGenerateMipmaps))
 	{
 		// No idea
 	}

AnKi/Gr/Gl/Common.cpp

@@ -85,34 +85,34 @@ void convertFilter(SamplingFilter minMagFilter, SamplingFilter mipFilter, GLenum
 {
 	switch(minMagFilter)
 	{
-	case SamplingFilter::NEAREST:
+	case SamplingFilter::kNearest:
 		magFilter = GL_NEAREST;
 		switch(mipFilter)
 		{
-		case SamplingFilter::NEAREST:
+		case SamplingFilter::kNearest:
 			minFilter = GL_NEAREST_MIPMAP_NEAREST;
 			break;
-		case SamplingFilter::LINEAR:
+		case SamplingFilter::kLinear:
 			minFilter = GL_NEAREST_MIPMAP_LINEAR;
 			break;
-		case SamplingFilter::BASE:
+		case SamplingFilter::kBase:
 			minFilter = GL_NEAREST;
 			break;
 		default:
 			ANKI_ASSERT(0);
 		}
 		break;
-	case SamplingFilter::LINEAR:
+	case SamplingFilter::kLinear:
 		magFilter = GL_LINEAR;
 		switch(mipFilter)
 		{
-		case SamplingFilter::NEAREST:
+		case SamplingFilter::kNearest:
 			minFilter = GL_LINEAR_MIPMAP_NEAREST;
 			break;
-		case SamplingFilter::LINEAR:
+		case SamplingFilter::kLinear:
 			minFilter = GL_LINEAR_MIPMAP_LINEAR;
 			break;
-		case SamplingFilter::BASE:
+		case SamplingFilter::kBase:
 			minFilter = GL_LINEAR;
 			break;
 		default:
@@ -129,17 +129,17 @@ void convertVertexFormat(Format fmt, U& compCount, GLenum& type, Bool& normalize
 {
 	switch(fmt)
 	{
-	case Format::R32_SFLOAT:
+	case Format::kR32_Sfloat:
 		compCount = 1;
 		type = GL_FLOAT;
 		normalized = false;
 		break;
-	case Format::R32G32_SFLOAT:
+	case Format::kR32G32_Sfloat:
 		compCount = 2;
 		type = GL_FLOAT;
 		normalized = false;
 		break;
-	case Format::R32G32B32_SFLOAT:
+	case Format::kR32G32B32_Sfloat:
 		compCount = 3;
 		type = GL_FLOAT;
 		normalized = false;
@@ -179,7 +179,7 @@ void convertVertexFormat(Format fmt, U& compCount, GLenum& type, Bool& normalize
 		type = GL_INT_2_10_10_10_REV;
 		normalized = true;
 		break;
-	case Format::R8G8B8A8_UNORM:
+	case Format::kR8G8B8A8_Unorm:
 		compCount = 4;
 		type = GL_UNSIGNED_BYTE;
 		normalized = true;
@@ -336,7 +336,7 @@ void convertTextureInformation(Format pf, Bool& compressed, GLenum& format, GLen
 		internalFormat = GL_RGB8I;
 		type = GL_RGB_INTEGER;
 		break;
-	case Format::R8G8B8A8_UNORM:
+	case Format::kR8G8B8A8_Unorm:
 		format = GL_RGBA;
 		internalFormat = GL_RGBA8;
 		type = GL_UNSIGNED_BYTE;
@@ -391,7 +391,7 @@ void convertTextureInformation(Format pf, Bool& compressed, GLenum& format, GLen
 		internalFormat = GL_RGBA16UI;
 		type = GL_UNSIGNED_SHORT;
 		break;
-	case Format::R32_SFLOAT:
+	case Format::kR32_Sfloat:
 		format = GL_R;
 		internalFormat = GL_R32F;
 		type = GL_FLOAT;
@@ -401,17 +401,17 @@ void convertTextureInformation(Format pf, Bool& compressed, GLenum& format, GLen
 		internalFormat = GL_R32UI;
 		type = GL_UNSIGNED_INT;
 		break;
-	case Format::R32G32_SFLOAT:
+	case Format::kR32G32_Sfloat:
 		format = GL_RG;
 		internalFormat = GL_RG32F;
 		type = GL_FLOAT;
 		break;
-	case Format::R32G32_UINT:
+	case Format::kR32G32_Uint:
 		format = GL_RG_INTEGER;
 		internalFormat = GL_RG32UI;
 		type = GL_UNSIGNED_INT;
 		break;
-	case Format::R32G32B32_SFLOAT:
+	case Format::kR32G32B32_Sfloat:
 		format = GL_RGB;
 		internalFormat = GL_RGB32F;
 		type = GL_FLOAT;

AnKi/Gr/Gl/Common.h

@@ -160,7 +160,7 @@ inline GLenum convertPrimitiveTopology(PrimitiveTopology ak)
 	case PrimitiveTopology::LINE_STRIP:
 		out = GL_LINE_STRIP;
 		break;
-	case PrimitiveTopology::TRIANGLES:
+	case PrimitiveTopology::kTriangles:
 		out = GL_TRIANGLES;
 		break;
 	case PrimitiveTopology::TRIANGLE_STRIP:

AnKi/Gr/Gl/FramebufferImpl.cpp

@@ -62,7 +62,7 @@ Error FramebufferImpl::init(const FramebufferInitInfo& init)
 		ANKI_ASSERT(viewImpl.m_tex->isSubresourceGoodForFramebufferAttachment(viewImpl.getSubresource()));
 
 		GLenum binding;
-		if(viewImpl.getSubresource().m_depthStencilAspect == DepthStencilAspectBit::DEPTH)
+		if(viewImpl.getSubresource().m_depthStencilAspect == DepthStencilAspectBit::kDepth)
 		{
 			binding = GL_DEPTH_ATTACHMENT;
 		}
@@ -95,7 +95,7 @@ Error FramebufferImpl::init(const FramebufferInitInfo& init)
 		}
 
 		// Misc
-		m_clearDepth = !!(viewImpl.getSubresource().m_depthStencilAspect & DepthStencilAspectBit::DEPTH)
+		m_clearDepth = !!(viewImpl.getSubresource().m_depthStencilAspect & DepthStencilAspectBit::kDepth)
 					   && att.m_loadOperation == AttachmentLoadOperation::CLEAR;
 
 		m_clearStencil = !!(viewImpl.getSubresource().m_depthStencilAspect & DepthStencilAspectBit::STENCIL)

AnKi/Gr/Gl/GrManagerImpl.cpp

@@ -81,9 +81,9 @@ void GrManagerImpl::initFakeDefaultFb(GrManagerInitInfo& init)
 	TextureInitInfo texinit("FB Tex");
 	texinit.m_width = defaultFbWidth;
 	texinit.m_height = defaultFbHeight;
-	texinit.m_format = Format::R8G8B8A8_UNORM;
+	texinit.m_format = Format::kR8G8B8A8_Unorm;
 	texinit.m_usage =
-		TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE | TextureUsageBit::IMAGE_COMPUTE_WRITE | TextureUsageBit::PRESENT;
+		TextureUsageBit::kFramebufferWrite | TextureUsageBit::kImageComputeWrite | TextureUsageBit::kPresent;
 	m_fakeFbTex = newTexture(texinit);
 
 	TextureViewPtr view = newTextureView(TextureViewInitInfo(m_fakeFbTex, "FB view"));

AnKi/Gr/Gl/SamplerImpl.cpp

@@ -13,13 +13,13 @@ void SamplerImpl::init(const SamplerInitInfo& sinit)
 	glGenSamplers(1, &m_glName);
 	ANKI_ASSERT(m_glName);
 
-	if(sinit.m_addressing == SamplingAddressing::REPEAT)
+	if(sinit.m_addressing == SamplingAddressing::kRepeat)
 	{
 		glSamplerParameteri(m_glName, GL_TEXTURE_WRAP_S, GL_REPEAT);
 		glSamplerParameteri(m_glName, GL_TEXTURE_WRAP_T, GL_REPEAT);
 		glSamplerParameteri(m_glName, GL_TEXTURE_WRAP_R, GL_REPEAT);
 	}
-	else if(sinit.m_addressing == SamplingAddressing::CLAMP)
+	else if(sinit.m_addressing == SamplingAddressing::kClamp)
 	{
 		glSamplerParameteri(m_glName, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 		glSamplerParameteri(m_glName, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

AnKi/Gr/Gl/ShaderProgram.cpp

@@ -56,9 +56,9 @@ ShaderProgram* ShaderProgram::newInstance(GrManager* manager, const ShaderProgra
 
 	CommandBufferPtr cmdb = manager->newCommandBuffer(CommandBufferInitInfo());
 	static_cast<CommandBufferImpl&>(*cmdb).pushBackNewCommand<CreateCommand>(
-		impl, init.m_shaders[ShaderType::VERTEX], init.m_shaders[ShaderType::TESSELLATION_CONTROL],
-		init.m_shaders[ShaderType::TESSELLATION_EVALUATION], init.m_shaders[ShaderType::GEOMETRY],
-		init.m_shaders[ShaderType::FRAGMENT], init.m_shaders[ShaderType::COMPUTE]);
+		impl, init.m_shaders[ShaderType::kVertex], init.m_shaders[ShaderType::kTessellationControl],
+		init.m_shaders[ShaderType::kTessellationEvaluation], init.m_shaders[ShaderType::kGeometry],
+		init.m_shaders[ShaderType::kFragment], init.m_shaders[ShaderType::kCompute]);
 	static_cast<CommandBufferImpl&>(*cmdb).flush();
 
 	return impl;

AnKi/Gr/Gl/ShaderProgramImpl.cpp

@@ -28,28 +28,28 @@ Error ShaderProgramImpl::initGraphics(ShaderPtr vert, ShaderPtr tessc, ShaderPtr
 	ANKI_ASSERT(m_glName != 0);
 
 	glAttachShader(m_glName, static_cast<const ShaderImpl&>(*vert).getGlName());
-	m_shaders[ShaderType::VERTEX] = vert;
+	m_shaders[ShaderType::kVertex] = vert;
 
 	if(tessc)
 	{
 		glAttachShader(m_glName, static_cast<const ShaderImpl&>(*tessc).getGlName());
-		m_shaders[ShaderType::TESSELLATION_CONTROL] = tessc;
+		m_shaders[ShaderType::kTessellationControl] = tessc;
 	}
 
 	if(tesse)
 	{
 		glAttachShader(m_glName, static_cast<const ShaderImpl&>(*tesse).getGlName());
-		m_shaders[ShaderType::TESSELLATION_EVALUATION] = tesse;
+		m_shaders[ShaderType::kTessellationEvaluation] = tesse;
 	}
 
 	if(geom)
 	{
 		glAttachShader(m_glName, static_cast<const ShaderImpl&>(*geom).getGlName());
-		m_shaders[ShaderType::GEOMETRY] = geom;
+		m_shaders[ShaderType::kGeometry] = geom;
 	}
 
 	glAttachShader(m_glName, static_cast<const ShaderImpl&>(*frag).getGlName());
-	m_shaders[ShaderType::FRAGMENT] = frag;
+	m_shaders[ShaderType::kFragment] = frag;
 
 	return link(static_cast<const ShaderImpl&>(*vert).getGlName(), static_cast<const ShaderImpl&>(*frag).getGlName());
 }
@@ -60,7 +60,7 @@ Error ShaderProgramImpl::initCompute(ShaderPtr comp)
 	ANKI_ASSERT(m_glName != 0);
 
 	glAttachShader(m_glName, static_cast<const ShaderImpl&>(*comp).getGlName());
-	m_shaders[ShaderType::COMPUTE] = comp;
+	m_shaders[ShaderType::kCompute] = comp;
 
 	return link(0, 0);
 }

AnKi/Gr/Gl/ShaderProgramImpl.h

@@ -47,7 +47,7 @@ public:
 	const ShaderProgramImplReflection& getReflection();
 
 private:
-	Array<ShaderPtr, U(ShaderType::COUNT)> m_shaders;
+	Array<ShaderPtr, U(ShaderType::kCount)> m_shaders;
 	ShaderProgramImplReflection m_refl;
 	Bool m_reflInitialized = false;
 

AnKi/Gr/Gl/StateTracker.h

@@ -43,7 +43,7 @@ public:
 	{
 	public:
 		U32 m_buffBinding = MAX_U32;
-		Format m_fmt = Format::NONE;
+		Format m_fmt = Format::kNone;
 		PtrSize m_relativeOffset = MAX_PTR_SIZE;
 	};
 

AnKi/Gr/Gl/TextureImpl.cpp

@@ -23,19 +23,19 @@ static GLenum convertTextureType(TextureType type)
 	case TextureType::_1D:
 		out = GL_TEXTURE_1D;
 		break;
-	case TextureType::_2D:
+	case TextureType::k2D:
 		out = GL_TEXTURE_2D;
 		break;
-	case TextureType::_3D:
+	case TextureType::k3D:
 		out = GL_TEXTURE_3D;
 		break;
-	case TextureType::_2D_ARRAY:
+	case TextureType::k2DArray:
 		out = GL_TEXTURE_2D_ARRAY;
 		break;
-	case TextureType::CUBE:
+	case TextureType::kCube:
 		out = GL_TEXTURE_CUBE_MAP;
 		break;
-	case TextureType::CUBE_ARRAY:
+	case TextureType::kCubeArray:
 		out = GL_TEXTURE_CUBE_MAP_ARRAY;
 		break;
 	default:
@@ -304,12 +304,12 @@ void TextureImpl::clear(const TextureSubresourceInfo& subresource, const ClearVa
 {
 	ANKI_ASSERT(isCreated());
 	ANKI_ASSERT(isSubresourceValid(subresource));
-	ANKI_ASSERT(m_texType != TextureType::_3D && "TODO");
+	ANKI_ASSERT(m_texType != TextureType::k3D && "TODO");
 
 	// Find the aspect to clear
 	const DepthStencilAspectBit aspect = subresource.m_depthStencilAspect;
 	GLenum format;
-	if(aspect == DepthStencilAspectBit::DEPTH)
+	if(aspect == DepthStencilAspectBit::kDepth)
 	{
 		ANKI_ASSERT(m_glFormat == GL_DEPTH_COMPONENT || m_glFormat == GL_DEPTH_STENCIL);
 		format = GL_DEPTH_COMPONENT;
@@ -396,7 +396,7 @@ MicroTextureView TextureImpl::getOrCreateView(const TextureSubresourceInfo& subr
 		// Compute the new target if needed
 		const TextureType newTexType = computeNewTexTypeOfSubresource(subresource);
 		GLenum glTarget = m_target;
-		if(newTexType == TextureType::_2D)
+		if(newTexType == TextureType::k2D)
 		{
 			// Change that anyway
 			glTarget = GL_TEXTURE_2D;

AnKi/Gr/Gl/TextureImpl.h

@@ -64,7 +64,7 @@ public:
 	TextureType computeNewTexTypeOfSubresource(const TextureSubresourceInfo& subresource) const
 	{
 		ANKI_ASSERT(isSubresourceValid(subresource));
-		return (textureTypeIsCube(m_texType) && subresource.m_faceCount != 6) ? TextureType::_2D : m_texType;
+		return (textureTypeIsCube(m_texType) && subresource.m_faceCount != 6) ? TextureType::k2D : m_texType;
 	}
 
 private:

AnKi/Gr/GrObject.h

@@ -31,8 +31,8 @@ enum class GrObjectType : U8
 	ACCELERATION_STRUCTURE,
 	GR_UPSCALER,
 
-	COUNT,
-	FIRST = 0
+	kCount,
+	kFirst = 0
 };
 
 /// Base of all graphics objects.

AnKi/Gr/RenderGraph.cpp

@@ -117,7 +117,7 @@ public:
 	CommandBufferInitInfo m_secondLevelCmdbInitInfo;
 	Array<U32, 4> m_fbRenderArea;
 	Array<TextureUsageBit, MAX_COLOR_ATTACHMENTS> m_colorUsages = {}; ///< For beginRender pass
-	TextureUsageBit m_dsUsage = TextureUsageBit::NONE; ///< For beginRender pass
+	TextureUsageBit m_dsUsage = TextureUsageBit::kNone; ///< For beginRender pass
 
 	U32 m_batchIdx ANKI_DEBUG_CODE(= MAX_U32);
 	Bool m_drawsToPresentable = false;
@@ -218,8 +218,8 @@ void FramebufferDescription::bake()
 		ANKI_END_PACKED_STRUCT
 
 		const FramebufferDescriptionAttachment& inAtt = m_depthStencilAttachment;
-		const Bool hasDepth = !!(inAtt.m_aspect & DepthStencilAspectBit::DEPTH);
-		const Bool hasStencil = !!(inAtt.m_aspect & DepthStencilAspectBit::STENCIL);
+		const Bool hasDepth = !!(inAtt.m_aspect & DepthStencilAspectBit::kDepth);
+		const Bool hasStencil = !!(inAtt.m_aspect & DepthStencilAspectBit::kStencil);
 
 		outAtt.m_surf = inAtt.m_surface;
 		outAtt.m_loadOp = (hasDepth) ? static_cast<U32>(inAtt.m_loadOperation) : 0;
@@ -431,7 +431,7 @@ FramebufferPtr RenderGraph::getOrCreateFramebuffer(const FramebufferDescription&
 	{
 		uuids[count++] = m_ctx->m_rts[rtHandles[i].m_idx].m_texture->getUuid();
 
-		if(!!(m_ctx->m_rts[rtHandles[i].m_idx].m_texture->getTextureUsage() & TextureUsageBit::PRESENT))
+		if(!!(m_ctx->m_rts[rtHandles[i].m_idx].m_texture->getTextureUsage() & TextureUsageBit::kPresent))
 		{
 			drawsToPresentable = true;
 		}
@@ -564,7 +564,7 @@ Bool RenderGraph::passADependsOnB(const RenderPassDescriptionBase& a, const Rend
 						continue;
 					}
 
-					if(!((aDep.m_texture.m_usage | bDep.m_texture.m_usage) & TextureUsageBit::ALL_WRITE))
+					if(!((aDep.m_texture.m_usage | bDep.m_texture.m_usage) & TextureUsageBit::kAllWrite))
 					{
 						// Don't care about read to read deps
 						continue;
@@ -712,7 +712,7 @@ RenderGraph::BakeContext* RenderGraph::newContext(const RenderGraphDescription&
 			// Create a new TextureInitInfo with the derived usage
 			TextureInitInfo initInf = inRt.m_initInfo;
 			initInf.m_usage = inRt.m_usageDerivedByDeps;
-			ANKI_ASSERT(initInf.m_usage != TextureUsageBit::NONE && "Probably not referenced by any pass");
+			ANKI_ASSERT(initInf.m_usage != TextureUsageBit::kNone && "Probably not referenced by any pass");
 
 			// Create the new hash
 			const U64 hash = appendHash(&initInf.m_usage, sizeof(initInf.m_usage), inRt.m_hash);
@@ -723,7 +723,7 @@ RenderGraph::BakeContext* RenderGraph::newContext(const RenderGraphDescription&
 
 		// Init the usage
 		const U32 surfOrVolumeCount = getTextureSurfOrVolCount(outRt.m_texture);
-		outRt.m_surfOrVolUsages.create(alloc, surfOrVolumeCount, TextureUsageBit::NONE);
+		outRt.m_surfOrVolUsages.create(alloc, surfOrVolumeCount, TextureUsageBit::kNone);
 		if(imported && inRt.m_importedAndUndefinedUsage)
 		{
 			// Get the usage from previous frames
@@ -1377,7 +1377,7 @@ void RenderGraph::flush()
 void RenderGraph::getCrntUsage(RenderTargetHandle handle, U32 batchIdx, const TextureSubresourceInfo& subresource,
 							   TextureUsageBit& usage) const
 {
-	usage = TextureUsageBit::NONE;
+	usage = TextureUsageBit::kNone;
 	const Batch& batch = m_ctx->m_batches[batchIdx];
 
 	for(U32 passIdx : batch.m_passIndices)

AnKi/Gr/RenderGraph.h

@@ -102,7 +102,7 @@ public:
 	void bake()
 	{
 		ANKI_ASSERT(m_hash == 0);
-		ANKI_ASSERT(m_usage == TextureUsageBit::NONE && "No need to supply the usage. RenderGraph will find out");
+		ANKI_ASSERT(m_usage == TextureUsageBit::kNone && "No need to supply the usage. RenderGraph will find out");
 		m_hash = computeHash();
 	}
 
@@ -194,7 +194,7 @@ public:
 #if ANKI_ENABLE_ASSERTIONS
 		tex = getTexture(handle);
 		ANKI_ASSERT(tex->getLayerCount() == 1 && tex->getMipmapCount() == 1
-					&& tex->getDepthStencilAspect() == DepthStencilAspectBit::NONE);
+					&& tex->getDepthStencilAspect() == DepthStencilAspectBit::kNone);
 #endif
 		const TextureSubresourceInfo subresource;
 		getRenderTargetState(handle, subresource, tex);
@@ -248,7 +248,7 @@ public:
 
 	/// Dependency to the whole texture.
 	RenderPassDependency(RenderTargetHandle handle, TextureUsageBit usage,
-						 DepthStencilAspectBit aspect = DepthStencilAspectBit::NONE)
+						 DepthStencilAspectBit aspect = DepthStencilAspectBit::kNone)
 		: m_texture({handle, usage, TextureSubresourceInfo()})
 		, m_type(Type::TEXTURE)
 	{
@@ -402,7 +402,7 @@ public:
 	AttachmentLoadOperation m_stencilLoadOperation = AttachmentLoadOperation::DONT_CARE;
 	AttachmentStoreOperation m_stencilStoreOperation = AttachmentStoreOperation::STORE;
 
-	DepthStencilAspectBit m_aspect = DepthStencilAspectBit::NONE; ///< Relevant only for depth stencil textures.
+	DepthStencilAspectBit m_aspect = DepthStencilAspectBit::kNone; ///< Relevant only for depth stencil textures.
 };
 
 /// Describes a framebuffer.
@@ -550,9 +550,9 @@ private:
 		TextureInitInfo m_initInfo;
 		U64 m_hash = 0;
 		TexturePtr m_importedTex;
-		TextureUsageBit m_importedLastKnownUsage = TextureUsageBit::NONE;
+		TextureUsageBit m_importedLastKnownUsage = TextureUsageBit::kNone;
 		/// Derived by the deps of this RT and will be used to set its usage.
-		TextureUsageBit m_usageDerivedByDeps = TextureUsageBit::NONE;
+		TextureUsageBit m_usageDerivedByDeps = TextureUsageBit::kNone;
 		Bool m_importedAndUndefinedUsage = false;
 	};
 

AnKi/Gr/RenderGraph.inl.h

@@ -70,14 +70,14 @@ inline void RenderPassDescriptionBase::validateDep(const RenderPassDependency& d
 		[[maybe_unused]] const TextureUsageBit usage = dep.m_texture.m_usage;
 		if(m_type == Type::GRAPHICS)
 		{
-			ANKI_ASSERT(!(usage & TextureUsageBit::ALL_COMPUTE));
+			ANKI_ASSERT(!(usage & TextureUsageBit::kAllCompute));
 		}
 		else
 		{
-			ANKI_ASSERT(!(usage & TextureUsageBit::ALL_GRAPHICS));
+			ANKI_ASSERT(!(usage & TextureUsageBit::kAllGraphics));
 		}
 
-		ANKI_ASSERT(!!(usage & TextureUsageBit::ALL_READ) || !!(usage & TextureUsageBit::ALL_WRITE));
+		ANKI_ASSERT(!!(usage & TextureUsageBit::kAllRead) || !!(usage & TextureUsageBit::kAllWrite));
 	}
 	else if(dep.m_type == RenderPassDependency::Type::BUFFER)
 	{
@@ -116,12 +116,12 @@ inline void RenderPassDescriptionBase::newDependency(const RenderPassDependency&
 		m_rtDeps.emplaceBack(m_alloc, dep);
 		fixSubresource(m_rtDeps.getBack());
 
-		if(!!(dep.m_texture.m_usage & TextureUsageBit::ALL_READ))
+		if(!!(dep.m_texture.m_usage & TextureUsageBit::kAllRead))
 		{
 			m_readRtMask.set(dep.m_texture.m_handle.m_idx);
 		}
 
-		if(!!(dep.m_texture.m_usage & TextureUsageBit::ALL_WRITE))
+		if(!!(dep.m_texture.m_usage & TextureUsageBit::kAllWrite))
 		{
 			m_writeRtMask.set(dep.m_texture.m_handle.m_idx);
 		}
@@ -260,7 +260,7 @@ inline RenderTargetHandle RenderGraphDescription::importRenderTarget(TexturePtr
 	RT& rt = *m_renderTargets.emplaceBack(m_alloc);
 	rt.m_importedTex = tex;
 	rt.m_importedLastKnownUsage = usage;
-	rt.m_usageDerivedByDeps = TextureUsageBit::NONE;
+	rt.m_usageDerivedByDeps = TextureUsageBit::kNone;
 	rt.setName(tex->getName());
 
 	RenderTargetHandle out;
@@ -270,7 +270,7 @@ inline RenderTargetHandle RenderGraphDescription::importRenderTarget(TexturePtr
 
 inline RenderTargetHandle RenderGraphDescription::importRenderTarget(TexturePtr tex)
 {
-	RenderTargetHandle out = importRenderTarget(tex, TextureUsageBit::NONE);
+	RenderTargetHandle out = importRenderTarget(tex, TextureUsageBit::kNone);
 	m_renderTargets.getBack().m_importedAndUndefinedUsage = true;
 	return out;
 }
@@ -278,12 +278,13 @@ inline RenderTargetHandle RenderGraphDescription::importRenderTarget(TexturePtr
 inline RenderTargetHandle RenderGraphDescription::newRenderTarget(const RenderTargetDescription& initInf)
 {
 	ANKI_ASSERT(initInf.m_hash && "Forgot to call RenderTargetDescription::bake");
-	ANKI_ASSERT(initInf.m_usage == TextureUsageBit::NONE && "Don't need to supply the usage. Render grap will find it");
+	ANKI_ASSERT(initInf.m_usage == TextureUsageBit::kNone
+				&& "Don't need to supply the usage. Render grap will find it");
 	RT& rt = *m_renderTargets.emplaceBack(m_alloc);
 	rt.m_initInfo = initInf;
 	rt.m_hash = initInf.m_hash;
-	rt.m_importedLastKnownUsage = TextureUsageBit::NONE;
-	rt.m_usageDerivedByDeps = TextureUsageBit::NONE;
+	rt.m_importedLastKnownUsage = TextureUsageBit::kNone;
+	rt.m_usageDerivedByDeps = TextureUsageBit::kNone;
 	rt.setName(initInf.getName());
 
 	RenderTargetHandle out;

AnKi/Gr/Sampler.h

@@ -19,11 +19,11 @@ public:
 	F32 m_minLod = -1000.0f;
 	F32 m_maxLod = 1000.0f;
 	F32 m_lodBias = 0.0f;
-	SamplingFilter m_minMagFilter = SamplingFilter::NEAREST;
-	SamplingFilter m_mipmapFilter = SamplingFilter::BASE;
-	CompareOperation m_compareOperation = CompareOperation::ALWAYS;
+	SamplingFilter m_minMagFilter = SamplingFilter::kNearest;
+	SamplingFilter m_mipmapFilter = SamplingFilter::kBase;
+	CompareOperation m_compareOperation = CompareOperation::kAlways;
 	U8 m_anisotropyLevel = 0;
-	SamplingAddressing m_addressing = SamplingAddressing::REPEAT;
+	SamplingAddressing m_addressing = SamplingAddressing::kRepeat;
 	U8 _m_padding[3] = {0, 0, 0};
 
 	SamplerInitInfo() = default;

AnKi/Gr/Shader.h

@@ -60,7 +60,7 @@ public:
 class ShaderInitInfo : public GrBaseInitInfo
 {
 public:
-	ShaderType m_shaderType = ShaderType::COUNT;
+	ShaderType m_shaderType = ShaderType::kCount;
 	ConstWeakArray<U8> m_binary = {};
 
 	/// @note It's OK to have entries in that array with consts that do not appear in the shader.
@@ -93,12 +93,12 @@ public:
 
 	ShaderType getShaderType() const
 	{
-		ANKI_ASSERT(m_shaderType != ShaderType::COUNT);
+		ANKI_ASSERT(m_shaderType != ShaderType::kCount);
 		return m_shaderType;
 	}
 
 protected:
-	ShaderType m_shaderType = ShaderType::COUNT;
+	ShaderType m_shaderType = ShaderType::kCount;
 
 	/// Construct.
 	Shader(GrManager* manager, CString name)

AnKi/Gr/ShaderProgram.cpp

@@ -9,8 +9,8 @@ namespace anki {
 
 Bool ShaderProgramInitInfo::isValid() const
 {
-	ShaderTypeBit graphicsMask = ShaderTypeBit::NONE;
-	for(ShaderType i = ShaderType::FIRST_GRAPHICS; i <= ShaderType::LAST_GRAPHICS; ++i)
+	ShaderTypeBit graphicsMask = ShaderTypeBit::kNone;
+	for(ShaderType i = ShaderType::kFirstGraphics; i <= ShaderType::kLastGraphics; ++i)
 	{
 		if(m_graphicsShaders[i])
 		{
@@ -23,8 +23,8 @@ Bool ShaderProgramInitInfo::isValid() const
 	}
 
 	if(!!graphicsMask
-	   && (graphicsMask & (ShaderTypeBit::VERTEX | ShaderTypeBit::FRAGMENT))
-			  != (ShaderTypeBit::VERTEX | ShaderTypeBit::FRAGMENT))
+	   && (graphicsMask & (ShaderTypeBit::kVertex | ShaderTypeBit::kFragment))
+			  != (ShaderTypeBit::kVertex | ShaderTypeBit::kFragment))
 	{
 		return false;
 	}
@@ -32,7 +32,7 @@ Bool ShaderProgramInitInfo::isValid() const
 	Bool compute = false;
 	if(m_computeShader)
 	{
-		if(m_computeShader->getShaderType() != ShaderType::COMPUTE)
+		if(m_computeShader->getShaderType() != ShaderType::kCompute)
 		{
 			return false;
 		}
@@ -44,44 +44,44 @@ Bool ShaderProgramInitInfo::isValid() const
 		return false;
 	}
 
-	ShaderTypeBit rtMask = ShaderTypeBit::NONE;
+	ShaderTypeBit rtMask = ShaderTypeBit::kNone;
 	for(const ShaderPtr& s : m_rayTracingShaders.m_rayGenShaders)
 	{
-		if(s->getShaderType() != ShaderType::RAY_GEN)
+		if(s->getShaderType() != ShaderType::kRayGen)
 		{
 			return false;
 		}
-		rtMask |= ShaderTypeBit::RAY_GEN;
+		rtMask |= ShaderTypeBit::kRayGen;
 	}
 
 	for(const ShaderPtr& s : m_rayTracingShaders.m_missShaders)
 	{
-		if(s->getShaderType() != ShaderType::MISS)
+		if(s->getShaderType() != ShaderType::kMiss)
 		{
 			return false;
 		}
-		rtMask |= ShaderTypeBit::MISS;
+		rtMask |= ShaderTypeBit::kMiss;
 	}
 
 	for(const RayTracingHitGroup& group : m_rayTracingShaders.m_hitGroups)
 	{
-		ShaderTypeBit localRtMask = ShaderTypeBit::NONE;
+		ShaderTypeBit localRtMask = ShaderTypeBit::kNone;
 		if(group.m_anyHitShader)
 		{
-			if(group.m_anyHitShader->getShaderType() != ShaderType::ANY_HIT)
+			if(group.m_anyHitShader->getShaderType() != ShaderType::kAnyHit)
 			{
 				return false;
 			}
-			localRtMask |= ShaderTypeBit::ANY_HIT;
+			localRtMask |= ShaderTypeBit::kAnyHit;
 		}
 
 		if(group.m_closestHitShader)
 		{
-			if(group.m_closestHitShader->getShaderType() != ShaderType::CLOSEST_HIT)
+			if(group.m_closestHitShader->getShaderType() != ShaderType::kClosestHit)
 			{
 				return false;
 			}
-			localRtMask |= ShaderTypeBit::CLOSEST_HIT;
+			localRtMask |= ShaderTypeBit::kClosestHit;
 		}
 
 		if(!localRtMask)

AnKi/Gr/ShaderProgram.h

@@ -36,7 +36,7 @@ class ShaderProgramInitInfo : public GrBaseInitInfo
 {
 public:
 	/// Option 1
-	Array<ShaderPtr, U32(ShaderType::LAST_GRAPHICS + 1)> m_graphicsShaders;
+	Array<ShaderPtr, U32(ShaderType::kLastGraphics + 1)> m_graphicsShaders;
 
 	/// Option 2
 	ShaderPtr m_computeShader;

AnKi/Gr/Texture.h

@@ -21,10 +21,10 @@ public:
 	U32 m_depth = 1; //< Relevant only for 3D textures.
 	U32 m_layerCount = 1; ///< Relevant only for texture arrays.
 
-	Format m_format = Format::NONE;
+	Format m_format = Format::kNone;
 
-	TextureUsageBit m_usage = TextureUsageBit::NONE; ///< How the texture will be used.
-	TextureType m_type = TextureType::_2D;
+	TextureUsageBit m_usage = TextureUsageBit::kNone; ///< How the texture will be used.
+	TextureType m_type = TextureType::k2D;
 
 	U8 m_mipmapCount = 1;
 
@@ -61,27 +61,27 @@ public:
 		} \
 	} while(0)
 
-		ANKI_CHECK_VAL_VALIDITY(m_format != Format::NONE);
-		ANKI_CHECK_VAL_VALIDITY(m_usage != TextureUsageBit::NONE);
+		ANKI_CHECK_VAL_VALIDITY(m_format != Format::kNone);
+		ANKI_CHECK_VAL_VALIDITY(m_usage != TextureUsageBit::kNone);
 		ANKI_CHECK_VAL_VALIDITY(m_mipmapCount > 0);
 		ANKI_CHECK_VAL_VALIDITY(m_width > 0);
 		ANKI_CHECK_VAL_VALIDITY(m_height > 0);
 		switch(m_type)
 		{
-		case TextureType::_2D:
+		case TextureType::k2D:
 			ANKI_CHECK_VAL_VALIDITY(m_depth == 1);
 			ANKI_CHECK_VAL_VALIDITY(m_layerCount == 1);
 			break;
-		case TextureType::CUBE:
+		case TextureType::kCube:
 			ANKI_CHECK_VAL_VALIDITY(m_depth == 1);
 			ANKI_CHECK_VAL_VALIDITY(m_layerCount == 1);
 			break;
-		case TextureType::_3D:
+		case TextureType::k3D:
 			ANKI_CHECK_VAL_VALIDITY(m_depth > 0);
 			ANKI_CHECK_VAL_VALIDITY(m_layerCount == 1);
 			break;
-		case TextureType::_2D_ARRAY:
-		case TextureType::CUBE_ARRAY:
+		case TextureType::k2DArray:
+		case TextureType::kCubeArray:
 			ANKI_CHECK_VAL_VALIDITY(m_depth == 1);
 			ANKI_CHECK_VAL_VALIDITY(m_layerCount > 0);
 			break;
@@ -134,7 +134,7 @@ public:
 
 	TextureType getTextureType() const
 	{
-		ANKI_ASSERT(m_texType != TextureType::COUNT);
+		ANKI_ASSERT(m_texType != TextureType::kCount);
 		return m_texType;
 	}
 
@@ -146,7 +146,7 @@ public:
 
 	Format getFormat() const
 	{
-		ANKI_ASSERT(m_format != Format::NONE);
+		ANKI_ASSERT(m_format != Format::kNone);
 		return m_format;
 	}
 
@@ -182,7 +182,7 @@ public:
 		ANKI_TEX_SUBRESOURCE_ASSERT((m_aspect & subresource.m_depthStencilAspect) == subresource.m_depthStencilAspect);
 
 		// Misc
-		if(type == TextureType::CUBE_ARRAY && subresource.m_layerCount > 1)
+		if(type == TextureType::kCubeArray && subresource.m_layerCount > 1)
 		{
 			// Because of the way surfaces are arranged in cube arrays
 			ANKI_TEX_SUBRESOURCE_ASSERT(subresource.m_faceCount == 6);
@@ -196,7 +196,7 @@ public:
 	Bool isSubresourceGoodForMipmapGeneration(const TextureSubresourceInfo& subresource) const
 	{
 		ANKI_ASSERT(isSubresourceValid(subresource));
-		if(m_texType != TextureType::_3D)
+		if(m_texType != TextureType::k3D)
 		{
 			return subresource.m_firstMipmap == 0 && subresource.m_mipmapCount == m_mipCount
 				   && subresource.m_faceCount == 1 && subresource.m_layerCount == 1
@@ -222,9 +222,9 @@ public:
 	{
 		ANKI_ASSERT(isSubresourceValid(subresource));
 		/// Can bound only one aspect at a time.
-		return subresource.m_depthStencilAspect == DepthStencilAspectBit::DEPTH
-			   || subresource.m_depthStencilAspect == DepthStencilAspectBit::STENCIL
-			   || subresource.m_depthStencilAspect == DepthStencilAspectBit::NONE;
+		return subresource.m_depthStencilAspect == DepthStencilAspectBit::kDepth
+			   || subresource.m_depthStencilAspect == DepthStencilAspectBit::kStencil
+			   || subresource.m_depthStencilAspect == DepthStencilAspectBit::kNone;
 	}
 
 	/// Return true if the subresource can be used in CommandBuffer::copyBufferToTextureView.
@@ -232,7 +232,7 @@ public:
 	{
 		ANKI_ASSERT(isSubresourceValid(subresource));
 		return subresource.m_faceCount == 1 && subresource.m_mipmapCount == 1 && subresource.m_layerCount == 1
-			   && subresource.m_depthStencilAspect == DepthStencilAspectBit::NONE;
+			   && subresource.m_depthStencilAspect == DepthStencilAspectBit::kNone;
 	}
 
 	/// Return true if the subresource can be used as Framebuffer attachment.
@@ -248,10 +248,10 @@ protected:
 	U32 m_depth = 0;
 	U32 m_layerCount = 0;
 	U32 m_mipCount = 0;
-	TextureType m_texType = TextureType::COUNT;
-	TextureUsageBit m_usage = TextureUsageBit::NONE;
-	Format m_format = Format::NONE;
-	DepthStencilAspectBit m_aspect = DepthStencilAspectBit::NONE;
+	TextureType m_texType = TextureType::kCount;
+	TextureUsageBit m_usage = TextureUsageBit::kNone;
+	Format m_format = Format::kNone;
+	DepthStencilAspectBit m_aspect = DepthStencilAspectBit::kNone;
 
 	/// Construct.
 	Texture(GrManager* manager, CString name)

AnKi/Gr/TextureView.h

@@ -29,7 +29,7 @@ public:
 		m_layerCount = tex->getLayerCount();
 		m_firstFace = 0;
 		m_faceCount =
-			(tex->getTextureType() == TextureType::CUBE_ARRAY || tex->getTextureType() == TextureType::CUBE) ? 6 : 1;
+			(tex->getTextureType() == TextureType::kCubeArray || tex->getTextureType() == TextureType::kCube) ? 6 : 1;
 
 		m_depthStencilAspect = getFormatInfo(tex->getFormat()).m_depthStencil;
 	}
@@ -40,7 +40,7 @@ public:
 	}
 
 	TextureViewInitInfo(TexturePtr tex, const TextureSurfaceInfo& surf,
-						DepthStencilAspectBit aspect = DepthStencilAspectBit::NONE, CString name = {})
+						DepthStencilAspectBit aspect = DepthStencilAspectBit::kNone, CString name = {})
 		: GrBaseInitInfo(name)
 		, m_texture(tex)
 	{
@@ -93,14 +93,14 @@ public:
 	U32 getOrCreateBindlessTextureIndex();
 
 protected:
-	TextureType m_texType = TextureType::COUNT;
+	TextureType m_texType = TextureType::kCount;
 	TextureSubresourceInfo m_subresource;
 
 	/// Construct.
 	TextureView(GrManager* manager, CString name)
 		: GrObject(manager, CLASS_TYPE, name)
 	{
-		m_subresource.m_depthStencilAspect = DepthStencilAspectBit::NONE;
+		m_subresource.m_depthStencilAspect = DepthStencilAspectBit::kNone;
 
 		m_subresource.m_firstMipmap = MAX_U32;
 		m_subresource.m_mipmapCount = MAX_U32;
@@ -119,7 +119,7 @@ protected:
 
 	Bool initialized() const
 	{
-		return m_texType != TextureType::COUNT && m_subresource.m_firstMipmap < MAX_U32
+		return m_texType != TextureType::kCount && m_subresource.m_firstMipmap < MAX_U32
 			   && m_subresource.m_mipmapCount < MAX_U32 && m_subresource.m_firstLayer < MAX_U32
 			   && m_subresource.m_layerCount < MAX_U32 && m_subresource.m_firstFace < MAX_U8
 			   && m_subresource.m_faceCount < MAX_U8;

AnKi/Gr/Utils/Functions.h

@@ -13,17 +13,17 @@ namespace anki {
 inline Bool stencilTestDisabled(StencilOperation stencilFail, StencilOperation stencilPassDepthFail,
 								StencilOperation stencilPassDepthPass, CompareOperation compare)
 {
-	return stencilFail == StencilOperation::KEEP && stencilPassDepthFail == StencilOperation::KEEP
-		   && stencilPassDepthPass == StencilOperation::KEEP && compare == CompareOperation::ALWAYS;
+	return stencilFail == StencilOperation::kKeep && stencilPassDepthFail == StencilOperation::kKeep
+		   && stencilPassDepthPass == StencilOperation::kKeep && compare == CompareOperation::kAlways;
 }
 
 inline Bool blendingDisabled(BlendFactor srcFactorRgb, BlendFactor dstFactorRgb, BlendFactor srcFactorA,
 							 BlendFactor dstFactorA, BlendOperation opRgb, BlendOperation opA)
 {
-	Bool dontWantBlend = srcFactorRgb == BlendFactor::ONE && dstFactorRgb == BlendFactor::ZERO
-						 && srcFactorA == BlendFactor::ONE && dstFactorA == BlendFactor::ZERO
-						 && (opRgb == BlendOperation::ADD || opRgb == BlendOperation::SUBTRACT)
-						 && (opA == BlendOperation::ADD || opA == BlendOperation::SUBTRACT);
+	Bool dontWantBlend = srcFactorRgb == BlendFactor::kOne && dstFactorRgb == BlendFactor::kZero
+						 && srcFactorA == BlendFactor::kOne && dstFactorA == BlendFactor::kZero
+						 && (opRgb == BlendOperation::kAdd || opRgb == BlendOperation::kSubtract)
+						 && (opA == BlendOperation::kAdd || opA == BlendOperation::kSubtract);
 	return dontWantBlend;
 }
 

AnKi/Gr/Vulkan/CommandBufferFactory.h

@@ -98,7 +98,7 @@ public:
 
 	VulkanQueueType getVulkanQueueType() const
 	{
-		ANKI_ASSERT(m_queue != VulkanQueueType::COUNT);
+		ANKI_ASSERT(m_queue != VulkanQueueType::kCount);
 		return m_queue;
 	}
 
@@ -109,14 +109,14 @@ private:
 	VkCommandBuffer m_handle = {};
 
 	MicroFencePtr m_fence;
-	Array<DynamicArray<GrObjectPtr>, U(GrObjectType::COUNT)> m_objectRefs;
+	Array<DynamicArray<GrObjectPtr>, U(GrObjectType::kCount)> m_objectRefs;
 
 	// Cacheline boundary
 
 	CommandBufferThreadAllocator* m_threadAlloc;
 	mutable Atomic<I32> m_refcount = {0};
 	CommandBufferFlag m_flags = CommandBufferFlag::NONE;
-	VulkanQueueType m_queue = VulkanQueueType::COUNT;
+	VulkanQueueType m_queue = VulkanQueueType::kCount;
 
 	void reset();
 
@@ -190,13 +190,13 @@ public:
 private:
 	CommandBufferFactory* m_factory;
 	ThreadId m_tid;
-	Array<VkCommandPool, U(VulkanQueueType::COUNT)> m_pools = {};
+	Array<VkCommandPool, U(VulkanQueueType::kCount)> m_pools = {};
 
 #if ANKI_EXTRA_CHECKS
 	Atomic<U32> m_createdCmdbs = {0};
 #endif
 
-	Array3d<MicroObjectRecycler<MicroCommandBuffer>, 2, 2, U(VulkanQueueType::COUNT)> m_recyclers;
+	Array3d<MicroObjectRecycler<MicroCommandBuffer>, 2, 2, U(VulkanQueueType::kCount)> m_recyclers;
 };
 
 /// Command bufffer object recycler.

AnKi/Gr/Vulkan/CommandBufferImpl.cpp

@@ -318,7 +318,7 @@ void CommandBufferImpl::generateMipmaps2dInternal(const TextureViewPtr& texView)
 
 	const TextureViewImpl& view = static_cast<const TextureViewImpl&>(*texView);
 	const TextureImpl& tex = view.getTextureImpl();
-	ANKI_ASSERT(tex.getTextureType() != TextureType::_3D && "Not for 3D");
+	ANKI_ASSERT(tex.getTextureType() != TextureType::k3D && "Not for 3D");
 	ANKI_ASSERT(tex.isSubresourceGoodForMipmapGeneration(view.getSubresource()));
 
 	const U32 blitCount = tex.getMipmapCount() - 1u;
@@ -371,13 +371,13 @@ void CommandBufferImpl::generateMipmaps2dInternal(const TextureViewPtr& texView)
 		U32 vkLayer = 0;
 		switch(tex.getTextureType())
 		{
-		case TextureType::_2D:
-		case TextureType::_2D_ARRAY:
+		case TextureType::k2D:
+		case TextureType::k2DArray:
 			break;
-		case TextureType::CUBE:
+		case TextureType::kCube:
 			vkLayer = face;
 			break;
-		case TextureType::CUBE_ARRAY:
+		case TextureType::kCubeArray:
 			vkLayer = layer * 6 + face;
 			break;
 		default:
@@ -664,10 +664,10 @@ void CommandBufferImpl::copyBufferToTextureViewInternal(const BufferPtr& buff, P
 
 	const TextureViewImpl& view = static_cast<const TextureViewImpl&>(*texView);
 	const TextureImpl& tex = view.getTextureImpl();
-	ANKI_ASSERT(tex.usageValid(TextureUsageBit::TRANSFER_DESTINATION));
+	ANKI_ASSERT(tex.usageValid(TextureUsageBit::kTransferDestination));
 	ANKI_ASSERT(tex.isSubresourceGoodForCopyFromBuffer(view.getSubresource()));
 	const VkImageLayout layout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
-	const Bool is3D = tex.getTextureType() == TextureType::_3D;
+	const Bool is3D = tex.getTextureType() == TextureType::k3D;
 	const VkImageAspectFlags aspect = convertImageAspect(view.getSubresource().m_depthStencilAspect);
 
 	const TextureSurfaceInfo surf(view.getSubresource().m_firstMipmap, view.getSubresource().m_firstFace, 0,
@@ -910,18 +910,18 @@ void CommandBufferImpl::setPipelineBarrierInternal(
 
 		ANKI_ASSERT(impl.usageValid(prevUsage));
 		ANKI_ASSERT(impl.usageValid(nextUsage));
-		ANKI_ASSERT(((nextUsage & TextureUsageBit::GENERATE_MIPMAPS) == TextureUsageBit::GENERATE_MIPMAPS
-					 || (nextUsage & TextureUsageBit::GENERATE_MIPMAPS) == TextureUsageBit::NONE)
+		ANKI_ASSERT(((nextUsage & TextureUsageBit::kGenerateMipmaps) == TextureUsageBit::kGenerateMipmaps
+					 || (nextUsage & TextureUsageBit::kGenerateMipmaps) == TextureUsageBit::kNone)
 					&& "GENERATE_MIPMAPS should be alone");
 		ANKI_ASSERT(impl.isSubresourceValid(subresource));
 
-		if(ANKI_UNLIKELY(subresource.m_firstMipmap > 0 && nextUsage == TextureUsageBit::GENERATE_MIPMAPS))
+		if(ANKI_UNLIKELY(subresource.m_firstMipmap > 0 && nextUsage == TextureUsageBit::kGenerateMipmaps))
 		{
 			// This transition happens inside CommandBufferImpl::generateMipmapsX. No need to do something
 			continue;
 		}
 
-		if(ANKI_UNLIKELY(nextUsage == TextureUsageBit::GENERATE_MIPMAPS))
+		if(ANKI_UNLIKELY(nextUsage == TextureUsageBit::kGenerateMipmaps))
 		{
 			// The transition of the non zero mip levels happens inside CommandBufferImpl::generateMipmapsX so limit the
 			// subresource

AnKi/Gr/Vulkan/CommandBufferImpl.h

@@ -235,7 +235,7 @@ public:
 		const TextureViewImpl& view = static_cast<const TextureViewImpl&>(*texView);
 		const TextureImpl& tex = view.getTextureImpl();
 		ANKI_ASSERT(tex.isSubresourceGoodForSampling(view.getSubresource()));
-		const VkImageLayout lay = tex.computeLayout(TextureUsageBit::ALL_SAMPLED & tex.getTextureUsage(), 0);
+		const VkImageLayout lay = tex.computeLayout(TextureUsageBit::kAllSampled & tex.getTextureUsage(), 0);
 
 		m_dsetState[set].bindTextureAndSampler(binding, arrayIdx, &view, sampler.get(), lay);
 
@@ -249,7 +249,7 @@ public:
 		const TextureViewImpl& view = static_cast<const TextureViewImpl&>(*texView);
 		const TextureImpl& tex = view.getTextureImpl();
 		ANKI_ASSERT(tex.isSubresourceGoodForSampling(view.getSubresource()));
-		const VkImageLayout lay = tex.computeLayout(TextureUsageBit::ALL_SAMPLED & tex.getTextureUsage(), 0);
+		const VkImageLayout lay = tex.computeLayout(TextureUsageBit::kAllSampled & tex.getTextureUsage(), 0);
 
 		m_dsetState[set].bindTexture(binding, arrayIdx, &view, lay);
 
@@ -268,8 +268,8 @@ public:
 		commandCommon();
 		m_dsetState[set].bindImage(binding, arrayIdx, img.get());
 
-		const Bool isPresentable =
-			!!(static_cast<const TextureViewImpl&>(*img).getTextureImpl().getTextureUsage() & TextureUsageBit::PRESENT);
+		const Bool isPresentable = !!(static_cast<const TextureViewImpl&>(*img).getTextureImpl().getTextureUsage()
+									  & TextureUsageBit::kPresent);
 		if(isPresentable)
 		{
 			m_renderedToDefaultFb = true;
@@ -435,7 +435,7 @@ private:
 	Array<U32, 2> m_fbSize = {0, 0};
 	U32 m_rpCommandCount = 0; ///< Number of drawcalls or pushed cmdbs in rp.
 	Array<TextureUsageBit, MAX_COLOR_ATTACHMENTS> m_colorAttachmentUsages = {};
-	TextureUsageBit m_depthStencilAttachmentUsage = TextureUsageBit::NONE;
+	TextureUsageBit m_depthStencilAttachmentUsage = TextureUsageBit::kNone;
 
 	PipelineStateTracker m_state;
 

AnKi/Gr/Vulkan/CommandBufferImpl.inl.h

@@ -19,13 +19,13 @@ inline void CommandBufferImpl::setStencilCompareMaskInternal(FaceSelectionBit fa
 
 	VkStencilFaceFlags flags = 0;
 
-	if(!!(face & FaceSelectionBit::FRONT) && m_stencilCompareMasks[0] != mask)
+	if(!!(face & FaceSelectionBit::kFront) && m_stencilCompareMasks[0] != mask)
 	{
 		m_stencilCompareMasks[0] = mask;
 		flags = VK_STENCIL_FACE_FRONT_BIT;
 	}
 
-	if(!!(face & FaceSelectionBit::BACK) && m_stencilCompareMasks[1] != mask)
+	if(!!(face & FaceSelectionBit::kBack) && m_stencilCompareMasks[1] != mask)
 	{
 		m_stencilCompareMasks[1] = mask;
 		flags |= VK_STENCIL_FACE_BACK_BIT;
@@ -43,13 +43,13 @@ inline void CommandBufferImpl::setStencilWriteMaskInternal(FaceSelectionBit face
 
 	VkStencilFaceFlags flags = 0;
 
-	if(!!(face & FaceSelectionBit::FRONT) && m_stencilWriteMasks[0] != mask)
+	if(!!(face & FaceSelectionBit::kFront) && m_stencilWriteMasks[0] != mask)
 	{
 		m_stencilWriteMasks[0] = mask;
 		flags = VK_STENCIL_FACE_FRONT_BIT;
 	}
 
-	if(!!(face & FaceSelectionBit::BACK) && m_stencilWriteMasks[1] != mask)
+	if(!!(face & FaceSelectionBit::kBack) && m_stencilWriteMasks[1] != mask)
 	{
 		m_stencilWriteMasks[1] = mask;
 		flags |= VK_STENCIL_FACE_BACK_BIT;
@@ -67,13 +67,13 @@ inline void CommandBufferImpl::setStencilReferenceInternal(FaceSelectionBit face
 
 	VkStencilFaceFlags flags = 0;
 
-	if(!!(face & FaceSelectionBit::FRONT) && m_stencilReferenceMasks[0] != ref)
+	if(!!(face & FaceSelectionBit::kFront) && m_stencilReferenceMasks[0] != ref)
 	{
 		m_stencilReferenceMasks[0] = ref;
 		flags = VK_STENCIL_FACE_FRONT_BIT;
 	}
 
-	if(!!(face & FaceSelectionBit::BACK) && m_stencilReferenceMasks[1] != ref)
+	if(!!(face & FaceSelectionBit::kBack) && m_stencilReferenceMasks[1] != ref)
 	{
 		m_stencilWriteMasks[1] = ref;
 		flags |= VK_STENCIL_FACE_BACK_BIT;
@@ -129,8 +129,8 @@ inline void CommandBufferImpl::setTextureBarrierRangeInternal(const TexturePtr&
 	const TextureImpl& impl = static_cast<const TextureImpl&>(*tex);
 	ANKI_ASSERT(impl.usageValid(prevUsage));
 	ANKI_ASSERT(impl.usageValid(nextUsage));
-	ANKI_ASSERT(((nextUsage & TextureUsageBit::GENERATE_MIPMAPS) == TextureUsageBit::GENERATE_MIPMAPS
-				 || (nextUsage & TextureUsageBit::GENERATE_MIPMAPS) == TextureUsageBit::NONE)
+	ANKI_ASSERT(((nextUsage & TextureUsageBit::kGenerateMipmaps) == TextureUsageBit::kGenerateMipmaps
+				 || (nextUsage & TextureUsageBit::kGenerateMipmaps) == TextureUsageBit::kNone)
 				&& "GENERATE_MIPMAPS should be alone");
 
 	VkPipelineStageFlags srcStage;
@@ -157,7 +157,7 @@ inline void CommandBufferImpl::setTextureBarrierInternal(const TexturePtr& tex,
 
 	// The transition of the non zero mip levels happens inside CommandBufferImpl::generateMipmapsX so limit the
 	// subresource
-	if(nextUsage == TextureUsageBit::GENERATE_MIPMAPS)
+	if(nextUsage == TextureUsageBit::kGenerateMipmaps)
 	{
 		ANKI_ASSERT(impl.isSubresourceGoodForMipmapGeneration(subresource));
 
@@ -176,7 +176,7 @@ inline void CommandBufferImpl::setTextureSurfaceBarrierInternal(const TexturePtr
 																TextureUsageBit nextUsage,
 																const TextureSurfaceInfo& surf)
 {
-	if(ANKI_UNLIKELY(surf.m_level > 0 && nextUsage == TextureUsageBit::GENERATE_MIPMAPS))
+	if(ANKI_UNLIKELY(surf.m_level > 0 && nextUsage == TextureUsageBit::kGenerateMipmaps))
 	{
 		// This transition happens inside CommandBufferImpl::generateMipmapsX. No need to do something
 		return;
@@ -194,7 +194,7 @@ inline void CommandBufferImpl::setTextureVolumeBarrierInternal(const TexturePtr&
 {
 	if(vol.m_level > 0)
 	{
-		ANKI_ASSERT(!(nextUsage & TextureUsageBit::GENERATE_MIPMAPS)
+		ANKI_ASSERT(!(nextUsage & TextureUsageBit::kGenerateMipmaps)
 					&& "This transition happens inside CommandBufferImpl::generateMipmaps");
 	}
 
@@ -733,8 +733,8 @@ inline void CommandBufferImpl::drawcallCommon()
 
 	// Some checks
 #if ANKI_ENABLE_ASSERTIONS
-	if(m_state.getPrimitiveTopology() == PrimitiveTopology::LINES
-	   || m_state.getPrimitiveTopology() == PrimitiveTopology::LINE_STRIP)
+	if(m_state.getPrimitiveTopology() == PrimitiveTopology::kLines
+	   || m_state.getPrimitiveTopology() == PrimitiveTopology::kLineStip)
 	{
 		ANKI_ASSERT(m_lineWidthSet == true);
 	}
@@ -861,7 +861,7 @@ inline void CommandBufferImpl::bindShaderProgramInternal(const ShaderProgramPtr&
 		m_rtProg = nullptr; // See above
 		m_state.bindShaderProgram(&impl);
 	}
-	else if(!!(impl.getStages() & ShaderTypeBit::COMPUTE))
+	else if(!!(impl.getStages() & ShaderTypeBit::kCompute))
 	{
 		m_computeProg = &impl;
 		m_graphicsProg = nullptr; // See comment in the if()
@@ -873,7 +873,7 @@ inline void CommandBufferImpl::bindShaderProgramInternal(const ShaderProgramPtr&
 	}
 	else
 	{
-		ANKI_ASSERT(!!(impl.getStages() & ShaderTypeBit::ALL_RAY_TRACING));
+		ANKI_ASSERT(!!(impl.getStages() & ShaderTypeBit::kAllRayTracing));
 		m_computeProg = nullptr;
 		m_graphicsProg = nullptr;
 		m_rtProg = &impl;

AnKi/Gr/Vulkan/Common.cpp

@@ -15,28 +15,28 @@ VkCompareOp convertCompareOp(CompareOperation ak)
 	VkCompareOp out = VK_COMPARE_OP_NEVER;
 	switch(ak)
 	{
-	case CompareOperation::ALWAYS:
+	case CompareOperation::kAlways:
 		out = VK_COMPARE_OP_ALWAYS;
 		break;
-	case CompareOperation::LESS:
+	case CompareOperation::kLess:
 		out = VK_COMPARE_OP_LESS;
 		break;
-	case CompareOperation::EQUAL:
+	case CompareOperation::kEqual:
 		out = VK_COMPARE_OP_EQUAL;
 		break;
-	case CompareOperation::LESS_EQUAL:
+	case CompareOperation::kLessEqual:
 		out = VK_COMPARE_OP_LESS_OR_EQUAL;
 		break;
-	case CompareOperation::GREATER:
+	case CompareOperation::kGreater:
 		out = VK_COMPARE_OP_GREATER;
 		break;
-	case CompareOperation::GREATER_EQUAL:
+	case CompareOperation::kGreaterEqual:
 		out = VK_COMPARE_OP_GREATER_OR_EQUAL;
 		break;
-	case CompareOperation::NOT_EQUAL:
+	case CompareOperation::kNotEqual:
 		out = VK_COMPARE_OP_NOT_EQUAL;
 		break;
-	case CompareOperation::NEVER:
+	case CompareOperation::kNever:
 		out = VK_COMPARE_OP_NEVER;
 		break;
 	default:
@@ -51,22 +51,22 @@ VkPrimitiveTopology convertTopology(PrimitiveTopology ak)
 	VkPrimitiveTopology out = VK_PRIMITIVE_TOPOLOGY_MAX_ENUM;
 	switch(ak)
 	{
-	case PrimitiveTopology::POINTS:
+	case PrimitiveTopology::kPoints:
 		out = VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
 		break;
-	case PrimitiveTopology::LINES:
+	case PrimitiveTopology::kLines:
 		out = VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
 		break;
-	case PrimitiveTopology::LINE_STRIP:
+	case PrimitiveTopology::kLineStip:
 		out = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
 		break;
-	case PrimitiveTopology::TRIANGLES:
+	case PrimitiveTopology::kTriangles:
 		out = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
 		break;
-	case PrimitiveTopology::TRIANGLE_STRIP:
+	case PrimitiveTopology::kTriangleStrip:
 		out = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
 		break;
-	case PrimitiveTopology::PATCHES:
+	case PrimitiveTopology::kPatchs:
 		out = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST;
 		break;
 	default:
@@ -81,13 +81,13 @@ VkPolygonMode convertFillMode(FillMode ak)
 	VkPolygonMode out = VK_POLYGON_MODE_FILL;
 	switch(ak)
 	{
-	case FillMode::POINTS:
+	case FillMode::kPoints:
 		out = VK_POLYGON_MODE_POINT;
 		break;
-	case FillMode::WIREFRAME:
+	case FillMode::kWireframe:
 		out = VK_POLYGON_MODE_LINE;
 		break;
-	case FillMode::SOLID:
+	case FillMode::kSolid:
 		out = VK_POLYGON_MODE_FILL;
 		break;
 	default:
@@ -102,16 +102,16 @@ VkCullModeFlags convertCullMode(FaceSelectionBit ak)
 	VkCullModeFlags out = 0;
 	switch(ak)
 	{
-	case FaceSelectionBit::NONE:
+	case FaceSelectionBit::kNone:
 		out = VK_CULL_MODE_NONE;
 		break;
-	case FaceSelectionBit::FRONT:
+	case FaceSelectionBit::kFront:
 		out = VK_CULL_MODE_FRONT_BIT;
 		break;
-	case FaceSelectionBit::BACK:
+	case FaceSelectionBit::kBack:
 		out = VK_CULL_MODE_BACK_BIT;
 		break;
-	case FaceSelectionBit::FRONT_AND_BACK:
+	case FaceSelectionBit::kFrontAndBack:
 		out = VK_CULL_MODE_FRONT_BIT | VK_CULL_MODE_BACK_BIT;
 		break;
 	default:
@@ -126,61 +126,61 @@ VkBlendFactor convertBlendFactor(BlendFactor ak)
 	VkBlendFactor out = VK_BLEND_FACTOR_MAX_ENUM;
 	switch(ak)
 	{
-	case BlendFactor::ZERO:
+	case BlendFactor::kZero:
 		out = VK_BLEND_FACTOR_ZERO;
 		break;
-	case BlendFactor::ONE:
+	case BlendFactor::kOne:
 		out = VK_BLEND_FACTOR_ONE;
 		break;
-	case BlendFactor::SRC_COLOR:
+	case BlendFactor::kSrcColor:
 		out = VK_BLEND_FACTOR_SRC_COLOR;
 		break;
-	case BlendFactor::ONE_MINUS_SRC_COLOR:
+	case BlendFactor::kOneMinusSrcColor:
 		out = VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR;
 		break;
-	case BlendFactor::DST_COLOR:
+	case BlendFactor::kDstColor:
 		out = VK_BLEND_FACTOR_DST_COLOR;
 		break;
-	case BlendFactor::ONE_MINUS_DST_COLOR:
+	case BlendFactor::kOneMinusDstColor:
 		out = VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR;
 		break;
-	case BlendFactor::SRC_ALPHA:
+	case BlendFactor::kSrcAlpha:
 		out = VK_BLEND_FACTOR_SRC_ALPHA;
 		break;
-	case BlendFactor::ONE_MINUS_SRC_ALPHA:
+	case BlendFactor::kOneMinusSrcAlpha:
 		out = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
 		break;
-	case BlendFactor::DST_ALPHA:
+	case BlendFactor::kDstAlpha:
 		out = VK_BLEND_FACTOR_DST_ALPHA;
 		break;
-	case BlendFactor::ONE_MINUS_DST_ALPHA:
+	case BlendFactor::kOneMinusDstAlpha:
 		out = VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;
 		break;
-	case BlendFactor::CONSTANT_COLOR:
+	case BlendFactor::kConstantColor:
 		out = VK_BLEND_FACTOR_CONSTANT_COLOR;
 		break;
-	case BlendFactor::ONE_MINUS_CONSTANT_COLOR:
+	case BlendFactor::kOneMinusConstantColor:
 		out = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR;
 		break;
-	case BlendFactor::CONSTANT_ALPHA:
+	case BlendFactor::kConstantAlpha:
 		out = VK_BLEND_FACTOR_CONSTANT_ALPHA;
 		break;
-	case BlendFactor::ONE_MINUS_CONSTANT_ALPHA:
+	case BlendFactor::kOneMinusConstantAlpha:
 		out = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA;
 		break;
-	case BlendFactor::SRC_ALPHA_SATURATE:
+	case BlendFactor::kSrcAlphaSaturate:
 		out = VK_BLEND_FACTOR_SRC_ALPHA_SATURATE;
 		break;
-	case BlendFactor::SRC1_COLOR:
+	case BlendFactor::kSrc1Color:
 		out = VK_BLEND_FACTOR_SRC1_COLOR;
 		break;
-	case BlendFactor::ONE_MINUS_SRC1_COLOR:
+	case BlendFactor::kOneMinusSrc1Color:
 		out = VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR;
 		break;
-	case BlendFactor::SRC1_ALPHA:
+	case BlendFactor::kSrc1Alpha:
 		out = VK_BLEND_FACTOR_SRC1_ALPHA;
 		break;
-	case BlendFactor::ONE_MINUS_SRC1_ALPHA:
+	case BlendFactor::kOneMinusSrc1Alpha:
 		out = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA;
 		break;
 	default:
@@ -196,19 +196,19 @@ VkBlendOp convertBlendOperation(BlendOperation ak)
 
 	switch(ak)
 	{
-	case BlendOperation::ADD:
+	case BlendOperation::kAdd:
 		out = VK_BLEND_OP_ADD;
 		break;
-	case BlendOperation::SUBTRACT:
+	case BlendOperation::kSubtract:
 		out = VK_BLEND_OP_SUBTRACT;
 		break;
-	case BlendOperation::REVERSE_SUBTRACT:
+	case BlendOperation::kReverseSubtract:
 		out = VK_BLEND_OP_REVERSE_SUBTRACT;
 		break;
-	case BlendOperation::MIN:
+	case BlendOperation::kMin:
 		out = VK_BLEND_OP_MIN;
 		break;
-	case BlendOperation::MAX:
+	case BlendOperation::kMax:
 		out = VK_BLEND_OP_MAX;
 		break;
 	default:
@@ -338,16 +338,16 @@ VkImageType convertTextureType(TextureType ak)
 	VkImageType out = VK_IMAGE_TYPE_MAX_ENUM;
 	switch(ak)
 	{
-	case TextureType::CUBE:
-	case TextureType::CUBE_ARRAY:
-	case TextureType::_2D:
-	case TextureType::_2D_ARRAY:
+	case TextureType::kCube:
+	case TextureType::kCubeArray:
+	case TextureType::k2D:
+	case TextureType::k2DArray:
 		out = VK_IMAGE_TYPE_2D;
 		break;
-	case TextureType::_3D:
+	case TextureType::k3D:
 		out = VK_IMAGE_TYPE_3D;
 		break;
-	case TextureType::_1D:
+	case TextureType::k1D:
 		out = VK_IMAGE_TYPE_1D;
 		break;
 	default:
@@ -362,22 +362,22 @@ VkImageViewType convertTextureViewType(TextureType ak)
 	VkImageViewType out = VK_IMAGE_VIEW_TYPE_MAX_ENUM;
 	switch(ak)
 	{
-	case TextureType::_1D:
+	case TextureType::k1D:
 		out = VK_IMAGE_VIEW_TYPE_1D;
 		break;
-	case TextureType::_2D:
+	case TextureType::k2D:
 		out = VK_IMAGE_VIEW_TYPE_2D;
 		break;
-	case TextureType::_2D_ARRAY:
+	case TextureType::k2DArray:
 		out = VK_IMAGE_VIEW_TYPE_2D_ARRAY;
 		break;
-	case TextureType::_3D:
+	case TextureType::k3D:
 		out = VK_IMAGE_VIEW_TYPE_3D;
 		break;
-	case TextureType::CUBE:
+	case TextureType::kCube:
 		out = VK_IMAGE_VIEW_TYPE_CUBE;
 		break;
-	case TextureType::CUBE_ARRAY:
+	case TextureType::kCubeArray:
 		out = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
 		break;
 	default:
@@ -391,17 +391,17 @@ VkImageUsageFlags convertTextureUsage(const TextureUsageBit ak, const Format for
 {
 	VkImageUsageFlags out = 0;
 
-	if(!!(ak & TextureUsageBit::ALL_SAMPLED))
+	if(!!(ak & TextureUsageBit::kAllSampled))
 	{
 		out |= VK_IMAGE_USAGE_SAMPLED_BIT;
 	}
 
-	if(!!(ak & TextureUsageBit::ALL_IMAGE))
+	if(!!(ak & TextureUsageBit::kAllImage))
 	{
 		out |= VK_IMAGE_USAGE_STORAGE_BIT;
 	}
 
-	if(!!(ak & (TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE)))
+	if(!!(ak & (TextureUsageBit::kFramebufferRead | TextureUsageBit::kFramebufferWrite)))
 	{
 		if(getFormatInfo(format).isDepthStencil())
 		{
@@ -413,17 +413,17 @@ VkImageUsageFlags convertTextureUsage(const TextureUsageBit ak, const Format for
 		}
 	}
 
-	if(!!(ak & TextureUsageBit::FRAMEBUFFER_SHADING_RATE))
+	if(!!(ak & TextureUsageBit::kFramebufferShadingRate))
 	{
 		out |= VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
 	}
 
-	if(!!(ak & TextureUsageBit::TRANSFER_DESTINATION))
+	if(!!(ak & TextureUsageBit::kTransferDestination))
 	{
 		out |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
 	}
 
-	if(!!(ak & TextureUsageBit::GENERATE_MIPMAPS))
+	if(!!(ak & TextureUsageBit::kGenerateMipmaps))
 	{
 		out |= VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
 	}
@@ -438,28 +438,28 @@ VkStencilOp convertStencilOp(StencilOperation ak)
 
 	switch(ak)
 	{
-	case StencilOperation::KEEP:
+	case StencilOperation::kKeep:
 		out = VK_STENCIL_OP_KEEP;
 		break;
-	case StencilOperation::ZERO:
+	case StencilOperation::kZero:
 		out = VK_STENCIL_OP_ZERO;
 		break;
-	case StencilOperation::REPLACE:
+	case StencilOperation::kReplace:
 		out = VK_STENCIL_OP_REPLACE;
 		break;
-	case StencilOperation::INCREMENT_AND_CLAMP:
+	case StencilOperation::kIncrementAndClamp:
 		out = VK_STENCIL_OP_INCREMENT_AND_CLAMP;
 		break;
-	case StencilOperation::DECREMENT_AND_CLAMP:
+	case StencilOperation::kDecrementAndClamp:
 		out = VK_STENCIL_OP_DECREMENT_AND_CLAMP;
 		break;
-	case StencilOperation::INVERT:
+	case StencilOperation::kInvert:
 		out = VK_STENCIL_OP_INVERT;
 		break;
-	case StencilOperation::INCREMENT_AND_WRAP:
+	case StencilOperation::kIncrementAndWrap:
 		out = VK_STENCIL_OP_INCREMENT_AND_WRAP;
 		break;
-	case StencilOperation::DECREMENT_AND_WRAP:
+	case StencilOperation::kDecrementAndWrap:
 		out = VK_STENCIL_OP_DECREMENT_AND_WRAP;
 		break;
 	default:
@@ -471,65 +471,65 @@ VkStencilOp convertStencilOp(StencilOperation ak)
 
 VkShaderStageFlags convertShaderTypeBit(ShaderTypeBit bit)
 {
-	ANKI_ASSERT(bit != ShaderTypeBit::NONE);
+	ANKI_ASSERT(bit != ShaderTypeBit::kNone);
 
 	VkShaderStageFlags out = 0;
-	if(!!(bit & ShaderTypeBit::VERTEX))
+	if(!!(bit & ShaderTypeBit::kVertex))
 	{
 		out |= VK_SHADER_STAGE_VERTEX_BIT;
 	}
 
-	if(!!(bit & ShaderTypeBit::TESSELLATION_CONTROL))
+	if(!!(bit & ShaderTypeBit::kTessellationControl))
 	{
 		out |= VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT;
 	}
 
-	if(!!(bit & ShaderTypeBit::TESSELLATION_EVALUATION))
+	if(!!(bit & ShaderTypeBit::kTessellationEvaluation))
 	{
 		out |= VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;
 	}
 
-	if(!!(bit & ShaderTypeBit::GEOMETRY))
+	if(!!(bit & ShaderTypeBit::kGeometry))
 	{
 		out |= VK_SHADER_STAGE_GEOMETRY_BIT;
 	}
 
-	if(!!(bit & ShaderTypeBit::FRAGMENT))
+	if(!!(bit & ShaderTypeBit::kFragment))
 	{
 		out |= VK_SHADER_STAGE_FRAGMENT_BIT;
 	}
 
-	if(!!(bit & ShaderTypeBit::COMPUTE))
+	if(!!(bit & ShaderTypeBit::kCompute))
 	{
 		out |= VK_SHADER_STAGE_COMPUTE_BIT;
 	}
 
-	if(!!(bit & ShaderTypeBit::RAY_GEN))
+	if(!!(bit & ShaderTypeBit::kRayGen))
 	{
 		out |= VK_SHADER_STAGE_RAYGEN_BIT_KHR;
 	}
 
-	if(!!(bit & ShaderTypeBit::ANY_HIT))
+	if(!!(bit & ShaderTypeBit::kAnyHit))
 	{
 		out |= VK_SHADER_STAGE_ANY_HIT_BIT_KHR;
 	}
 
-	if(!!(bit & ShaderTypeBit::CLOSEST_HIT))
+	if(!!(bit & ShaderTypeBit::kClosestHit))
 	{
 		out |= VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR;
 	}
 
-	if(!!(bit & ShaderTypeBit::MISS))
+	if(!!(bit & ShaderTypeBit::kMiss))
 	{
 		out |= VK_SHADER_STAGE_MISS_BIT_KHR;
 	}
 
-	if(!!(bit & ShaderTypeBit::INTERSECTION))
+	if(!!(bit & ShaderTypeBit::kIntersection))
 	{
 		out |= VK_SHADER_STAGE_INTERSECTION_BIT_KHR;
 	}
 
-	if(!!(bit & ShaderTypeBit::CALLABLE))
+	if(!!(bit & ShaderTypeBit::kCallable))
 	{
 		out |= VK_SHADER_STAGE_CALLABLE_BIT_KHR;
 	}

AnKi/Gr/Vulkan/Common.h

@@ -100,12 +100,12 @@ enum class VulkanQueueType : U8
 	GENERAL,
 	COMPUTE,
 
-	COUNT,
-	FIRST = 0
+	kCount,
+	kFirst = 0
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(VulkanQueueType)
 
-using VulkanQueueFamilies = Array<U32, U32(VulkanQueueType::COUNT)>;
+using VulkanQueueFamilies = Array<U32, U32(VulkanQueueType::kCount)>;
 
 /// @name Constants
 /// @{
@@ -158,7 +158,7 @@ static_assert(!(BufferUsageBit::ALL & PrivateBufferUsageBit::ALL_PRIVATE), "Upda
 /// Convert format.
 [[nodiscard]] inline VkFormat convertFormat(const Format ak)
 {
-	ANKI_ASSERT(ak != Format::NONE);
+	ANKI_ASSERT(ak != Format::kNone);
 	const VkFormat out = static_cast<VkFormat>(ak);
 	return out;
 }
@@ -166,15 +166,15 @@ static_assert(!(BufferUsageBit::ALL & PrivateBufferUsageBit::ALL_PRIVATE), "Upda
 /// Get format aspect mask.
 [[nodiscard]] inline DepthStencilAspectBit getImageAspectFromFormat(const Format ak)
 {
-	DepthStencilAspectBit out = DepthStencilAspectBit::NONE;
+	DepthStencilAspectBit out = DepthStencilAspectBit::kNone;
 	if(getFormatInfo(ak).isStencil())
 	{
-		out = DepthStencilAspectBit::STENCIL;
+		out = DepthStencilAspectBit::kStencil;
 	}
 
 	if(getFormatInfo(ak).isDepth())
 	{
-		out |= DepthStencilAspectBit::DEPTH;
+		out |= DepthStencilAspectBit::kDepth;
 	}
 
 	return out;
@@ -184,12 +184,12 @@ static_assert(!(BufferUsageBit::ALL & PrivateBufferUsageBit::ALL_PRIVATE), "Upda
 [[nodiscard]] inline VkImageAspectFlags convertImageAspect(const DepthStencilAspectBit ak)
 {
 	VkImageAspectFlags out = 0;
-	if(!!(ak & DepthStencilAspectBit::DEPTH))
+	if(!!(ak & DepthStencilAspectBit::kDepth))
 	{
 		out |= VK_IMAGE_ASPECT_DEPTH_BIT;
 	}
 
-	if(!!(ak & DepthStencilAspectBit::STENCIL))
+	if(!!(ak & DepthStencilAspectBit::kStencil))
 	{
 		out |= VK_IMAGE_ASPECT_STENCIL_BIT;
 	}
@@ -247,10 +247,10 @@ static_assert(!(BufferUsageBit::ALL & PrivateBufferUsageBit::ALL_PRIVATE), "Upda
 	VkVertexInputRate out;
 	switch(ak)
 	{
-	case VertexStepRate::VERTEX:
+	case VertexStepRate::kVertex:
 		out = VK_VERTEX_INPUT_RATE_VERTEX;
 		break;
-	case VertexStepRate::INSTANCE:
+	case VertexStepRate::kInstance:
 		out = VK_VERTEX_INPUT_RATE_INSTANCE;
 		break;
 	default:

AnKi/Gr/Vulkan/DescriptorSet.h

@@ -26,7 +26,7 @@ class alignas(8) DescriptorBinding
 {
 public:
 	U32 m_arraySize = 0;
-	ShaderTypeBit m_stageMask = ShaderTypeBit::NONE;
+	ShaderTypeBit m_stageMask = ShaderTypeBit::kNone;
 	DescriptorType m_type = DescriptorType::COUNT;
 	U8 m_binding = MAX_U8;
 };

AnKi/Gr/Vulkan/FramebufferImpl.cpp

@@ -113,7 +113,7 @@ Error FramebufferImpl::initFbs(const FramebufferInitInfo& init)
 	ci.attachmentCount = getTotalAttachmentCount();
 	ci.layers = 1;
 
-	Array<VkImageView, MAX_ATTACHMENTS> imgViews;
+	Array<VkImageView, kMaxAttachments> imgViews;
 	U count = 0;
 
 	for(U i = 0; i < init.m_colorAttachmentCount; ++i)
@@ -133,7 +133,7 @@ Error FramebufferImpl::initFbs(const FramebufferInitInfo& init)
 
 		m_viewRefs.m_color[i] = att.m_textureView;
 
-		if(!!(tex.getTextureUsage() & TextureUsageBit::PRESENT))
+		if(!!(tex.getTextureUsage() & TextureUsageBit::kPresent))
 		{
 			m_presentableTex = true;
 		}
@@ -163,7 +163,7 @@ Error FramebufferImpl::initFbs(const FramebufferInitInfo& init)
 	if(hasSri())
 	{
 		const TextureViewImpl& view = static_cast<const TextureViewImpl&>(*init.m_shadingRateImage.m_textureView);
-		ANKI_ASSERT(view.getTextureImpl().usageValid(TextureUsageBit::FRAMEBUFFER_SHADING_RATE));
+		ANKI_ASSERT(view.getTextureImpl().usageValid(TextureUsageBit::kFramebufferShadingRate));
 		imgViews[count] = view.getHandle();
 		m_viewRefs.m_sri = init.m_shadingRateImage.m_textureView;
 		++count;
@@ -278,7 +278,7 @@ VkRenderPass FramebufferImpl::getRenderPassHandle(const Array<VkImageLayout, MAX
 	VkRenderPass out = VK_NULL_HANDLE;
 
 	// Create hash
-	Array<VkImageLayout, MAX_ATTACHMENTS> allLayouts;
+	Array<VkImageLayout, kMaxAttachments> allLayouts;
 	U allLayoutCount = 0;
 	for(U i = 0; i < m_colorAttCount; ++i)
 	{
@@ -325,8 +325,8 @@ VkRenderPass FramebufferImpl::getRenderPassHandle(const Array<VkImageLayout, MAX
 		else
 		{
 			VkRenderPassCreateInfo2 ci = m_rpassCi;
-			Array<VkAttachmentDescription2, MAX_ATTACHMENTS> attachmentDescriptions = m_attachmentDescriptions;
-			Array<VkAttachmentReference2, MAX_ATTACHMENTS> references = m_references;
+			Array<VkAttachmentDescription2, kMaxAttachments> attachmentDescriptions = m_attachmentDescriptions;
+			Array<VkAttachmentReference2, kMaxAttachments> references = m_references;
 			VkSubpassDescription2 subpassDescr = m_subpassDescr;
 			VkFragmentShadingRateAttachmentInfoKHR sriAttachmentInfo = m_sriAttachmentInfo;
 

AnKi/Gr/Vulkan/FramebufferImpl.h

@@ -52,8 +52,8 @@ public:
 	void getAttachmentInfo(BitSet<MAX_COLOR_ATTACHMENTS, U8>& colorAttachments, Bool& depth, Bool& stencil) const
 	{
 		colorAttachments = m_colorAttachmentMask;
-		depth = !!(m_aspect & DepthStencilAspectBit::DEPTH);
-		stencil = !!(m_aspect & DepthStencilAspectBit::STENCIL);
+		depth = !!(m_aspect & DepthStencilAspectBit::kDepth);
+		stencil = !!(m_aspect & DepthStencilAspectBit::kStencil);
 	}
 
 	U32 getColorAttachmentCount() const
@@ -109,13 +109,13 @@ public:
 	}
 
 private:
-	static constexpr U32 MAX_ATTACHMENTS = MAX_COLOR_ATTACHMENTS + 2; ///< Color + depth/stencil + SRI
+	static constexpr U32 kMaxAttachments = MAX_COLOR_ATTACHMENTS + 2; ///< Color + depth/stencil + SRI
 
 	BitSet<MAX_COLOR_ATTACHMENTS, U8> m_colorAttachmentMask = {false};
-	DepthStencilAspectBit m_aspect = DepthStencilAspectBit::NONE;
+	DepthStencilAspectBit m_aspect = DepthStencilAspectBit::kNone;
 
 	U8 m_colorAttCount = 0;
-	Array<VkClearValue, MAX_ATTACHMENTS> m_clearVals;
+	Array<VkClearValue, kMaxAttachments> m_clearVals;
 
 	U32 m_width = 0;
 	U32 m_height = 0;
@@ -138,8 +138,8 @@ private:
 
 	// RenderPass create info
 	VkRenderPassCreateInfo2 m_rpassCi = {};
-	Array<VkAttachmentDescription2, MAX_ATTACHMENTS> m_attachmentDescriptions = {};
-	Array<VkAttachmentReference2, MAX_ATTACHMENTS> m_references = {};
+	Array<VkAttachmentDescription2, kMaxAttachments> m_attachmentDescriptions = {};
+	Array<VkAttachmentReference2, kMaxAttachments> m_references = {};
 	VkSubpassDescription2 m_subpassDescr = {};
 	VkFragmentShadingRateAttachmentInfoKHR m_sriAttachmentInfo = {};
 

AnKi/Gr/Vulkan/GrManagerImpl.cpp

@@ -482,33 +482,33 @@ Error GrManagerImpl::initInstance()
 	switch(m_devProps.properties.vendorID)
 	{
 	case 0x13B5:
-		m_capabilities.m_gpuVendor = GpuVendor::ARM;
+		m_capabilities.m_gpuVendor = GpuVendor::kArm;
 		m_capabilities.m_minSubgroupSize = 16;
 		m_capabilities.m_maxSubgroupSize = 16;
 		break;
 	case 0x10DE:
-		m_capabilities.m_gpuVendor = GpuVendor::NVIDIA;
+		m_capabilities.m_gpuVendor = GpuVendor::kNvidia;
 		m_capabilities.m_minSubgroupSize = 32;
 		m_capabilities.m_maxSubgroupSize = 32;
 		break;
 	case 0x1002:
 	case 0x1022:
-		m_capabilities.m_gpuVendor = GpuVendor::AMD;
+		m_capabilities.m_gpuVendor = GpuVendor::kAMD;
 		m_capabilities.m_minSubgroupSize = 32;
 		m_capabilities.m_maxSubgroupSize = 64;
 		break;
 	case 0x8086:
-		m_capabilities.m_gpuVendor = GpuVendor::INTEL;
+		m_capabilities.m_gpuVendor = GpuVendor::kIntel;
 		m_capabilities.m_minSubgroupSize = 8;
 		m_capabilities.m_maxSubgroupSize = 32;
 		break;
 	case 0x5143:
-		m_capabilities.m_gpuVendor = GpuVendor::QUALCOMM;
+		m_capabilities.m_gpuVendor = GpuVendor::kQualcomm;
 		m_capabilities.m_minSubgroupSize = 64;
 		m_capabilities.m_maxSubgroupSize = 128;
 		break;
 	default:
-		m_capabilities.m_gpuVendor = GpuVendor::UNKNOWN;
+		m_capabilities.m_gpuVendor = GpuVendor::kUnknown;
 		// Choose something really low
 		m_capabilities.m_minSubgroupSize = 8;
 		m_capabilities.m_maxSubgroupSize = 8;
@@ -535,7 +535,7 @@ Error GrManagerImpl::initInstance()
 	m_capabilities.m_sbtRecordAlignment = m_rtPipelineProps.shaderGroupBaseAlignment;
 
 #if ANKI_PLATFORM_MOBILE
-	if(m_capabilities.m_gpuVendor == GpuVendor::QUALCOMM)
+	if(m_capabilities.m_gpuVendor == GpuVendor::kQualcomm)
 	{
 		// Calling vkCreateGraphicsPipeline from multiple threads crashes qualcomm's compiler
 		ANKI_VK_LOGI("Enabling workaround for vkCreateGraphicsPipeline crashing when called from multiple threads");
@@ -544,7 +544,7 @@ Error GrManagerImpl::initInstance()
 #endif
 
 	// DLSS checks
-	m_capabilities.m_dlss = ANKI_DLSS && m_capabilities.m_gpuVendor == GpuVendor::NVIDIA;
+	m_capabilities.m_dlss = ANKI_DLSS && m_capabilities.m_gpuVendor == GpuVendor::kNvidia;
 
 	return Error::NONE;
 }
@@ -602,7 +602,7 @@ Error GrManagerImpl::initDevice(const GrManagerInitInfo& init)
 	}
 
 	const F32 priority = 1.0f;
-	Array<VkDeviceQueueCreateInfo, U32(VulkanQueueType::COUNT)> q = {};
+	Array<VkDeviceQueueCreateInfo, U32(VulkanQueueType::kCount)> q = {};
 
 	VkDeviceCreateInfo ci = {};
 	ci.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
@@ -1554,12 +1554,12 @@ Error GrManagerImpl::printPipelineShaderInfoInternal(VkPipeline ppline, CString
 
 		StringAuto str(getAllocator());
 
-		for(ShaderType type = ShaderType::FIRST; type < ShaderType::COUNT; ++type)
+		for(ShaderType type = ShaderType::kFirst; type < ShaderType::kCount; ++type)
 		{
 			ShaderTypeBit stage = stages & ShaderTypeBit(1 << type);
 			if(!stage)
 			{
-				ANKI_CHECK(m_shaderStatsFile.writeText((type != ShaderType::LAST) ? "0,0," : "0,0\n"));
+				ANKI_CHECK(m_shaderStatsFile.writeText((type != ShaderType::kLast) ? "0,0," : "0,0\n"));
 				continue;
 			}
 
@@ -1571,7 +1571,7 @@ Error GrManagerImpl::printPipelineShaderInfoInternal(VkPipeline ppline, CString
 						   .sprintf("Stage %u: VGRPS %02u, SGRPS %02u ", U32(type), stats.resourceUsage.numUsedVgprs,
 									stats.resourceUsage.numUsedSgprs));
 
-			ANKI_CHECK(m_shaderStatsFile.writeTextf((type != ShaderType::LAST) ? "%u,%u," : "%u,%u\n",
+			ANKI_CHECK(m_shaderStatsFile.writeTextf((type != ShaderType::kLast) ? "%u,%u," : "%u,%u\n",
 													stats.resourceUsage.numUsedVgprs,
 													stats.resourceUsage.numUsedSgprs));
 		}

AnKi/Gr/Vulkan/GrManagerImpl.h

@@ -248,7 +248,7 @@ private:
 	VulkanExtensions m_extensions = VulkanExtensions::NONE;
 	VkDevice m_device = VK_NULL_HANDLE;
 	VulkanQueueFamilies m_queueFamilyIndices = {MAX_U32, MAX_U32};
-	Array<VkQueue, U32(VulkanQueueType::COUNT)> m_queues = {};
+	Array<VkQueue, U32(VulkanQueueType::kCount)> m_queues = {};
 	Mutex m_globalMtx;
 
 	VkPhysicalDeviceProperties2 m_devProps = {};
@@ -284,7 +284,7 @@ private:
 		/// Signaled by the submit that renders to the default FB. Present waits for it.
 		MicroSemaphorePtr m_renderSemaphore;
 
-		VulkanQueueType m_queueWroteToSwapchainImage = VulkanQueueType::COUNT;
+		VulkanQueueType m_queueWroteToSwapchainImage = VulkanQueueType::kCount;
 	};
 
 	VkSurfaceKHR m_surface = VK_NULL_HANDLE;

AnKi/Gr/Vulkan/Pipeline.cpp

@@ -314,7 +314,7 @@ const VkGraphicsPipelineCreateInfo& PipelineStateTracker::updatePipelineCreateIn
 		if(m_fbDepth)
 		{
 			dsCi.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
-			dsCi.depthTestEnable = m_state.m_depth.m_depthCompareFunction != CompareOperation::ALWAYS
+			dsCi.depthTestEnable = m_state.m_depth.m_depthCompareFunction != CompareOperation::kAlways
 								   || m_state.m_depth.m_depthWriteEnabled;
 			dsCi.depthWriteEnable = m_state.m_depth.m_depthWriteEnabled;
 			dsCi.depthCompareOp = convertCompareOp(m_state.m_depth.m_depthCompareFunction);

AnKi/Gr/Vulkan/Pipeline.h

@@ -21,7 +21,7 @@ class VertexBufferBindingPipelineState
 {
 public:
 	U32 m_stride = MAX_U32; ///< Vertex stride.
-	VertexStepRate m_stepRate = VertexStepRate::VERTEX;
+	VertexStepRate m_stepRate = VertexStepRate::kVertex;
 	Array<U8, 3> m_padding = {};
 
 	Bool operator==(const VertexBufferBindingPipelineState& b) const
@@ -40,7 +40,7 @@ class VertexAttributeBindingPipelineState
 {
 public:
 	PtrSize m_offset = 0;
-	Format m_format = Format::NONE;
+	Format m_format = Format::kNone;
 	U8 m_binding = 0;
 	Array<U8, 3> m_padding = {};
 
@@ -70,7 +70,7 @@ static_assert(sizeof(VertexPipelineState)
 class InputAssemblerPipelineState
 {
 public:
-	PrimitiveTopology m_topology = PrimitiveTopology::TRIANGLES;
+	PrimitiveTopology m_topology = PrimitiveTopology::kTriangles;
 	Bool m_primitiveRestartEnabled = false;
 };
 static_assert(sizeof(InputAssemblerPipelineState) == sizeof(U8) * 2, "Packed because it will be hashed");
@@ -78,8 +78,8 @@ static_assert(sizeof(InputAssemblerPipelineState) == sizeof(U8) * 2, "Packed bec
 class RasterizerPipelineState
 {
 public:
-	FillMode m_fillMode = FillMode::SOLID;
-	FaceSelectionBit m_cullMode = FaceSelectionBit::BACK;
+	FillMode m_fillMode = FillMode::kSolid;
+	FaceSelectionBit m_cullMode = FaceSelectionBit::kBack;
 	RasterizationOrder m_rasterizationOrder = RasterizationOrder::ORDERED;
 	U8 m_padding = 0;
 	F32 m_depthBiasConstantFactor = 0.0f;
@@ -91,7 +91,7 @@ class DepthPipelineState
 {
 public:
 	Bool m_depthWriteEnabled = true;
-	CompareOperation m_depthCompareFunction = CompareOperation::LESS;
+	CompareOperation m_depthCompareFunction = CompareOperation::kLess;
 };
 static_assert(sizeof(DepthPipelineState) == sizeof(U8) * 2, "Packed because it will be hashed");
 
@@ -101,10 +101,10 @@ public:
 	class S
 	{
 	public:
-		StencilOperation m_stencilFailOperation = StencilOperation::KEEP;
-		StencilOperation m_stencilPassDepthFailOperation = StencilOperation::KEEP;
-		StencilOperation m_stencilPassDepthPassOperation = StencilOperation::KEEP;
-		CompareOperation m_compareFunction = CompareOperation::ALWAYS;
+		StencilOperation m_stencilFailOperation = StencilOperation::kKeep;
+		StencilOperation m_stencilPassDepthFailOperation = StencilOperation::kKeep;
+		StencilOperation m_stencilPassDepthPassOperation = StencilOperation::kKeep;
+		CompareOperation m_compareFunction = CompareOperation::kAlways;
 	};
 
 	Array<S, 2> m_face;
@@ -114,13 +114,13 @@ static_assert(sizeof(StencilPipelineState) == sizeof(U32) * 2, "Packed because i
 class ColorAttachmentState
 {
 public:
-	BlendFactor m_srcBlendFactorRgb = BlendFactor::ONE;
-	BlendFactor m_srcBlendFactorA = BlendFactor::ONE;
-	BlendFactor m_dstBlendFactorRgb = BlendFactor::ZERO;
-	BlendFactor m_dstBlendFactorA = BlendFactor::ZERO;
-	BlendOperation m_blendFunctionRgb = BlendOperation::ADD;
-	BlendOperation m_blendFunctionA = BlendOperation::ADD;
-	ColorBit m_channelWriteMask = ColorBit::ALL;
+	BlendFactor m_srcBlendFactorRgb = BlendFactor::kOne;
+	BlendFactor m_srcBlendFactorA = BlendFactor::kOne;
+	BlendFactor m_dstBlendFactorRgb = BlendFactor::kZero;
+	BlendFactor m_dstBlendFactorA = BlendFactor::kZero;
+	BlendOperation m_blendFunctionRgb = BlendOperation::kAdd;
+	BlendOperation m_blendFunctionA = BlendOperation::kAdd;
+	ColorBit m_channelWriteMask = ColorBit::kAll;
 };
 static_assert(sizeof(ColorAttachmentState) == sizeof(U8) * 7, "Packed because it will be hashed");
 
@@ -243,7 +243,7 @@ public:
 	void setStencilOperations(FaceSelectionBit face, StencilOperation stencilFail,
 							  StencilOperation stencilPassDepthFail, StencilOperation stencilPassDepthPass)
 	{
-		if(!!(face & FaceSelectionBit::FRONT)
+		if(!!(face & FaceSelectionBit::kFront)
 		   && (m_state.m_stencil.m_face[0].m_stencilFailOperation != stencilFail
 			   || m_state.m_stencil.m_face[0].m_stencilPassDepthFailOperation != stencilPassDepthFail
 			   || m_state.m_stencil.m_face[0].m_stencilPassDepthPassOperation != stencilPassDepthPass))
@@ -254,7 +254,7 @@ public:
 			m_dirty.m_stencil = true;
 		}
 
-		if(!!(face & FaceSelectionBit::BACK)
+		if(!!(face & FaceSelectionBit::kBack)
 		   && (m_state.m_stencil.m_face[1].m_stencilFailOperation != stencilFail
 			   || m_state.m_stencil.m_face[1].m_stencilPassDepthFailOperation != stencilPassDepthFail
 			   || m_state.m_stencil.m_face[1].m_stencilPassDepthPassOperation != stencilPassDepthPass))
@@ -268,13 +268,13 @@ public:
 
 	void setStencilCompareOperation(FaceSelectionBit face, CompareOperation comp)
 	{
-		if(!!(face & FaceSelectionBit::FRONT) && m_state.m_stencil.m_face[0].m_compareFunction != comp)
+		if(!!(face & FaceSelectionBit::kFront) && m_state.m_stencil.m_face[0].m_compareFunction != comp)
 		{
 			m_state.m_stencil.m_face[0].m_compareFunction = comp;
 			m_dirty.m_stencil = true;
 		}
 
-		if(!!(face & FaceSelectionBit::BACK) && m_state.m_stencil.m_face[1].m_compareFunction != comp)
+		if(!!(face & FaceSelectionBit::kBack) && m_state.m_stencil.m_face[1].m_compareFunction != comp)
 		{
 			m_state.m_stencil.m_face[1].m_compareFunction = comp;
 			m_dirty.m_stencil = true;

AnKi/Gr/Vulkan/SamplerFactory.cpp

@@ -22,24 +22,24 @@ Error MicroSampler::init(const SamplerInitInfo& inf)
 	VkSamplerCreateInfo ci = {};
 	ci.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
 
-	if(inf.m_minMagFilter == SamplingFilter::NEAREST)
+	if(inf.m_minMagFilter == SamplingFilter::kNearest)
 	{
 		ci.minFilter = VK_FILTER_NEAREST;
 	}
-	else if(inf.m_minMagFilter == SamplingFilter::LINEAR)
+	else if(inf.m_minMagFilter == SamplingFilter::kLinear)
 	{
 		ci.minFilter = VK_FILTER_LINEAR;
 	}
 	else
 	{
-		ANKI_ASSERT(inf.m_minMagFilter == SamplingFilter::MAX || inf.m_minMagFilter == SamplingFilter::MIN);
+		ANKI_ASSERT(inf.m_minMagFilter == SamplingFilter::kMax || inf.m_minMagFilter == SamplingFilter::kMin);
 		ANKI_ASSERT(m_factory->m_gr->getDeviceCapabilities().m_samplingFilterMinMax);
 		ci.minFilter = VK_FILTER_LINEAR;
 	}
 
 	ci.magFilter = ci.minFilter;
 
-	if(inf.m_mipmapFilter == SamplingFilter::BASE || inf.m_mipmapFilter == SamplingFilter::NEAREST)
+	if(inf.m_mipmapFilter == SamplingFilter::kBase || inf.m_mipmapFilter == SamplingFilter::kNearest)
 	{
 		ci.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
 	}
@@ -50,17 +50,17 @@ Error MicroSampler::init(const SamplerInitInfo& inf)
 
 	switch(inf.m_addressing)
 	{
-	case SamplingAddressing::CLAMP:
+	case SamplingAddressing::kClamp:
 		ci.addressModeU = ci.addressModeV = ci.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
 		break;
-	case SamplingAddressing::REPEAT:
+	case SamplingAddressing::kRepeat:
 		ci.addressModeU = ci.addressModeV = ci.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
 		break;
-	case SamplingAddressing::BLACK:
+	case SamplingAddressing::kBlack:
 		ci.addressModeU = ci.addressModeV = ci.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
 		ci.borderColor = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
 		break;
-	case SamplingAddressing::WHITE:
+	case SamplingAddressing::kWhite:
 		ci.addressModeU = ci.addressModeV = ci.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
 		ci.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
 		break;
@@ -89,16 +89,16 @@ Error MicroSampler::init(const SamplerInitInfo& inf)
 
 	// min/max
 	VkSamplerReductionModeCreateInfoEXT reductionCi = {};
-	if(inf.m_minMagFilter == SamplingFilter::MAX || inf.m_minMagFilter == SamplingFilter::MIN)
+	if(inf.m_minMagFilter == SamplingFilter::kMax || inf.m_minMagFilter == SamplingFilter::kMin)
 	{
 		reductionCi.sType = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT;
-		if(inf.m_minMagFilter == SamplingFilter::MAX)
+		if(inf.m_minMagFilter == SamplingFilter::kMax)
 		{
 			reductionCi.reductionMode = VK_SAMPLER_REDUCTION_MODE_MAX_EXT;
 		}
 		else
 		{
-			ANKI_ASSERT(inf.m_minMagFilter == SamplingFilter::MIN);
+			ANKI_ASSERT(inf.m_minMagFilter == SamplingFilter::kMin);
 			reductionCi.reductionMode = VK_SAMPLER_REDUCTION_MODE_MIN_EXT;
 		}
 

AnKi/Gr/Vulkan/ShaderImpl.cpp

@@ -209,7 +209,7 @@ void ShaderImpl::doReflection(ConstWeakArray<U8> spirv, SpecConstsVector& specCo
 	}
 
 	// Color attachments
-	if(m_shaderType == ShaderType::FRAGMENT)
+	if(m_shaderType == ShaderType::kFragment)
 	{
 		for(const spirv_cross::Resource& r : rsrc.stage_outputs)
 		{
@@ -221,7 +221,7 @@ void ShaderImpl::doReflection(ConstWeakArray<U8> spirv, SpecConstsVector& specCo
 	}
 
 	// Attribs
-	if(m_shaderType == ShaderType::VERTEX)
+	if(m_shaderType == ShaderType::kVertex)
 	{
 		for(const spirv_cross::Resource& r : rsrcActive.stage_inputs)
 		{

AnKi/Gr/Vulkan/ShaderProgramImpl.cpp

@@ -44,7 +44,7 @@ Error ShaderProgramImpl::init(const ShaderProgramInitInfo& inf)
 	{
 		m_shaders.emplaceBack(getAllocator(), inf.m_computeShader);
 	}
-	else if(inf.m_graphicsShaders[ShaderType::VERTEX])
+	else if(inf.m_graphicsShaders[ShaderType::kVertex])
 	{
 		for(const ShaderPtr& s : inf.m_graphicsShaders)
 		{
@@ -182,14 +182,14 @@ Error ShaderProgramImpl::init(const ShaderProgramInitInfo& inf)
 
 	// Get some masks
 	//
-	const Bool graphicsProg = !!(m_stages & ShaderTypeBit::ALL_GRAPHICS);
+	const Bool graphicsProg = !!(m_stages & ShaderTypeBit::kAllGraphics);
 	if(graphicsProg)
 	{
 		m_refl.m_attributeMask =
-			static_cast<const ShaderImpl&>(*inf.m_graphicsShaders[ShaderType::VERTEX]).m_attributeMask;
+			static_cast<const ShaderImpl&>(*inf.m_graphicsShaders[ShaderType::kVertex]).m_attributeMask;
 
 		m_refl.m_colorAttachmentWritemask =
-			static_cast<const ShaderImpl&>(*inf.m_graphicsShaders[ShaderType::FRAGMENT]).m_colorAttachmentWritemask;
+			static_cast<const ShaderImpl&>(*inf.m_graphicsShaders[ShaderType::kFragment]).m_colorAttachmentWritemask;
 
 		const U32 attachmentCount = m_refl.m_colorAttachmentWritemask.getEnabledBitCount();
 		for(U32 i = 0; i < attachmentCount; ++i)
@@ -233,7 +233,7 @@ Error ShaderProgramImpl::init(const ShaderProgramInitInfo& inf)
 
 	// Create the pipeline if compute
 	//
-	if(!!(m_stages & ShaderTypeBit::COMPUTE))
+	if(!!(m_stages & ShaderTypeBit::kCompute))
 	{
 		const ShaderImpl& shaderImpl = static_cast<const ShaderImpl&>(*m_shaders[0]);
 
@@ -256,12 +256,12 @@ Error ShaderProgramImpl::init(const ShaderProgramInitInfo& inf)
 		ANKI_TRACE_SCOPED_EVENT(VK_PIPELINE_CREATE);
 		ANKI_VK_CHECK(vkCreateComputePipelines(getDevice(), getGrManagerImpl().getPipelineCache(), 1, &ci, nullptr,
 											   &m_compute.m_ppline));
-		getGrManagerImpl().printPipelineShaderInfo(m_compute.m_ppline, getName(), ShaderTypeBit::COMPUTE);
+		getGrManagerImpl().printPipelineShaderInfo(m_compute.m_ppline, getName(), ShaderTypeBit::kCompute);
 	}
 
 	// Create the RT pipeline
 	//
-	if(!!(m_stages & ShaderTypeBit::ALL_RAY_TRACING))
+	if(!!(m_stages & ShaderTypeBit::kAllRayTracing))
 	{
 		// Create shaders
 		DynamicArrayAuto<VkPipelineShaderStageCreateInfo> stages(getAllocator(), m_shaders.getSize());

AnKi/Gr/Vulkan/ShaderProgramImpl.h

@@ -43,7 +43,7 @@ public:
 
 	Bool isGraphics() const
 	{
-		return !!(m_stages & ShaderTypeBit::ALL_GRAPHICS);
+		return !!(m_stages & ShaderTypeBit::kAllGraphics);
 	}
 
 	const VkPipelineShaderStageCreateInfo* getShaderCreateInfos(U32& count) const
@@ -108,7 +108,7 @@ public:
 
 private:
 	DynamicArray<ShaderPtr> m_shaders;
-	ShaderTypeBit m_stages = ShaderTypeBit::NONE;
+	ShaderTypeBit m_stages = ShaderTypeBit::kNone;
 
 	PipelineLayout m_pplineLayout = {};
 	Array<DescriptorSetLayout, MAX_DESCRIPTOR_SETS> m_descriptorSetLayouts;
@@ -118,7 +118,8 @@ private:
 	class
 	{
 	public:
-		Array<VkPipelineShaderStageCreateInfo, U32(ShaderType::FRAGMENT - ShaderType::VERTEX) + 1> m_shaderCreateInfos;
+		Array<VkPipelineShaderStageCreateInfo, U32(ShaderType::kFragment - ShaderType::kVertex) + 1>
+			m_shaderCreateInfos;
 		U32 m_shaderCreateInfoCount = 0;
 		PipelineFactory* m_pplineFactory = nullptr;
 	} m_graphics;

AnKi/Gr/Vulkan/SwapchainFactory.cpp

@@ -76,7 +76,7 @@ Error MicroSwapchain::initInternal()
 														   m_factory->m_gr->getSurface(), &formatCount, &formats[0]));
 
 		ANKI_VK_LOGV("Supported surface formats:");
-		Format akSurfaceFormat = Format::NONE;
+		Format akSurfaceFormat = Format::kNone;
 		for(U32 i = 0; i < formatCount; ++i)
 		{
 			const VkFormat vkFormat = formats[i].format;
@@ -86,15 +86,15 @@ Error MicroSwapchain::initInternal()
 #define ANKI_FORMAT_DEF(type, id, componentCount, texelSize, blockWidth, blockHeight, blockSize, shaderType, \
 						depthStencil) \
 	case id: \
-		akFormat = Format::type; \
+		akFormat = Format::k##type; \
 		break;
 #include <AnKi/Gr/Format.defs.h>
 #undef ANKI_FORMAT_DEF
 			default:
-				akFormat = Format::NONE;
+				akFormat = Format::kNone;
 			}
 
-			ANKI_VK_LOGV("\t%s", (akFormat != Format::NONE) ? getFormatInfo(akFormat).m_name : "Unknown format");
+			ANKI_VK_LOGV("\t%s", (akFormat != Format::kNone) ? getFormatInfo(akFormat).m_name : "Unknown format");
 
 			if(surfaceFormat == VK_FORMAT_UNDEFINED
 			   && (vkFormat == VK_FORMAT_R8G8B8A8_UNORM || vkFormat == VK_FORMAT_B8G8R8A8_UNORM
@@ -236,10 +236,10 @@ 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::IMAGE_COMPUTE_WRITE | TextureUsageBit::IMAGE_TRACE_RAYS_WRITE
-						   | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ
-						   | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE | TextureUsageBit::PRESENT;
-			init.m_type = TextureType::_2D;
+			init.m_usage = TextureUsageBit::kImageComputeWrite | TextureUsageBit::kImageTraceRaysWrite
+						   | TextureUsageBit::kFramebufferRead | TextureUsageBit::kFramebufferWrite
+						   | TextureUsageBit::kPresent;
+			init.m_type = TextureType::k2D;
 
 			TextureImpl* tex =
 				m_factory->m_gr->getAllocator().newInstance<TextureImpl>(m_factory->m_gr, init.getName());

AnKi/Gr/Vulkan/TextureImpl.cpp

@@ -99,7 +99,7 @@ TextureImpl::~TextureImpl()
 		}
 	}
 
-	if(m_imageHandle && !(m_usage & TextureUsageBit::PRESENT))
+	if(m_imageHandle && !(m_usage & TextureUsageBit::kPresent))
 	{
 		garbage->m_imageHandle = m_imageHandle;
 	}
@@ -115,11 +115,11 @@ Error TextureImpl::initInternal(VkImage externalImage, const TextureInitInfo& in
 	ANKI_ASSERT(init.isValid());
 	if(externalImage)
 	{
-		ANKI_ASSERT(!!(init.m_usage & TextureUsageBit::PRESENT));
+		ANKI_ASSERT(!!(init.m_usage & TextureUsageBit::kPresent));
 	}
 
 	ANKI_ASSERT(getGrManagerImpl().getDeviceCapabilities().m_vrs
-				|| !(init.m_usage & TextureUsageBit::FRAMEBUFFER_SHADING_RATE));
+				|| !(init.m_usage & TextureUsageBit::kFramebufferShadingRate));
 
 	// Set some stuff
 	m_width = init.m_width;
@@ -127,7 +127,7 @@ Error TextureImpl::initInternal(VkImage externalImage, const TextureInitInfo& in
 	m_depth = init.m_depth;
 	m_texType = init.m_type;
 
-	if(m_texType == TextureType::_3D)
+	if(m_texType == TextureType::k3D)
 	{
 		m_mipCount = min<U32>(init.m_mipmapCount, computeMaxMipmapCount3d(m_width, m_height, m_depth));
 	}
@@ -180,7 +180,7 @@ Error TextureImpl::initInternal(VkImage externalImage, const TextureInitInfo& in
 	}
 
 	// Create a view if the texture is a single surface
-	if(m_texType == TextureType::_2D && m_mipCount == 1 && m_aspect == DepthStencilAspectBit::NONE)
+	if(m_texType == TextureType::k2D && m_mipCount == 1 && m_aspect == DepthStencilAspectBit::kNone)
 	{
 		VkImageViewCreateInfo viewCi;
 		TextureSubresourceInfo subresource;
@@ -198,7 +198,7 @@ Error TextureImpl::initInternal(VkImage externalImage, const TextureInitInfo& in
 VkImageCreateFlags TextureImpl::calcCreateFlags(const TextureInitInfo& init)
 {
 	VkImageCreateFlags flags = 0;
-	if(init.m_type == TextureType::CUBE || init.m_type == TextureType::CUBE_ARRAY)
+	if(init.m_type == TextureType::kCube || init.m_type == TextureType::kCubeArray)
 	{
 		flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
 	}
@@ -247,24 +247,24 @@ Error TextureImpl::initImage(const TextureInitInfo& init)
 
 	switch(m_texType)
 	{
-	case TextureType::_1D:
-	case TextureType::_2D:
+	case TextureType::k1D:
+	case TextureType::k2D:
 		ci.extent.depth = 1;
 		ci.arrayLayers = 1;
 		break;
-	case TextureType::_2D_ARRAY:
+	case TextureType::k2DArray:
 		ci.extent.depth = 1;
 		ci.arrayLayers = init.m_layerCount;
 		break;
-	case TextureType::CUBE:
+	case TextureType::kCube:
 		ci.extent.depth = 1;
 		ci.arrayLayers = 6;
 		break;
-	case TextureType::CUBE_ARRAY:
+	case TextureType::kCubeArray:
 		ci.extent.depth = 1;
 		ci.arrayLayers = 6 * init.m_layerCount;
 		break;
-	case TextureType::_3D:
+	case TextureType::k3D:
 		ci.extent.depth = init.m_depth;
 		ci.arrayLayers = 1;
 		break;
@@ -345,57 +345,57 @@ void TextureImpl::computeBarrierInfo(TextureUsageBit usage, Bool src, U32 level,
 	accesses = 0;
 	const Bool depthStencil = !!m_aspect;
 
-	if(!!(usage & (TextureUsageBit::SAMPLED_GEOMETRY | TextureUsageBit::IMAGE_GEOMETRY_READ)))
+	if(!!(usage & (TextureUsageBit::kSampledGeometry | TextureUsageBit::kImageGeometryRead)))
 	{
 		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::IMAGE_GEOMETRY_WRITE))
+	if(!!(usage & TextureUsageBit::kImageGeometryWrite))
 	{
 		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::SAMPLED_FRAGMENT | TextureUsageBit::IMAGE_FRAGMENT_READ)))
+	if(!!(usage & (TextureUsageBit::kSampledFragment | TextureUsageBit::kImageFragmentRead)))
 	{
 		stages |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
 		accesses |= VK_ACCESS_SHADER_READ_BIT;
 	}
 
-	if(!!(usage & TextureUsageBit::IMAGE_FRAGMENT_WRITE))
+	if(!!(usage & TextureUsageBit::kImageFragmentWrite))
 	{
 		stages |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
 		accesses |= VK_ACCESS_SHADER_WRITE_BIT;
 	}
 
-	if(!!(usage & (TextureUsageBit::SAMPLED_COMPUTE | TextureUsageBit::IMAGE_COMPUTE_READ)))
+	if(!!(usage & (TextureUsageBit::kSampledCompute | TextureUsageBit::kImageComputeRead)))
 	{
 		stages |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
 		accesses |= VK_ACCESS_SHADER_READ_BIT;
 	}
 
-	if(!!(usage & TextureUsageBit::IMAGE_COMPUTE_WRITE))
+	if(!!(usage & TextureUsageBit::kImageComputeWrite))
 	{
 		stages |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
 		accesses |= VK_ACCESS_SHADER_WRITE_BIT;
 	}
 
-	if(!!(usage & (TextureUsageBit::SAMPLED_TRACE_RAYS | TextureUsageBit::IMAGE_TRACE_RAYS_READ)))
+	if(!!(usage & (TextureUsageBit::kSampledTraceRays | TextureUsageBit::kImageTraceRaysRead)))
 	{
 		stages |= VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
 		accesses |= VK_ACCESS_SHADER_READ_BIT;
 	}
 
-	if(!!(usage & TextureUsageBit::IMAGE_TRACE_RAYS_WRITE))
+	if(!!(usage & TextureUsageBit::kImageTraceRaysWrite))
 	{
 		stages |= VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
 		accesses |= VK_ACCESS_SHADER_WRITE_BIT;
 	}
 
-	if(!!(usage & TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ))
+	if(!!(usage & TextureUsageBit::kFramebufferRead))
 	{
 		if(depthStencil)
 		{
@@ -409,7 +409,7 @@ void TextureImpl::computeBarrierInfo(TextureUsageBit usage, Bool src, U32 level,
 		}
 	}
 
-	if(!!(usage & TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE))
+	if(!!(usage & TextureUsageBit::kFramebufferWrite))
 	{
 		if(depthStencil)
 		{
@@ -423,13 +423,13 @@ void TextureImpl::computeBarrierInfo(TextureUsageBit usage, Bool src, U32 level,
 		}
 	}
 
-	if(!!(usage & TextureUsageBit::FRAMEBUFFER_SHADING_RATE))
+	if(!!(usage & TextureUsageBit::kFramebufferShadingRate))
 	{
 		stages |= VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
 		accesses |= VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR;
 	}
 
-	if(!!(usage & TextureUsageBit::GENERATE_MIPMAPS))
+	if(!!(usage & TextureUsageBit::kGenerateMipmaps))
 	{
 		stages |= VK_PIPELINE_STAGE_TRANSFER_BIT;
 		if(src)
@@ -453,13 +453,13 @@ void TextureImpl::computeBarrierInfo(TextureUsageBit usage, Bool src, U32 level,
 		}
 	}
 
-	if(!!(usage & TextureUsageBit::TRANSFER_DESTINATION))
+	if(!!(usage & TextureUsageBit::kTransferDestination))
 	{
 		stages |= VK_PIPELINE_STAGE_TRANSFER_BIT;
 		accesses |= VK_ACCESS_TRANSFER_WRITE_BIT;
 	}
 
-	if(!!(usage & TextureUsageBit::PRESENT))
+	if(!!(usage & TextureUsageBit::kPresent))
 	{
 		stages |= VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
 		accesses |= VK_ACCESS_MEMORY_READ_BIT;
@@ -490,13 +490,13 @@ VkImageLayout TextureImpl::computeLayout(TextureUsageBit usage, U level) const
 	const Bool lastLevel = level == m_mipCount - 1u;
 	const Bool depthStencil = !!m_aspect;
 
-	if(usage == TextureUsageBit::NONE)
+	if(usage == TextureUsageBit::kNone)
 	{
 		out = VK_IMAGE_LAYOUT_UNDEFINED;
 	}
 	else if(depthStencil)
 	{
-		if(!(usage & ~(TextureUsageBit::ALL_SAMPLED | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ)))
+		if(!(usage & ~(TextureUsageBit::kAllSampled | TextureUsageBit::kFramebufferRead)))
 		{
 			// Only depth tests and sampled
 			out = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
@@ -504,32 +504,31 @@ VkImageLayout TextureImpl::computeLayout(TextureUsageBit usage, U level) const
 		else
 		{
 			// Only attachment write, the rest (eg transfer) are not supported for now
-			ANKI_ASSERT(usage == TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE
-						|| usage == TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT);
+			ANKI_ASSERT(usage == TextureUsageBit::kFramebufferWrite || usage == TextureUsageBit::kAllFramebuffer);
 			out = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
 		}
 	}
-	else if(!(usage & ~TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT))
+	else if(!(usage & ~TextureUsageBit::kAllFramebuffer))
 	{
 		// Color attachment
 		out = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
 	}
-	else if(!(usage & ~TextureUsageBit::FRAMEBUFFER_SHADING_RATE))
+	else if(!(usage & ~TextureUsageBit::kFramebufferShadingRate))
 	{
 		// SRI
 		out = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR;
 	}
-	else if(!(usage & ~TextureUsageBit::ALL_IMAGE))
+	else if(!(usage & ~TextureUsageBit::kAllImage))
 	{
 		// Only image load/store
 		out = VK_IMAGE_LAYOUT_GENERAL;
 	}
-	else if(!(usage & ~TextureUsageBit::ALL_SAMPLED))
+	else if(!(usage & ~TextureUsageBit::kAllSampled))
 	{
 		// Only sampled
 		out = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 	}
-	else if(usage == TextureUsageBit::GENERATE_MIPMAPS)
+	else if(usage == TextureUsageBit::kGenerateMipmaps)
 	{
 		if(!lastLevel)
 		{
@@ -540,11 +539,11 @@ VkImageLayout TextureImpl::computeLayout(TextureUsageBit usage, U level) const
 			out = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
 		}
 	}
-	else if(usage == TextureUsageBit::TRANSFER_DESTINATION)
+	else if(usage == TextureUsageBit::kTransferDestination)
 	{
 		out = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
 	}
-	else if(usage == TextureUsageBit::PRESENT)
+	else if(usage == TextureUsageBit::kPresent)
 	{
 		out = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
 	}
@@ -583,12 +582,12 @@ const MicroImageView& TextureImpl::getOrCreateView(const TextureSubresourceInfo&
 	// Not found in the 2nd search, create it
 
 	VkImageView handle = VK_NULL_HANDLE;
-	TextureType viewTexType = TextureType::COUNT;
+	TextureType viewTexType = TextureType::kCount;
 
 	// Compute the VkImageViewCreateInfo
 	VkImageViewCreateInfo viewCi;
 	computeVkImageViewCreateInfo(subresource, viewCi, viewTexType);
-	ANKI_ASSERT(viewTexType != TextureType::COUNT);
+	ANKI_ASSERT(viewTexType != TextureType::kCount);
 
 	ANKI_VK_CHECKF(vkCreateImageView(getDevice(), &viewCi, nullptr, &handle));
 	getGrManagerImpl().trySetVulkanHandleName(getName(), VK_OBJECT_TYPE_IMAGE_VIEW, ptrToNumber(handle));
@@ -614,11 +613,11 @@ TextureType TextureImpl::computeNewTexTypeOfSubresource(const TextureSubresource
 		if(subresource.m_faceCount != 6)
 		{
 			ANKI_ASSERT(subresource.m_faceCount == 1);
-			return (subresource.m_layerCount > 1) ? TextureType::_2D_ARRAY : TextureType::_2D;
+			return (subresource.m_layerCount > 1) ? TextureType::k2DArray : TextureType::k2D;
 		}
 		else if(subresource.m_layerCount == 1)
 		{
-			return TextureType::CUBE;
+			return TextureType::kCube;
 		}
 	}
 	return m_texType;

AnKi/Gr/Vulkan/TextureImpl.h

@@ -46,7 +46,7 @@ public:
 		m_bindlessIndex = b.m_bindlessIndex;
 		b.m_bindlessIndex = MAX_U32;
 		m_derivedTextureType = b.m_derivedTextureType;
-		b.m_derivedTextureType = TextureType::COUNT;
+		b.m_derivedTextureType = TextureType::kCount;
 		return *this;
 	}
 
@@ -61,7 +61,7 @@ public:
 
 	TextureType getDerivedTextureType() const
 	{
-		ANKI_ASSERT(m_derivedTextureType != TextureType::COUNT);
+		ANKI_ASSERT(m_derivedTextureType != TextureType::kCount);
 		return m_derivedTextureType;
 	}
 
@@ -72,7 +72,7 @@ private:
 	mutable SpinLock m_bindlessIndexLock;
 
 	/// Because for example a single surface view of a cube texture will be a 2D view.
-	TextureType m_derivedTextureType = TextureType::COUNT;
+	TextureType m_derivedTextureType = TextureType::kCount;
 };
 
 /// Texture container.
@@ -116,16 +116,16 @@ public:
 		U32 layer = 0;
 		switch(m_texType)
 		{
-		case TextureType::_2D:
+		case TextureType::k2D:
 			layer = 0;
 			break;
-		case TextureType::CUBE:
+		case TextureType::kCube:
 			layer = surf.m_face;
 			break;
-		case TextureType::_2D_ARRAY:
+		case TextureType::k2DArray:
 			layer = surf.m_layer;
 			break;
-		case TextureType::CUBE_ARRAY:
+		case TextureType::kCubeArray:
 			layer = surf.m_layer * 6 + surf.m_face;
 			break;
 		default:
@@ -137,7 +137,7 @@ public:
 
 	U32 computeVkArrayLayer([[maybe_unused]] const TextureVolumeInfo& vol) const
 	{
-		ANKI_ASSERT(m_texType == TextureType::_3D);
+		ANKI_ASSERT(m_texType == TextureType::k3D);
 		return 0;
 	}
 
@@ -195,7 +195,7 @@ private:
 	MicroImageView m_singleSurfaceImageView;
 
 #if ANKI_ENABLE_ASSERTIONS
-	mutable TextureUsageBit m_usedFor = TextureUsageBit::NONE;
+	mutable TextureUsageBit m_usedFor = TextureUsageBit::kNone;
 	mutable SpinLock m_usedForMtx;
 #endif
 

AnKi/Gr/Vulkan/TextureView.cpp

@@ -24,7 +24,7 @@ TextureView* TextureView::newInstance(GrManager* manager, const TextureViewInitI
 U32 TextureView::getOrCreateBindlessTextureIndex()
 {
 	ANKI_VK_SELF(TextureViewImpl);
-	ANKI_ASSERT(self.getTextureImpl().computeLayout(TextureUsageBit::ALL_SAMPLED, 0)
+	ANKI_ASSERT(self.getTextureImpl().computeLayout(TextureUsageBit::kAllSampled, 0)
 				== VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
 	return self.getOrCreateBindlessIndex();
 }

AnKi/Importer/GltfImporterMesh.cpp

@@ -641,28 +641,28 @@ Error GltfImporter::writeMesh(const cgltf_mesh& mesh, U32 lod, F32 decimateFacto
 		// Positions
 		MeshBinaryVertexAttribute& posa = header.m_vertexAttributes[VertexAttributeId::POSITION];
 		posa.m_bufferBinding = 0;
-		posa.m_format = Format::R32G32B32_SFLOAT;
+		posa.m_format = Format::kR32G32B32_Sfloat;
 		posa.m_relativeOffset = 0;
 		posa.m_scale = 1.0f;
 
 		// Normals
 		MeshBinaryVertexAttribute& na = header.m_vertexAttributes[VertexAttributeId::NORMAL];
 		na.m_bufferBinding = 1;
-		na.m_format = Format::A2B10G10R10_SNORM_PACK32;
+		na.m_format = Format::kA2B10G10R10_Snorm_Pack32;
 		na.m_relativeOffset = 0;
 		na.m_scale = 1.0f;
 
 		// Tangents
 		MeshBinaryVertexAttribute& ta = header.m_vertexAttributes[VertexAttributeId::TANGENT];
 		ta.m_bufferBinding = 1;
-		ta.m_format = Format::A2B10G10R10_SNORM_PACK32;
+		ta.m_format = Format::kA2B10G10R10_Snorm_Pack32;
 		ta.m_relativeOffset = sizeof(U32);
 		ta.m_scale = 1.0f;
 
 		// UVs
 		MeshBinaryVertexAttribute& uva = header.m_vertexAttributes[VertexAttributeId::UV0];
 		uva.m_bufferBinding = 1;
-		uva.m_format = Format::R32G32_SFLOAT;
+		uva.m_format = Format::kR32G32_Sfloat;
 		uva.m_relativeOffset = sizeof(U32) * 2;
 		uva.m_scale = 1.0f;
 
@@ -671,13 +671,13 @@ Error GltfImporter::writeMesh(const cgltf_mesh& mesh, U32 lod, F32 decimateFacto
 		{
 			MeshBinaryVertexAttribute& bidxa = header.m_vertexAttributes[VertexAttributeId::BONE_INDICES];
 			bidxa.m_bufferBinding = 2;
-			bidxa.m_format = Format::R8G8B8A8_UINT;
+			bidxa.m_format = Format::kR8G8B8A8_Uint;
 			bidxa.m_relativeOffset = 0;
 			bidxa.m_scale = 1.0f;
 
 			MeshBinaryVertexAttribute& wa = header.m_vertexAttributes[VertexAttributeId::BONE_WEIGHTS];
 			wa.m_bufferBinding = 2;
-			wa.m_format = Format::R8G8B8A8_UNORM;
+			wa.m_format = Format::kR8G8B8A8_Unorm;
 			wa.m_relativeOffset = sizeof(U8Vec4);
 			wa.m_scale = 1.0f;
 		}

AnKi/Input/Input.h

@@ -149,9 +149,9 @@ protected:
 	Vec2 m_mousePosNdc;
 	UVec2 m_mousePosWin;
 
-	Array<U32, U(TouchPointer::COUNT)> m_touchPointers;
-	Array<Vec2, U(TouchPointer::COUNT)> m_touchPointerPosNdc;
-	Array<UVec2, U(TouchPointer::COUNT)> m_touchPointerPosWin;
+	Array<U32, U(TouchPointer::kCount)> m_touchPointers;
+	Array<Vec2, U(TouchPointer::kCount)> m_touchPointerPosNdc;
+	Array<UVec2, U(TouchPointer::kCount)> m_touchPointerPosWin;
 
 	Array<U8, U(InputEvent::COUNT)> m_events;
 

AnKi/Input/KeyCode.h

@@ -298,8 +298,8 @@ enum class TouchPointer : U8
 	_14,
 	_15,
 
-	COUNT,
-	FIRST = _0
+	kCount,
+	kFirst = _0
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(TouchPointer)
 

AnKi/Renderer/Bloom.cpp

@@ -40,7 +40,7 @@ Error Bloom::initExposure()
 
 	// Create RT info
 	m_exposure.m_rtDescr =
-		m_r->create2DRenderTargetDescription(m_exposure.m_width, m_exposure.m_height, RT_PIXEL_FORMAT, "Bloom Exp");
+		m_r->create2DRenderTargetDescription(m_exposure.m_width, m_exposure.m_height, kRtPixelFormat, "Bloom Exp");
 	m_exposure.m_rtDescr.bake();
 
 	// init shaders
@@ -64,12 +64,12 @@ Error Bloom::initExposure()
 
 Error Bloom::initUpscale()
 {
-	m_upscale.m_width = m_r->getPostProcessResolution().x() / BLOOM_FRACTION;
-	m_upscale.m_height = m_r->getPostProcessResolution().y() / BLOOM_FRACTION;
+	m_upscale.m_width = m_r->getPostProcessResolution().x() / kBloomFraction;
+	m_upscale.m_height = m_r->getPostProcessResolution().y() / kBloomFraction;
 
 	// Create RT descr
 	m_upscale.m_rtDescr =
-		m_r->create2DRenderTargetDescription(m_upscale.m_width, m_upscale.m_height, RT_PIXEL_FORMAT, "Bloom Upscale");
+		m_r->create2DRenderTargetDescription(m_upscale.m_width, m_upscale.m_height, kRtPixelFormat, "Bloom Upscale");
 	m_upscale.m_rtDescr.bake();
 
 	// init shaders
@@ -114,9 +114,9 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 		{
 			ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("Bloom Main");
 
-			rpass.newDependency(RenderPassDependency(m_r->getDownscaleBlur().getRt(), TextureUsageBit::SAMPLED_COMPUTE,
+			rpass.newDependency(RenderPassDependency(m_r->getDownscaleBlur().getRt(), TextureUsageBit::kSampledCompute,
 													 inputTexSubresource));
-			rpass.newDependency(RenderPassDependency(m_runCtx.m_exposureRt, TextureUsageBit::IMAGE_COMPUTE_WRITE));
+			rpass.newDependency(RenderPassDependency(m_runCtx.m_exposureRt, TextureUsageBit::kImageComputeWrite));
 
 			prpass = &rpass;
 		}
@@ -125,10 +125,9 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 			GraphicsRenderPassDescription& rpass = rgraph.newGraphicsRenderPass("Bloom Main");
 			rpass.setFramebufferInfo(m_fbDescr, {m_runCtx.m_exposureRt});
 
-			rpass.newDependency(RenderPassDependency(m_r->getDownscaleBlur().getRt(), TextureUsageBit::SAMPLED_FRAGMENT,
+			rpass.newDependency(RenderPassDependency(m_r->getDownscaleBlur().getRt(), TextureUsageBit::kSampledFragment,
 													 inputTexSubresource));
-			rpass.newDependency(
-				RenderPassDependency(m_runCtx.m_exposureRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE));
+			rpass.newDependency(RenderPassDependency(m_runCtx.m_exposureRt, TextureUsageBit::kFramebufferWrite));
 
 			prpass = &rpass;
 		}
@@ -160,7 +159,7 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 			{
 				cmdb->setViewport(0, 0, m_exposure.m_width, m_exposure.m_height);
 
-				cmdb->drawArrays(PrimitiveTopology::TRIANGLES, 3);
+				cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
 			}
 		});
 	}
@@ -176,8 +175,8 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 		{
 			ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("Bloom Upscale");
 
-			rpass.newDependency({m_runCtx.m_exposureRt, TextureUsageBit::SAMPLED_COMPUTE});
-			rpass.newDependency({m_runCtx.m_upscaleRt, TextureUsageBit::IMAGE_COMPUTE_WRITE});
+			rpass.newDependency({m_runCtx.m_exposureRt, TextureUsageBit::kSampledCompute});
+			rpass.newDependency({m_runCtx.m_upscaleRt, TextureUsageBit::kImageComputeWrite});
 
 			prpass = &rpass;
 		}
@@ -186,8 +185,8 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 			GraphicsRenderPassDescription& rpass = rgraph.newGraphicsRenderPass("Bloom Upscale");
 			rpass.setFramebufferInfo(m_fbDescr, {m_runCtx.m_upscaleRt});
 
-			rpass.newDependency({m_runCtx.m_exposureRt, TextureUsageBit::SAMPLED_FRAGMENT});
-			rpass.newDependency({m_runCtx.m_upscaleRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
+			rpass.newDependency({m_runCtx.m_exposureRt, TextureUsageBit::kSampledFragment});
+			rpass.newDependency({m_runCtx.m_upscaleRt, TextureUsageBit::kFramebufferWrite});
 
 			prpass = &rpass;
 		}
@@ -211,7 +210,7 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 			{
 				cmdb->setViewport(0, 0, m_upscale.m_width, m_upscale.m_height);
 
-				cmdb->drawArrays(PrimitiveTopology::TRIANGLES, 3);
+				cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
 			}
 		});
 	}

AnKi/Renderer/Bloom.h

@@ -41,7 +41,7 @@ public:
 	}
 
 private:
-	static constexpr Format RT_PIXEL_FORMAT = Format::A2B10G10R10_UNORM_PACK32;
+	static constexpr Format kRtPixelFormat = Format::kA2B10G10R10_Unorm_Pack32;
 
 	const Array<U32, 2> m_workgroupSize = {16, 16};
 

AnKi/Renderer/Common.cpp

@@ -1,13 +0,0 @@
-// Copyright (C) 2009-2022, Panagiotis Christopoulos Charitos and contributors.
-// All rights reserved.
-// Code licensed under the BSD License.
-// http://www.anki3d.org/LICENSE
-
-#include <AnKi/Renderer/Common.h>
-
-namespace anki {
-
-const Array<Format, GBUFFER_COLOR_ATTACHMENT_COUNT> GBUFFER_COLOR_ATTACHMENT_PIXEL_FORMATS = {
-	{Format::R8G8B8A8_UNORM, Format::R8G8B8A8_UNORM, Format::A2B10G10R10_UNORM_PACK32, Format::R16G16_SNORM}};
-
-} // end namespace anki

AnKi/Renderer/Common.h

@@ -42,22 +42,16 @@ class ShaderProgramResourceVariant;
 /// @{
 
 /// Don't create second level command buffers if they contain more drawcalls than this constant.
-constexpr U32 MIN_DRAWCALLS_PER_2ND_LEVEL_COMMAND_BUFFER = 16;
+constexpr U32 kMinDrawcallsPerSecondaryCommandBuffer = 16;
 
-/// SSAO size is rendererSize/SSAO_FRACTION.
-constexpr U32 SSAO_FRACTION = 2;
-
-/// Bloom size is rendererSize/BLOOM_FRACTION.
-constexpr U32 BLOOM_FRACTION = 4;
-
-/// Volumetric size is rendererSize/VOLUMETRIC_FRACTION.
-constexpr U32 VOLUMETRIC_FRACTION = 4;
+/// Bloom size is rendererSize/kBloomFraction.
+constexpr U32 kBloomFraction = 4;
 
 /// Used to calculate the mipmap count of the HiZ map.
-constexpr U32 HIERARCHICAL_Z_MIN_HEIGHT = 80;
+constexpr U32 hHierachicalZMinHeight = 80;
 
-constexpr TextureSubresourceInfo HIZ_HALF_DEPTH(TextureSurfaceInfo(0, 0, 0, 0));
-constexpr TextureSubresourceInfo HIZ_QUARTER_DEPTH(TextureSurfaceInfo(1, 0, 0, 0));
+constexpr TextureSubresourceInfo kHiZHalfSurface(TextureSurfaceInfo(0, 0, 0, 0));
+constexpr TextureSubresourceInfo kHiZQuarterSurface(TextureSurfaceInfo(1, 0, 0, 0));
 
 constexpr U32 kMaxDebugRenderTargets = 2;
 
@@ -68,19 +62,13 @@ inline void computeLinearizeDepthOptimal(F32 near, F32 far, F32& a, F32& b)
 	b = far / near;
 }
 
-constexpr U32 GBUFFER_COLOR_ATTACHMENT_COUNT = 4;
-
-/// Downsample and blur down to a texture with size DOWNSCALE_BLUR_DOWN_TO
-constexpr U32 DOWNSCALE_BLUR_DOWN_TO = 32;
-
-/// Use this size of render target for the avg lum calculation.
-constexpr U32 AVERAGE_LUMINANCE_RENDER_TARGET_SIZE = 128;
-
-extern const Array<Format, GBUFFER_COLOR_ATTACHMENT_COUNT> GBUFFER_COLOR_ATTACHMENT_PIXEL_FORMATS;
+constexpr U32 kGBufferColorRenderTargetCount = 4;
 
-constexpr Format FORWARD_SHADING_COLOR_ATTACHMENT_PIXEL_FORMAT = Format::R16G16B16A16_SFLOAT;
+/// Downsample and blur down to a texture with size kDownscaleBurDownTo
+constexpr U32 kDownscaleBurDownTo = 32;
 
-constexpr Format DBG_COLOR_ATTACHMENT_PIXEL_FORMAT = Format::R8G8B8A8_UNORM;
+inline constexpr Array<Format, kGBufferColorRenderTargetCount> kGBufferColorRenderTargetFormats = {
+	{Format::kR8G8B8A8_Unorm, Format::kR8G8B8A8_Unorm, Format::kA2B10G10R10_Unorm_Pack32, Format::kR16G16_Snorm}};
 
 /// GPU buffers and textures that the clusterer refers to.
 class ClusteredShadingContext

AnKi/Renderer/Dbg.cpp

@@ -32,7 +32,7 @@ Error Dbg::init()
 
 	// RT descr
 	m_rtDescr = m_r->create2DRenderTargetDescription(m_r->getInternalResolution().x(), m_r->getInternalResolution().y(),
-													 DBG_COLOR_ATTACHMENT_PIXEL_FORMAT, "Dbg");
+													 Format::kR8G8B8A8_Unorm, "Dbg");
 	m_rtDescr.bake();
 
 	// Create FB descr
@@ -40,7 +40,7 @@ Error Dbg::init()
 	m_fbDescr.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::CLEAR;
 	m_fbDescr.m_depthStencilAttachment.m_loadOperation = AttachmentLoadOperation::LOAD;
 	m_fbDescr.m_depthStencilAttachment.m_stencilLoadOperation = AttachmentLoadOperation::DONT_CARE;
-	m_fbDescr.m_depthStencilAttachment.m_aspect = DepthStencilAspectBit::DEPTH;
+	m_fbDescr.m_depthStencilAttachment.m_aspect = DepthStencilAspectBit::kDepth;
 	m_fbDescr.bake();
 
 	return Error::NONE;
@@ -58,9 +58,9 @@ void Dbg::run(RenderPassWorkContext& rgraphCtx, const RenderingContext& ctx)
 
 	cmdb->bindSampler(0, 0, m_r->getSamplers().m_nearestNearestClamp);
 
-	rgraphCtx.bindTexture(0, 1, m_r->getGBuffer().getDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::DEPTH));
+	rgraphCtx.bindTexture(0, 1, m_r->getGBuffer().getDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
-	cmdb->setBlendFactors(0, BlendFactor::SRC_ALPHA, BlendFactor::ONE_MINUS_SRC_ALPHA);
+	cmdb->setBlendFactors(0, BlendFactor::kSrcAlpha, BlendFactor::kOneMinusSrcAlpha);
 
 	// Set the context
 	RenderQueueDrawContext dctx;
@@ -181,9 +181,9 @@ void Dbg::populateRenderGraph(RenderingContext& ctx)
 
 	pass.setFramebufferInfo(m_fbDescr, {m_runCtx.m_rt}, m_r->getGBuffer().getDepthRt());
 
-	pass.newDependency({m_runCtx.m_rt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
-	pass.newDependency({m_r->getGBuffer().getDepthRt(),
-						TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ});
+	pass.newDependency({m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite});
+	pass.newDependency(
+		{m_r->getGBuffer().getDepthRt(), TextureUsageBit::kSampledFragment | TextureUsageBit::kFramebufferRead});
 }
 
 } // end namespace anki

AnKi/Renderer/DepthDownscale.cpp

@@ -42,7 +42,7 @@ Error DepthDownscale::initInternal()
 	const U32 width = m_r->getInternalResolution().x() >> 1;
 	const U32 height = m_r->getInternalResolution().y() >> 1;
 
-	m_mipCount = computeMaxMipmapCount2d(width, height, HIERARCHICAL_Z_MIN_HEIGHT);
+	m_mipCount = computeMaxMipmapCount2d(width, height, hHierachicalZMinHeight);
 
 	m_lastMipSize.x() = width >> (m_mipCount - 1);
 	m_lastMipSize.y() = height >> (m_mipCount - 1);
@@ -55,19 +55,19 @@ Error DepthDownscale::initInternal()
 
 	// Create RT descr
 	{
-		TextureUsageBit usage = TextureUsageBit::ALL_SAMPLED;
+		TextureUsageBit usage = TextureUsageBit::kAllSampled;
 		if(preferCompute)
 		{
-			usage |= TextureUsageBit::IMAGE_COMPUTE_WRITE;
+			usage |= TextureUsageBit::kImageComputeWrite;
 		}
 		else
 		{
-			usage |= TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE;
+			usage |= TextureUsageBit::kFramebufferWrite;
 		}
 
-		TextureInitInfo texInit = m_r->create2DRenderTargetInitInfo(width, height, Format::R32_SFLOAT, usage, "HiZ");
+		TextureInitInfo texInit = m_r->create2DRenderTargetInitInfo(width, height, Format::kR32_Sfloat, usage, "HiZ");
 		texInit.m_mipmapCount = U8(m_mipCount);
-		m_hizTex = m_r->createAndClearRenderTarget(texInit, TextureUsageBit::SAMPLED_FRAGMENT);
+		m_hizTex = m_r->createAndClearRenderTarget(texInit, TextureUsageBit::kSampledFragment);
 	}
 
 	// Progs
@@ -130,9 +130,9 @@ Error DepthDownscale::initInternal()
 	if(!preferCompute && supportsReductionSampler)
 	{
 		SamplerInitInfo sinit("HiZReduction");
-		sinit.m_addressing = SamplingAddressing::CLAMP;
-		sinit.m_mipmapFilter = SamplingFilter::MAX;
-		sinit.m_minMagFilter = SamplingFilter::MAX;
+		sinit.m_addressing = SamplingAddressing::kClamp;
+		sinit.m_mipmapFilter = SamplingFilter::kMax;
+		sinit.m_minMagFilter = SamplingFilter::kMax;
 		m_reductionSampler = getGrManager().newSampler(sinit);
 	}
 
@@ -173,7 +173,7 @@ void DepthDownscale::importRenderTargets(RenderingContext& ctx)
 	}
 	else
 	{
-		m_runCtx.m_hizRt = rgraph.importRenderTarget(m_hizTex, TextureUsageBit::SAMPLED_FRAGMENT);
+		m_runCtx.m_hizRt = rgraph.importRenderTarget(m_hizTex, TextureUsageBit::kSampledFragment);
 		m_hizTexImportedOnce = true;
 	}
 }
@@ -188,15 +188,15 @@ void DepthDownscale::populateRenderGraph(RenderingContext& ctx)
 
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("HiZ");
 
-		pass.newDependency(RenderPassDependency(m_r->getGBuffer().getDepthRt(), TextureUsageBit::SAMPLED_COMPUTE,
-												TextureSubresourceInfo(DepthStencilAspectBit::DEPTH)));
+		pass.newDependency(RenderPassDependency(m_r->getGBuffer().getDepthRt(), TextureUsageBit::kSampledCompute,
+												TextureSubresourceInfo(DepthStencilAspectBit::kDepth)));
 
 		for(U32 mip = 0; mip < m_mipCount; ++mip)
 		{
 			TextureSubresourceInfo subresource;
 			subresource.m_firstMipmap = mip;
 			pass.newDependency(
-				RenderPassDependency(m_runCtx.m_hizRt, TextureUsageBit::IMAGE_COMPUTE_WRITE, subresource));
+				RenderPassDependency(m_runCtx.m_hizRt, TextureUsageBit::kImageComputeWrite, subresource));
 		}
 
 		pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
@@ -217,21 +217,20 @@ void DepthDownscale::populateRenderGraph(RenderingContext& ctx)
 			if(mip == 0)
 			{
 				pass.newDependency(RenderPassDependency(m_r->getGBuffer().getDepthRt(),
-														TextureUsageBit::SAMPLED_FRAGMENT,
-														TextureSubresourceInfo(DepthStencilAspectBit::DEPTH)));
+														TextureUsageBit::kSampledFragment,
+														TextureSubresourceInfo(DepthStencilAspectBit::kDepth)));
 			}
 			else
 			{
 				TextureSurfaceInfo subresource;
 				subresource.m_level = mip - 1;
 				pass.newDependency(
-					RenderPassDependency(m_runCtx.m_hizRt, TextureUsageBit::SAMPLED_FRAGMENT, subresource));
+					RenderPassDependency(m_runCtx.m_hizRt, TextureUsageBit::kSampledFragment, subresource));
 			}
 
 			TextureSurfaceInfo subresource;
 			subresource.m_level = mip;
-			pass.newDependency(
-				RenderPassDependency(m_runCtx.m_hizRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE, subresource));
+			pass.newDependency(RenderPassDependency(m_runCtx.m_hizRt, TextureUsageBit::kFramebufferWrite, subresource));
 
 			pass.setWork([this, mip](RenderPassWorkContext& rgraphCtx) {
 				runGraphics(mip, rgraphCtx);
@@ -307,7 +306,7 @@ void DepthDownscale::runCompute(RenderPassWorkContext& rgraphCtx)
 	cmdb->bindStorageBuffer(0, 3, m_clientBuffer, 0, MAX_PTR_SIZE);
 
 	cmdb->bindSampler(0, 4, m_r->getSamplers().m_trilinearClamp);
-	rgraphCtx.bindTexture(0, 5, m_r->getGBuffer().getDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::DEPTH));
+	rgraphCtx.bindTexture(0, 5, m_r->getGBuffer().getDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
 	cmdb->dispatchCompute(dispatchThreadGroupCountXY[0], dispatchThreadGroupCountXY[1], 1);
 }
@@ -319,7 +318,7 @@ void DepthDownscale::runGraphics(U32 mip, RenderPassWorkContext& rgraphCtx)
 	if(mip == 0)
 	{
 		rgraphCtx.bindTexture(0, 0, m_r->getGBuffer().getDepthRt(),
-							  TextureSubresourceInfo(DepthStencilAspectBit::DEPTH));
+							  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
 		cmdb->bindSampler(0, 1, m_r->getSamplers().m_trilinearClamp);
 
@@ -350,7 +349,7 @@ void DepthDownscale::runGraphics(U32 mip, RenderPassWorkContext& rgraphCtx)
 
 	const UVec2 size = (m_r->getInternalResolution() / 2) >> mip;
 	cmdb->setViewport(0, 0, size.x(), size.y());
-	cmdb->drawArrays(PrimitiveTopology::TRIANGLES, 3);
+	cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
 }
 
 } // end namespace anki

AnKi/Renderer/DownscaleBlur.cpp

@@ -30,7 +30,7 @@ Error DownscaleBlur::init()
 Error DownscaleBlur::initInternal()
 {
 	m_passCount = computeMaxMipmapCount2d(m_r->getPostProcessResolution().x(), m_r->getPostProcessResolution().y(),
-										  DOWNSCALE_BLUR_DOWN_TO)
+										  kDownscaleBurDownTo)
 				  - 1;
 
 	const UVec2 rez = m_r->getPostProcessResolution() / 2;
@@ -41,17 +41,17 @@ Error DownscaleBlur::initInternal()
 	// Create the miped texture
 	TextureInitInfo texinit =
 		m_r->create2DRenderTargetDescription(rez.x(), rez.y(), m_r->getHdrFormat(), "DownscaleBlur");
-	texinit.m_usage = TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::SAMPLED_COMPUTE;
+	texinit.m_usage = TextureUsageBit::kSampledFragment | TextureUsageBit::kSampledCompute;
 	if(preferCompute)
 	{
-		texinit.m_usage |= TextureUsageBit::SAMPLED_COMPUTE | TextureUsageBit::IMAGE_COMPUTE_WRITE;
+		texinit.m_usage |= TextureUsageBit::kSampledCompute | TextureUsageBit::kImageComputeWrite;
 	}
 	else
 	{
-		texinit.m_usage |= TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE;
+		texinit.m_usage |= TextureUsageBit::kFramebufferWrite;
 	}
 	texinit.m_mipmapCount = U8(m_passCount);
-	m_rtTex = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::SAMPLED_COMPUTE);
+	m_rtTex = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::kSampledCompute);
 
 	// FB descr
 	if(!preferCompute)
@@ -79,7 +79,7 @@ Error DownscaleBlur::initInternal()
 void DownscaleBlur::importRenderTargets(RenderingContext& ctx)
 {
 	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
-	m_runCtx.m_rt = rgraph.importRenderTarget(m_rtTex, TextureUsageBit::SAMPLED_COMPUTE);
+	m_runCtx.m_rt = rgraph.importRenderTarget(m_rtTex, TextureUsageBit::kSampledCompute);
 }
 
 void DownscaleBlur::populateRenderGraph(RenderingContext& ctx)
@@ -109,17 +109,17 @@ void DownscaleBlur::populateRenderGraph(RenderingContext& ctx)
 				renderSubresource.m_firstMipmap = i;
 
 				pass.newDependency(
-					RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::IMAGE_COMPUTE_WRITE, renderSubresource));
+					RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::kImageComputeWrite, renderSubresource));
 				pass.newDependency(
-					RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::SAMPLED_COMPUTE, sampleSubresource));
+					RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::kSampledCompute, sampleSubresource));
 			}
 			else
 			{
 				TextureSubresourceInfo renderSubresource;
 
 				pass.newDependency(
-					RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::IMAGE_COMPUTE_WRITE, renderSubresource));
-				pass.newDependency(RenderPassDependency(inRt, TextureUsageBit::SAMPLED_COMPUTE));
+					RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::kImageComputeWrite, renderSubresource));
+				pass.newDependency(RenderPassDependency(inRt, TextureUsageBit::kSampledCompute));
 			}
 		}
 	}
@@ -141,18 +141,18 @@ void DownscaleBlur::populateRenderGraph(RenderingContext& ctx)
 				sampleSubresource.m_firstMipmap = i - 1;
 				renderSubresource.m_firstMipmap = i;
 
-				pass.newDependency(RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
-														renderSubresource));
 				pass.newDependency(
-					RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::SAMPLED_FRAGMENT, sampleSubresource));
+					RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite, renderSubresource));
+				pass.newDependency(
+					RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::kSampledFragment, sampleSubresource));
 			}
 			else
 			{
 				TextureSubresourceInfo renderSubresource;
 
-				pass.newDependency(RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
-														renderSubresource));
-				pass.newDependency(RenderPassDependency(inRt, TextureUsageBit::SAMPLED_FRAGMENT));
+				pass.newDependency(
+					RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite, renderSubresource));
+				pass.newDependency(RenderPassDependency(inRt, TextureUsageBit::kSampledFragment));
 			}
 		}
 	}
@@ -200,7 +200,7 @@ void DownscaleBlur::run(U32 passIdx, RenderPassWorkContext& rgraphCtx)
 	{
 		cmdb->setViewport(0, 0, vpWidth, vpHeight);
 
-		cmdb->drawArrays(PrimitiveTopology::TRIANGLES, 3);
+		cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
 	}
 }
 

AnKi/Renderer/FinalComposite.cpp

@@ -98,18 +98,18 @@ void FinalComposite::populateRenderGraph(RenderingContext& ctx)
 	});
 	pass.setFramebufferInfo(m_fbDescr, {ctx.m_outRenderTarget});
 
-	pass.newDependency(RenderPassDependency(ctx.m_outRenderTarget, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE));
+	pass.newDependency(RenderPassDependency(ctx.m_outRenderTarget, TextureUsageBit::kFramebufferWrite));
 
 	if(getConfig().getRDbgEnabled())
 	{
-		pass.newDependency(RenderPassDependency(m_r->getDbg().getRt(), TextureUsageBit::SAMPLED_FRAGMENT));
+		pass.newDependency(RenderPassDependency(m_r->getDbg().getRt(), TextureUsageBit::kSampledFragment));
 	}
 
-	pass.newDependency(RenderPassDependency(m_r->getScale().getTonemappedRt(), TextureUsageBit::SAMPLED_FRAGMENT));
-	pass.newDependency(RenderPassDependency(m_r->getBloom().getRt(), TextureUsageBit::SAMPLED_FRAGMENT));
+	pass.newDependency(RenderPassDependency(m_r->getScale().getTonemappedRt(), TextureUsageBit::kSampledFragment));
+	pass.newDependency(RenderPassDependency(m_r->getBloom().getRt(), TextureUsageBit::kSampledFragment));
 	pass.newDependency(
-		RenderPassDependency(m_r->getMotionVectors().getMotionVectorsRt(), TextureUsageBit::SAMPLED_FRAGMENT));
-	pass.newDependency(RenderPassDependency(m_r->getGBuffer().getDepthRt(), TextureUsageBit::SAMPLED_FRAGMENT));
+		RenderPassDependency(m_r->getMotionVectors().getMotionVectorsRt(), TextureUsageBit::kSampledFragment));
+	pass.newDependency(RenderPassDependency(m_r->getGBuffer().getDepthRt(), TextureUsageBit::kSampledFragment));
 
 	Array<RenderTargetHandle, kMaxDebugRenderTargets> dbgRts;
 	ShaderProgramPtr debugProgram;
@@ -120,7 +120,7 @@ void FinalComposite::populateRenderGraph(RenderingContext& ctx)
 		{
 			if(handle.isValid())
 			{
-				pass.newDependency(RenderPassDependency(handle, TextureUsageBit::SAMPLED_FRAGMENT));
+				pass.newDependency(RenderPassDependency(handle, TextureUsageBit::kSampledFragment));
 			}
 		}
 	}
@@ -162,7 +162,7 @@ void FinalComposite::run(RenderingContext& ctx, RenderPassWorkContext& rgraphCtx
 		cmdb->bindTexture(0, 5, m_lut->getTextureView());
 		rgraphCtx.bindColorTexture(0, 6, m_r->getMotionVectors().getMotionVectorsRt());
 		rgraphCtx.bindTexture(0, 7, m_r->getGBuffer().getDepthRt(),
-							  TextureSubresourceInfo(DepthStencilAspectBit::DEPTH));
+							  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
 		if(dbgEnabled)
 		{

AnKi/Renderer/ForwardShading.cpp

@@ -32,13 +32,13 @@ void ForwardShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgr
 	if(start != end)
 	{
 		cmdb->setDepthWrite(false);
-		cmdb->setBlendFactors(0, BlendFactor::SRC_ALPHA, BlendFactor::ONE_MINUS_SRC_ALPHA);
+		cmdb->setBlendFactors(0, BlendFactor::kSrcAlpha, BlendFactor::kOneMinusSrcAlpha);
 
 		const ClusteredShadingContext& rsrc = ctx.m_clusteredShading;
 		const U32 set = MATERIAL_SET_GLOBAL;
 		cmdb->bindSampler(set, MATERIAL_BINDING_LINEAR_CLAMP_SAMPLER, m_r->getSamplers().m_trilinearClamp);
 
-		rgraphCtx.bindTexture(set, MATERIAL_BINDING_DEPTH_RT, m_r->getDepthDownscale().getHiZRt(), HIZ_HALF_DEPTH);
+		rgraphCtx.bindTexture(set, MATERIAL_BINDING_DEPTH_RT, m_r->getDepthDownscale().getHiZRt(), kHiZHalfSurface);
 		rgraphCtx.bindColorTexture(set, MATERIAL_BINDING_LIGHT_VOLUME,
 								   m_r->getVolumetricLightingAccumulation().getRt());
 
@@ -63,7 +63,7 @@ void ForwardShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgr
 
 		// Restore state
 		cmdb->setDepthWrite(true);
-		cmdb->setBlendFactors(0, BlendFactor::ONE, BlendFactor::ZERO);
+		cmdb->setBlendFactors(0, BlendFactor::kOne, BlendFactor::kZero);
 	}
 
 	if(threadId == threadCount - 1 && ctx.m_renderQueue->m_lensFlares.getSize())
@@ -74,8 +74,8 @@ void ForwardShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgr
 
 void ForwardShading::setDependencies(const RenderingContext& ctx, GraphicsRenderPassDescription& pass)
 {
-	pass.newDependency({m_r->getDepthDownscale().getHiZRt(), TextureUsageBit::SAMPLED_FRAGMENT, HIZ_HALF_DEPTH});
-	pass.newDependency({m_r->getVolumetricLightingAccumulation().getRt(), TextureUsageBit::SAMPLED_FRAGMENT});
+	pass.newDependency({m_r->getDepthDownscale().getHiZRt(), TextureUsageBit::kSampledFragment, kHiZHalfSurface});
+	pass.newDependency({m_r->getVolumetricLightingAccumulation().getRt(), TextureUsageBit::kSampledFragment});
 
 	if(ctx.m_renderQueue->m_lensFlares.getSize())
 	{

AnKi/Renderer/GBuffer.cpp

@@ -38,21 +38,21 @@ Error GBuffer::initInternal()
 	static constexpr Array<const char*, 2> depthRtNames = {{"GBuffer depth #0", "GBuffer depth #1"}};
 	for(U32 i = 0; i < 2; ++i)
 	{
-		const TextureUsageBit usage = TextureUsageBit::ALL_SAMPLED | TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT;
+		const TextureUsageBit usage = TextureUsageBit::kAllSampled | TextureUsageBit::kAllFramebuffer;
 		TextureInitInfo texinit =
 			m_r->create2DRenderTargetInitInfo(m_r->getInternalResolution().x(), m_r->getInternalResolution().y(),
 											  m_r->getDepthNoStencilFormat(), usage, depthRtNames[i]);
 
-		m_depthRts[i] = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::SAMPLED_FRAGMENT);
+		m_depthRts[i] = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
 	}
 
-	static constexpr Array<const char*, GBUFFER_COLOR_ATTACHMENT_COUNT> rtNames = {
+	static constexpr Array<const char*, kGBufferColorRenderTargetCount> rtNames = {
 		{"GBuffer rt0", "GBuffer rt1", "GBuffer rt2", "GBuffer rt3"}};
-	for(U i = 0; i < GBUFFER_COLOR_ATTACHMENT_COUNT; ++i)
+	for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 	{
 		m_colorRtDescrs[i] =
 			m_r->create2DRenderTargetDescription(m_r->getInternalResolution().x(), m_r->getInternalResolution().y(),
-												 GBUFFER_COLOR_ATTACHMENT_PIXEL_FORMATS[i], rtNames[i]);
+												 kGBufferColorRenderTargetFormats[i], rtNames[i]);
 		m_colorRtDescrs[i].bake();
 	}
 
@@ -62,8 +62,8 @@ Error GBuffer::initInternal()
 	loadop = AttachmentLoadOperation::CLEAR;
 #endif
 
-	m_fbDescr.m_colorAttachmentCount = GBUFFER_COLOR_ATTACHMENT_COUNT;
-	for(U i = 0; i < GBUFFER_COLOR_ATTACHMENT_COUNT; ++i)
+	m_fbDescr.m_colorAttachmentCount = kGBufferColorRenderTargetCount;
+	for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 	{
 		m_fbDescr.m_colorAttachments[i].m_loadOperation = loadop;
 		m_fbDescr.m_colorAttachments[i].m_clearValue.m_colorf = {1.0f, 0.0f, 1.0f, 0.0f};
@@ -74,7 +74,7 @@ Error GBuffer::initInternal()
 
 	m_fbDescr.m_depthStencilAttachment.m_loadOperation = AttachmentLoadOperation::CLEAR;
 	m_fbDescr.m_depthStencilAttachment.m_clearValue.m_depthStencil.m_depth = 1.0f;
-	m_fbDescr.m_depthStencilAttachment.m_aspect = DepthStencilAspectBit::DEPTH;
+	m_fbDescr.m_depthStencilAttachment.m_aspect = DepthStencilAspectBit::kDepth;
 
 	if(getGrManager().getDeviceCapabilities().m_vrs && getConfig().getRVrs())
 	{
@@ -130,9 +130,9 @@ void GBuffer::runInThread(const RenderingContext& ctx, RenderPassWorkContext& rg
 	// First do early Z (if needed)
 	if(earlyZStart < earlyZEnd)
 	{
-		for(U32 i = 0; i < GBUFFER_COLOR_ATTACHMENT_COUNT; ++i)
+		for(U32 i = 0; i < kGBufferColorRenderTargetCount; ++i)
 		{
-			cmdb->setColorChannelWriteMask(i, ColorBit::NONE);
+			cmdb->setColorChannelWriteMask(i, ColorBit::kNone);
 		}
 
 		ANKI_ASSERT(earlyZStart < earlyZEnd && earlyZEnd <= I32(earlyZCount));
@@ -143,9 +143,9 @@ void GBuffer::runInThread(const RenderingContext& ctx, RenderPassWorkContext& rg
 		// Restore state for the color write
 		if(colorStart < colorEnd)
 		{
-			for(U32 i = 0; i < GBUFFER_COLOR_ATTACHMENT_COUNT; ++i)
+			for(U32 i = 0; i < kGBufferColorRenderTargetCount; ++i)
 			{
-				cmdb->setColorChannelWriteMask(i, ColorBit::ALL);
+				cmdb->setColorChannelWriteMask(i, ColorBit::kAll);
 			}
 		}
 	}
@@ -153,7 +153,7 @@ void GBuffer::runInThread(const RenderingContext& ctx, RenderPassWorkContext& rg
 	// Do the color writes
 	if(colorStart < colorEnd)
 	{
-		cmdb->setDepthCompareOperation(CompareOperation::LESS_EQUAL);
+		cmdb->setDepthCompareOperation(CompareOperation::kLessEqual);
 
 		ANKI_ASSERT(colorStart < colorEnd && colorEnd <= I32(ctx.m_renderQueue->m_renderables.getSize()));
 		m_r->getSceneDrawer().drawRange(RenderingTechnique::GBUFFER, args,
@@ -192,7 +192,7 @@ void GBuffer::populateRenderGraph(RenderingContext& ctx)
 
 	// Create RTs
 	Array<RenderTargetHandle, MAX_COLOR_ATTACHMENTS> rts;
-	for(U i = 0; i < GBUFFER_COLOR_ATTACHMENT_COUNT; ++i)
+	for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 	{
 		m_runCtx.m_colorRts[i] = rgraph.newRenderTarget(m_colorRtDescrs[i]);
 		rts[i] = m_runCtx.m_colorRts[i];
@@ -202,15 +202,15 @@ void GBuffer::populateRenderGraph(RenderingContext& ctx)
 	{
 		// Already imported once
 		m_runCtx.m_crntFrameDepthRt =
-			rgraph.importRenderTarget(m_depthRts[m_r->getFrameCount() & 1], TextureUsageBit::NONE);
+			rgraph.importRenderTarget(m_depthRts[m_r->getFrameCount() & 1], TextureUsageBit::kNone);
 		m_runCtx.m_prevFrameDepthRt = rgraph.importRenderTarget(m_depthRts[(m_r->getFrameCount() + 1) & 1]);
 	}
 	else
 	{
 		m_runCtx.m_crntFrameDepthRt =
-			rgraph.importRenderTarget(m_depthRts[m_r->getFrameCount() & 1], TextureUsageBit::NONE);
+			rgraph.importRenderTarget(m_depthRts[m_r->getFrameCount() & 1], TextureUsageBit::kNone);
 		m_runCtx.m_prevFrameDepthRt =
-			rgraph.importRenderTarget(m_depthRts[(m_r->getFrameCount() + 1) & 1], TextureUsageBit::SAMPLED_FRAGMENT);
+			rgraph.importRenderTarget(m_depthRts[(m_r->getFrameCount() + 1) & 1], TextureUsageBit::kSampledFragment);
 	}
 
 	RenderTargetHandle sriRt;
@@ -222,7 +222,7 @@ void GBuffer::populateRenderGraph(RenderingContext& ctx)
 	// Create pass
 	GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass("GBuffer");
 
-	pass.setFramebufferInfo(m_fbDescr, ConstWeakArray<RenderTargetHandle>(&rts[0], GBUFFER_COLOR_ATTACHMENT_COUNT),
+	pass.setFramebufferInfo(m_fbDescr, ConstWeakArray<RenderTargetHandle>(&rts[0], kGBufferColorRenderTargetCount),
 							m_runCtx.m_crntFrameDepthRt, sriRt);
 	pass.setWork(computeNumberOfSecondLevelCommandBuffers(ctx.m_renderQueue->m_earlyZRenderables.getSize()
 														  + ctx.m_renderQueue->m_renderables.getSize()),
@@ -230,18 +230,18 @@ void GBuffer::populateRenderGraph(RenderingContext& ctx)
 					 runInThread(ctx, rgraphCtx);
 				 });
 
-	for(U i = 0; i < GBUFFER_COLOR_ATTACHMENT_COUNT; ++i)
+	for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 	{
-		pass.newDependency(RenderPassDependency(m_runCtx.m_colorRts[i], TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE));
+		pass.newDependency(RenderPassDependency(m_runCtx.m_colorRts[i], TextureUsageBit::kFramebufferWrite));
 	}
 
-	TextureSubresourceInfo subresource(DepthStencilAspectBit::DEPTH);
+	TextureSubresourceInfo subresource(DepthStencilAspectBit::kDepth);
 	pass.newDependency(
-		RenderPassDependency(m_runCtx.m_crntFrameDepthRt, TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT, subresource));
+		RenderPassDependency(m_runCtx.m_crntFrameDepthRt, TextureUsageBit::kAllFramebuffer, subresource));
 
 	if(enableVrs)
 	{
-		pass.newDependency(RenderPassDependency(sriRt, TextureUsageBit::FRAMEBUFFER_SHADING_RATE));
+		pass.newDependency(RenderPassDependency(sriRt, TextureUsageBit::kFramebufferShadingRate));
 	}
 }
 

AnKi/Renderer/GBuffer.h

@@ -69,14 +69,14 @@ public:
 	}
 
 private:
-	Array<RenderTargetDescription, GBUFFER_COLOR_ATTACHMENT_COUNT> m_colorRtDescrs;
+	Array<RenderTargetDescription, kGBufferColorRenderTargetCount> m_colorRtDescrs;
 	Array<TexturePtr, 2> m_depthRts;
 	FramebufferDescription m_fbDescr;
 
 	class
 	{
 	public:
-		Array<RenderTargetHandle, GBUFFER_COLOR_ATTACHMENT_COUNT> m_colorRts;
+		Array<RenderTargetHandle, kGBufferColorRenderTargetCount> m_colorRts;
 		RenderTargetHandle m_crntFrameDepthRt;
 		RenderTargetHandle m_prevFrameDepthRt;
 	} m_runCtx;

AnKi/Renderer/GBufferPost.cpp

@@ -68,12 +68,10 @@ void GBufferPost::populateRenderGraph(RenderingContext& ctx)
 
 	rpass.setFramebufferInfo(m_fbDescr, {m_r->getGBuffer().getColorRt(0), m_r->getGBuffer().getColorRt(1)});
 
-	rpass.newDependency(
-		RenderPassDependency(m_r->getGBuffer().getColorRt(0), TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT));
-	rpass.newDependency(
-		RenderPassDependency(m_r->getGBuffer().getColorRt(1), TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT));
-	rpass.newDependency(RenderPassDependency(m_r->getGBuffer().getDepthRt(), TextureUsageBit::SAMPLED_FRAGMENT,
-											 TextureSubresourceInfo(DepthStencilAspectBit::DEPTH)));
+	rpass.newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(0), TextureUsageBit::kAllFramebuffer));
+	rpass.newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(1), TextureUsageBit::kAllFramebuffer));
+	rpass.newDependency(RenderPassDependency(m_r->getGBuffer().getDepthRt(), TextureUsageBit::kSampledFragment,
+											 TextureSubresourceInfo(DepthStencilAspectBit::kDepth)));
 	rpass.newDependency(
 		RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::STORAGE_FRAGMENT_READ));
 }
@@ -86,13 +84,13 @@ void GBufferPost::run(const RenderingContext& ctx, RenderPassWorkContext& rgraph
 	cmdb->setViewport(0, 0, m_r->getInternalResolution().x(), m_r->getInternalResolution().y());
 	cmdb->bindShaderProgram(m_grProg);
 
-	cmdb->setBlendFactors(0, BlendFactor::ONE, BlendFactor::SRC_ALPHA, BlendFactor::ZERO, BlendFactor::ONE);
-	cmdb->setBlendFactors(1, BlendFactor::ONE, BlendFactor::SRC_ALPHA, BlendFactor::ZERO, BlendFactor::ONE);
+	cmdb->setBlendFactors(0, BlendFactor::kOne, BlendFactor::kSrcAlpha, BlendFactor::kZero, BlendFactor::kOne);
+	cmdb->setBlendFactors(1, BlendFactor::kOne, BlendFactor::kSrcAlpha, BlendFactor::kZero, BlendFactor::kOne);
 
 	// Bind all
 	cmdb->bindSampler(0, 0, m_r->getSamplers().m_nearestNearestClamp);
 
-	rgraphCtx.bindTexture(0, 1, m_r->getGBuffer().getDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::DEPTH));
+	rgraphCtx.bindTexture(0, 1, m_r->getGBuffer().getDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
 	cmdb->bindSampler(0, 2, m_r->getSamplers().m_trilinearRepeat);
 
@@ -108,11 +106,11 @@ void GBufferPost::run(const RenderingContext& ctx, RenderPassWorkContext& rgraph
 	bindStorage(cmdb, 0, 7, rsrc.m_clustersToken);
 
 	// Draw
-	cmdb->drawArrays(PrimitiveTopology::TRIANGLES, 3);
+	cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
 
 	// Restore state
-	cmdb->setBlendFactors(0, BlendFactor::ONE, BlendFactor::ZERO);
-	cmdb->setBlendFactors(1, BlendFactor::ONE, BlendFactor::ZERO);
+	cmdb->setBlendFactors(0, BlendFactor::kOne, BlendFactor::kZero);
+	cmdb->setBlendFactors(1, BlendFactor::kOne, BlendFactor::kZero);
 }
 
 } // end namespace anki

AnKi/Renderer/GenericCompute.cpp

@@ -27,7 +27,7 @@ void GenericCompute::populateRenderGraph(RenderingContext& ctx)
 		run(ctx, rgraphCtx);
 	});
 
-	pass.newDependency({m_r->getDepthDownscale().getHiZRt(), TextureUsageBit::SAMPLED_COMPUTE});
+	pass.newDependency({m_r->getDepthDownscale().getHiZRt(), TextureUsageBit::kSampledCompute});
 }
 
 void GenericCompute::run(const RenderingContext& ctx, RenderPassWorkContext& rgraphCtx)

AnKi/Renderer/IndirectDiffuse.cpp

@@ -38,14 +38,14 @@ Error IndirectDiffuse::initInternal()
 	const Bool preferCompute = getConfig().getRPreferCompute();
 
 	// Init textures
-	TextureUsageBit usage = TextureUsageBit::ALL_SAMPLED;
+	TextureUsageBit usage = TextureUsageBit::kAllSampled;
 
-	usage |= (preferCompute) ? TextureUsageBit::IMAGE_COMPUTE_WRITE : TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE;
+	usage |= (preferCompute) ? TextureUsageBit::kImageComputeWrite : TextureUsageBit::kFramebufferWrite;
 	TextureInitInfo texInit =
 		m_r->create2DRenderTargetInitInfo(size.x(), size.y(), m_r->getHdrFormat(), usage, "IndirectDiffuse #1");
-	m_rts[0] = m_r->createAndClearRenderTarget(texInit, TextureUsageBit::ALL_SAMPLED);
+	m_rts[0] = m_r->createAndClearRenderTarget(texInit, TextureUsageBit::kAllSampled);
 	texInit.setName("IndirectDiffuse #2");
-	m_rts[1] = m_r->createAndClearRenderTarget(texInit, TextureUsageBit::ALL_SAMPLED);
+	m_rts[1] = m_r->createAndClearRenderTarget(texInit, TextureUsageBit::kAllSampled);
 
 	if(!preferCompute)
 	{
@@ -62,7 +62,7 @@ Error IndirectDiffuse::initInternal()
 
 		const UVec2 rez = (size + m_vrs.m_sriTexelDimension - 1) / m_vrs.m_sriTexelDimension;
 		m_vrs.m_rtHandle =
-			m_r->create2DRenderTargetDescription(rez.x(), rez.y(), Format::R8_UINT, "IndirectDiffuseVrsSri");
+			m_r->create2DRenderTargetDescription(rez.x(), rez.y(), Format::kR8_Uint, "IndirectDiffuseVrsSri");
 		m_vrs.m_rtHandle.bake();
 
 		ANKI_CHECK(getResourceManager().loadResource("ShaderBinaries/IndirectDiffuseVrsSriGeneration.ankiprogbin",
@@ -168,9 +168,9 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("IndirectDiffuse VRS SRI gen");
 
-		pass.newDependency(RenderPassDependency(m_runCtx.m_sriRt, TextureUsageBit::IMAGE_COMPUTE_WRITE));
-		pass.newDependency(RenderPassDependency(m_r->getDepthDownscale().getHiZRt(), TextureUsageBit::SAMPLED_COMPUTE,
-												HIZ_HALF_DEPTH));
+		pass.newDependency(RenderPassDependency(m_runCtx.m_sriRt, TextureUsageBit::kImageComputeWrite));
+		pass.newDependency(RenderPassDependency(m_r->getDepthDownscale().getHiZRt(), TextureUsageBit::kSampledCompute,
+												kHiZHalfSurface));
 
 		pass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
 			const UVec2 viewport = m_r->getInternalResolution() / 2u;
@@ -179,7 +179,7 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 
 			cmdb->bindShaderProgram(m_vrs.m_grProg);
 
-			rgraphCtx.bindTexture(0, 0, m_r->getDepthDownscale().getHiZRt(), HIZ_HALF_DEPTH);
+			rgraphCtx.bindTexture(0, 0, m_r->getDepthDownscale().getHiZRt(), kHiZHalfSurface);
 			cmdb->bindSampler(0, 1, m_r->getSamplers().m_nearestNearestClamp);
 			rgraphCtx.bindImage(0, 2, m_runCtx.m_sriRt);
 
@@ -211,8 +211,8 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 		}
 		else
 		{
-			m_runCtx.m_mainRtHandles[0] = rgraph.importRenderTarget(m_rts[readRtIdx], TextureUsageBit::ALL_SAMPLED);
-			m_runCtx.m_mainRtHandles[1] = rgraph.importRenderTarget(m_rts[writeRtIdx], TextureUsageBit::ALL_SAMPLED);
+			m_runCtx.m_mainRtHandles[0] = rgraph.importRenderTarget(m_rts[readRtIdx], TextureUsageBit::kAllSampled);
+			m_runCtx.m_mainRtHandles[1] = rgraph.importRenderTarget(m_rts[writeRtIdx], TextureUsageBit::kAllSampled);
 			m_rtsImportedOnce = true;
 		}
 
@@ -223,8 +223,8 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 		if(preferCompute)
 		{
 			ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("IndirectDiffuse");
-			readUsage = TextureUsageBit::SAMPLED_COMPUTE;
-			writeUsage = TextureUsageBit::IMAGE_COMPUTE_WRITE;
+			readUsage = TextureUsageBit::kSampledCompute;
+			writeUsage = TextureUsageBit::kImageComputeWrite;
 			prpass = &rpass;
 		}
 		else
@@ -232,14 +232,13 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 			GraphicsRenderPassDescription& rpass = rgraph.newGraphicsRenderPass("IndirectDiffuse");
 			rpass.setFramebufferInfo(m_main.m_fbDescr, {m_runCtx.m_mainRtHandles[WRITE]}, {},
 									 (enableVrs) ? m_runCtx.m_sriRt : RenderTargetHandle());
-			readUsage = TextureUsageBit::SAMPLED_FRAGMENT;
-			writeUsage = TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE;
+			readUsage = TextureUsageBit::kSampledFragment;
+			writeUsage = TextureUsageBit::kFramebufferWrite;
 			prpass = &rpass;
 
 			if(enableVrs)
 			{
-				prpass->newDependency(
-					RenderPassDependency(m_runCtx.m_sriRt, TextureUsageBit::FRAMEBUFFER_SHADING_RATE));
+				prpass->newDependency(RenderPassDependency(m_runCtx.m_sriRt, TextureUsageBit::kFramebufferShadingRate));
 			}
 		}
 
@@ -307,7 +306,7 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 					cmdb->setVrsRate(VrsRate::_1x1);
 				}
 
-				cmdb->drawArrays(PrimitiveTopology::TRIANGLES, 3);
+				cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
 			}
 		});
 	}
@@ -324,8 +323,8 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 		{
 			ComputeRenderPassDescription& rpass =
 				rgraph.newComputeRenderPass((dir == 0) ? "IndirectDiffuseDenoiseH" : "IndirectDiffuseDenoiseV");
-			readUsage = TextureUsageBit::SAMPLED_COMPUTE;
-			writeUsage = TextureUsageBit::IMAGE_COMPUTE_WRITE;
+			readUsage = TextureUsageBit::kSampledCompute;
+			writeUsage = TextureUsageBit::kImageComputeWrite;
 			prpass = &rpass;
 		}
 		else
@@ -333,8 +332,8 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 			GraphicsRenderPassDescription& rpass =
 				rgraph.newGraphicsRenderPass((dir == 0) ? "IndirectDiffuseDenoiseH" : "IndirectDiffuseDenoiseV");
 			rpass.setFramebufferInfo(m_denoise.m_fbDescr, {m_runCtx.m_mainRtHandles[!readIdx]});
-			readUsage = TextureUsageBit::SAMPLED_FRAGMENT;
-			writeUsage = TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE;
+			readUsage = TextureUsageBit::kSampledFragment;
+			writeUsage = TextureUsageBit::kFramebufferWrite;
 			prpass = &rpass;
 		}
 
@@ -377,7 +376,7 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 			{
 				cmdb->setViewport(0, 0, unis.m_viewportSize.x(), unis.m_viewportSize.y());
 
-				cmdb->drawArrays(PrimitiveTopology::TRIANGLES, 3);
+				cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
 			}
 		});
 	}

AnKi/Renderer/IndirectDiffuseProbes.cpp

@@ -39,7 +39,7 @@ public:
 		m_probeToUpdateThisFrame ANKI_DEBUG_CODE(= numberToPtr<GlobalIlluminationProbeQueueElement*>(1));
 	UVec3 m_cellOfTheProbeToUpdateThisFrame ANKI_DEBUG_CODE(= UVec3(MAX_U32));
 
-	Array<RenderTargetHandle, GBUFFER_COLOR_ATTACHMENT_COUNT> m_gbufferColorRts;
+	Array<RenderTargetHandle, kGBufferColorRenderTargetCount> m_gbufferColorRts;
 	RenderTargetHandle m_gbufferDepthRt;
 	RenderTargetHandle m_shadowsRt;
 	RenderTargetHandle m_lightShadingRt;
@@ -127,12 +127,12 @@ Error IndirectDiffuseProbes::initGBuffer()
 	// Create RT descriptions
 	{
 		RenderTargetDescription texinit = m_r->create2DRenderTargetDescription(
-			m_tileSize * 6, m_tileSize, GBUFFER_COLOR_ATTACHMENT_PIXEL_FORMATS[0], "GI GBuffer");
+			m_tileSize * 6, m_tileSize, kGBufferColorRenderTargetFormats[0], "GI GBuffer");
 
 		// Create color RT descriptions
-		for(U32 i = 0; i < GBUFFER_COLOR_ATTACHMENT_COUNT; ++i)
+		for(U32 i = 0; i < kGBufferColorRenderTargetCount; ++i)
 		{
-			texinit.m_format = GBUFFER_COLOR_ATTACHMENT_PIXEL_FORMATS[i];
+			texinit.m_format = kGBufferColorRenderTargetFormats[i];
 			m_gbuffer.m_colorRtDescrs[i] = texinit;
 			m_gbuffer.m_colorRtDescrs[i].setName(StringAuto(getAllocator()).sprintf("GI GBuff Col #%u", i).toCString());
 			m_gbuffer.m_colorRtDescrs[i].bake();
@@ -147,14 +147,14 @@ Error IndirectDiffuseProbes::initGBuffer()
 
 	// Create FB descr
 	{
-		m_gbuffer.m_fbDescr.m_colorAttachmentCount = GBUFFER_COLOR_ATTACHMENT_COUNT;
+		m_gbuffer.m_fbDescr.m_colorAttachmentCount = kGBufferColorRenderTargetCount;
 
-		for(U j = 0; j < GBUFFER_COLOR_ATTACHMENT_COUNT; ++j)
+		for(U j = 0; j < kGBufferColorRenderTargetCount; ++j)
 		{
 			m_gbuffer.m_fbDescr.m_colorAttachments[j].m_loadOperation = AttachmentLoadOperation::CLEAR;
 		}
 
-		m_gbuffer.m_fbDescr.m_depthStencilAttachment.m_aspect = DepthStencilAspectBit::DEPTH;
+		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_clearValue.m_depthStencil.m_depth = 1.0f;
 
@@ -176,7 +176,7 @@ Error IndirectDiffuseProbes::initShadowMapping()
 
 	// FB descr
 	m_shadowMapping.m_fbDescr.m_colorAttachmentCount = 0;
-	m_shadowMapping.m_fbDescr.m_depthStencilAttachment.m_aspect = DepthStencilAspectBit::DEPTH;
+	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.bake();
@@ -266,7 +266,7 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 	// GBuffer
 	{
 		// RTs
-		for(U i = 0; i < GBUFFER_COLOR_ATTACHMENT_COUNT; ++i)
+		for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 		{
 			giCtx->m_gbufferColorRts[i] = rgraph.newRenderTarget(m_gbuffer.m_colorRtDescrs[i]);
 		}
@@ -279,13 +279,13 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 			runGBufferInThread(rgraphCtx, *giCtx);
 		});
 
-		for(U i = 0; i < GBUFFER_COLOR_ATTACHMENT_COUNT; ++i)
+		for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 		{
-			pass.newDependency({giCtx->m_gbufferColorRts[i], TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
+			pass.newDependency({giCtx->m_gbufferColorRts[i], TextureUsageBit::kFramebufferWrite});
 		}
 
-		TextureSubresourceInfo subresource(DepthStencilAspectBit::DEPTH);
-		pass.newDependency({giCtx->m_gbufferDepthRt, TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT, subresource});
+		TextureSubresourceInfo subresource(DepthStencilAspectBit::kDepth);
+		pass.newDependency({giCtx->m_gbufferDepthRt, TextureUsageBit::kAllFramebuffer, subresource});
 	}
 
 	// Shadow pass. Optional
@@ -321,8 +321,8 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 			runShadowmappingInThread(rgraphCtx, *giCtx);
 		});
 
-		TextureSubresourceInfo subresource(DepthStencilAspectBit::DEPTH);
-		pass.newDependency({giCtx->m_shadowsRt, TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT, subresource});
+		TextureSubresourceInfo subresource(DepthStencilAspectBit::kDepth);
+		pass.newDependency({giCtx->m_shadowsRt, TextureUsageBit::kAllFramebuffer, subresource});
 	}
 	else
 	{
@@ -341,18 +341,18 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 			runLightShading(rgraphCtx, *giCtx);
 		});
 
-		pass.newDependency({giCtx->m_lightShadingRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
+		pass.newDependency({giCtx->m_lightShadingRt, TextureUsageBit::kFramebufferWrite});
 
-		for(U i = 0; i < GBUFFER_COLOR_ATTACHMENT_COUNT; ++i)
+		for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 		{
-			pass.newDependency({giCtx->m_gbufferColorRts[i], TextureUsageBit::SAMPLED_FRAGMENT});
+			pass.newDependency({giCtx->m_gbufferColorRts[i], TextureUsageBit::kSampledFragment});
 		}
-		pass.newDependency({giCtx->m_gbufferDepthRt, TextureUsageBit::SAMPLED_FRAGMENT,
-							TextureSubresourceInfo(DepthStencilAspectBit::DEPTH)});
+		pass.newDependency({giCtx->m_gbufferDepthRt, TextureUsageBit::kSampledFragment,
+							TextureSubresourceInfo(DepthStencilAspectBit::kDepth)});
 
 		if(giCtx->m_shadowsRt.isValid())
 		{
-			pass.newDependency({giCtx->m_shadowsRt, TextureUsageBit::SAMPLED_FRAGMENT});
+			pass.newDependency({giCtx->m_shadowsRt, TextureUsageBit::kSampledFragment});
 		}
 	}
 
@@ -364,15 +364,15 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 			runIrradiance(rgraphCtx, *giCtx);
 		});
 
-		pass.newDependency({giCtx->m_lightShadingRt, TextureUsageBit::SAMPLED_COMPUTE});
+		pass.newDependency({giCtx->m_lightShadingRt, TextureUsageBit::kSampledCompute});
 
-		for(U32 i = 0; i < GBUFFER_COLOR_ATTACHMENT_COUNT - 1; ++i)
+		for(U32 i = 0; i < kGBufferColorRenderTargetCount - 1; ++i)
 		{
-			pass.newDependency({giCtx->m_gbufferColorRts[i], TextureUsageBit::SAMPLED_COMPUTE});
+			pass.newDependency({giCtx->m_gbufferColorRts[i], TextureUsageBit::kSampledCompute});
 		}
 
 		const U32 probeIdx = U32(giCtx->m_probeToUpdateThisFrame - &giCtx->m_ctx->m_renderQueue->m_giProbes.getFront());
-		pass.newDependency({giCtx->m_irradianceProbeRts[probeIdx], TextureUsageBit::IMAGE_COMPUTE_WRITE});
+		pass.newDependency({giCtx->m_irradianceProbeRts[probeIdx], TextureUsageBit::kImageComputeWrite});
 	}
 }
 
@@ -432,7 +432,7 @@ void IndirectDiffuseProbes::prepareProbes(InternalContext& giCtx)
 
 			entry.m_lastUsedTimestamp = m_r->getGlobalTimestamp();
 			volumeRts[newListOfProbeCount] =
-				ctx.m_renderGraphDescr.importRenderTarget(entry.m_volumeTex, TextureUsageBit::SAMPLED_FRAGMENT);
+				ctx.m_renderGraphDescr.importRenderTarget(entry.m_volumeTex, TextureUsageBit::kSampledFragment);
 			newListOfProbes[newListOfProbeCount++] = probe;
 			continue;
 		}
@@ -479,14 +479,14 @@ void IndirectDiffuseProbes::prepareProbes(InternalContext& giCtx)
 		if(shouldInitTextures)
 		{
 			TextureInitInfo texInit("GiProbeVolume");
-			texInit.m_type = TextureType::_3D;
+			texInit.m_type = TextureType::k3D;
 			texInit.m_format = m_r->getHdrFormat();
 			texInit.m_width = probe.m_cellCounts.x() * 6;
 			texInit.m_height = probe.m_cellCounts.y();
 			texInit.m_depth = probe.m_cellCounts.z();
-			texInit.m_usage = TextureUsageBit::ALL_COMPUTE | TextureUsageBit::ALL_SAMPLED;
+			texInit.m_usage = TextureUsageBit::kAllCompute | TextureUsageBit::kAllSampled;
 
-			entry.m_volumeTex = m_r->createAndClearRenderTarget(texInit, TextureUsageBit::SAMPLED_FRAGMENT);
+			entry.m_volumeTex = m_r->createAndClearRenderTarget(texInit, TextureUsageBit::kSampledFragment);
 		}
 
 		// Compute the render position
@@ -514,7 +514,7 @@ void IndirectDiffuseProbes::prepareProbes(InternalContext& giCtx)
 		giCtx.m_probeToUpdateThisFrame = &newListOfProbes[newListOfProbeCount];
 		newListOfProbes[newListOfProbeCount] = probe;
 		volumeRts[newListOfProbeCount] =
-			ctx.m_renderGraphDescr.importRenderTarget(entry.m_volumeTex, TextureUsageBit::SAMPLED_FRAGMENT);
+			ctx.m_renderGraphDescr.importRenderTarget(entry.m_volumeTex, TextureUsageBit::kSampledFragment);
 		++newListOfProbeCount;
 	}
 
@@ -709,7 +709,7 @@ void IndirectDiffuseProbes::runIrradiance(RenderPassWorkContext& rgraphCtx, Inte
 	cmdb->bindSampler(0, 0, m_r->getSamplers().m_nearestNearestClamp);
 	rgraphCtx.bindColorTexture(0, 1, giCtx.m_lightShadingRt);
 
-	for(U32 i = 0; i < GBUFFER_COLOR_ATTACHMENT_COUNT - 1; ++i)
+	for(U32 i = 0; i < kGBufferColorRenderTargetCount - 1; ++i)
 	{
 		rgraphCtx.bindColorTexture(0, 2, giCtx.m_gbufferColorRts[i], i);
 	}

AnKi/Renderer/IndirectDiffuseProbes.h

@@ -62,7 +62,7 @@ private:
 	class
 	{
 	public:
-		Array<RenderTargetDescription, GBUFFER_COLOR_ATTACHMENT_COUNT> m_colorRtDescrs;
+		Array<RenderTargetDescription, kGBufferColorRenderTargetCount> m_colorRtDescrs;
 		RenderTargetDescription m_depthRtDescr;
 		FramebufferDescription m_fbDescr;
 	} m_gbuffer; ///< G-buffer pass.

AnKi/Renderer/IndirectSpecular.cpp

@@ -40,15 +40,15 @@ Error IndirectSpecular::initInternal()
 	ANKI_CHECK(getResourceManager().loadResource("EngineAssets/BlueNoise_Rgba8_64x64.png", m_noiseImage));
 
 	// Create RT
-	TextureUsageBit usage = TextureUsageBit::ALL_SAMPLED;
+	TextureUsageBit usage = TextureUsageBit::kAllSampled;
 
-	usage |= (preferCompute) ? TextureUsageBit::IMAGE_COMPUTE_WRITE : TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE;
+	usage |= (preferCompute) ? TextureUsageBit::kImageComputeWrite : TextureUsageBit::kFramebufferWrite;
 
 	TextureInitInfo texInit =
 		m_r->create2DRenderTargetInitInfo(size.x(), size.y(), m_r->getHdrFormat(), usage, "SSR #1");
-	m_rts[0] = m_r->createAndClearRenderTarget(texInit, TextureUsageBit::ALL_SAMPLED);
+	m_rts[0] = m_r->createAndClearRenderTarget(texInit, TextureUsageBit::kAllSampled);
 	texInit.setName("SSR #2");
-	m_rts[1] = m_r->createAndClearRenderTarget(texInit, TextureUsageBit::ALL_SAMPLED);
+	m_rts[1] = m_r->createAndClearRenderTarget(texInit, TextureUsageBit::kAllSampled);
 
 	m_fbDescr.m_colorAttachmentCount = 1;
 	m_fbDescr.bake();
@@ -86,8 +86,8 @@ void IndirectSpecular::populateRenderGraph(RenderingContext& ctx)
 	}
 	else
 	{
-		m_runCtx.m_rts[0] = rgraph.importRenderTarget(m_rts[readRtIdx], TextureUsageBit::ALL_SAMPLED);
-		m_runCtx.m_rts[1] = rgraph.importRenderTarget(m_rts[writeRtIdx], TextureUsageBit::ALL_SAMPLED);
+		m_runCtx.m_rts[0] = rgraph.importRenderTarget(m_rts[readRtIdx], TextureUsageBit::kAllSampled);
+		m_runCtx.m_rts[1] = rgraph.importRenderTarget(m_rts[writeRtIdx], TextureUsageBit::kAllSampled);
 		m_rtsImportedOnce = true;
 	}
 
@@ -120,8 +120,8 @@ void IndirectSpecular::populateRenderGraph(RenderingContext& ctx)
 			ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("SSR");
 
 			ppass = &pass;
-			readUsage = TextureUsageBit::SAMPLED_COMPUTE;
-			writeUsage = TextureUsageBit::IMAGE_COMPUTE_WRITE;
+			readUsage = TextureUsageBit::kSampledCompute;
+			writeUsage = TextureUsageBit::kImageComputeWrite;
 		}
 		else
 		{
@@ -131,13 +131,13 @@ void IndirectSpecular::populateRenderGraph(RenderingContext& ctx)
 												: RenderTargetHandle());
 
 			ppass = &pass;
-			readUsage = TextureUsageBit::SAMPLED_FRAGMENT;
-			writeUsage = TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE;
+			readUsage = TextureUsageBit::kSampledFragment;
+			writeUsage = TextureUsageBit::kFramebufferWrite;
 
 			if(enableVrs)
 			{
 				ppass->newDependency(RenderPassDependency(m_r->getVrsSriGeneration().getDownscaledSriRt(),
-														  TextureUsageBit::FRAMEBUFFER_SHADING_RATE));
+														  TextureUsageBit::kFramebufferShadingRate));
 			}
 		}
 
@@ -220,7 +220,7 @@ void IndirectSpecular::run(const RenderingContext& ctx, RenderPassWorkContext& r
 	{
 		cmdb->setViewport(0, 0, m_r->getInternalResolution().x() / 2, m_r->getInternalResolution().y() / 2);
 
-		cmdb->drawArrays(PrimitiveTopology::TRIANGLES, 3);
+		cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
 	}
 }
 

AnKi/Renderer/LensFlare.cpp

@@ -102,7 +102,7 @@ void LensFlare::updateIndirectInfo(const RenderingContext& ctx, RenderPassWorkCo
 	rgraphCtx.bindStorageBuffer(0, 1, m_runCtx.m_indirectBuffHandle);
 	// Bind neareset because you don't need high quality
 	cmdb->bindSampler(0, 2, m_r->getSamplers().m_nearestNearestClamp);
-	rgraphCtx.bindTexture(0, 3, m_r->getDepthDownscale().getHiZRt(), HIZ_QUARTER_DEPTH);
+	rgraphCtx.bindTexture(0, 3, m_r->getDepthDownscale().getHiZRt(), kHiZQuarterSurface);
 	cmdb->dispatchCompute(count, 1, 1);
 }
 
@@ -127,7 +127,8 @@ void LensFlare::populateRenderGraph(RenderingContext& ctx)
 		});
 
 		rpass.newDependency({m_runCtx.m_indirectBuffHandle, BufferUsageBit::STORAGE_COMPUTE_WRITE});
-		rpass.newDependency({m_r->getDepthDownscale().getHiZRt(), TextureUsageBit::SAMPLED_COMPUTE, HIZ_QUARTER_DEPTH});
+		rpass.newDependency(
+			{m_r->getDepthDownscale().getHiZRt(), TextureUsageBit::kSampledCompute, kHiZQuarterSurface});
 	}
 }
 
@@ -141,7 +142,7 @@ void LensFlare::runDrawFlares(const RenderingContext& ctx, CommandBufferPtr& cmd
 	const U32 count = min<U32>(ctx.m_renderQueue->m_lensFlares.getSize(), m_maxFlares);
 
 	cmdb->bindShaderProgram(m_realGrProg);
-	cmdb->setBlendFactors(0, BlendFactor::SRC_ALPHA, BlendFactor::ONE_MINUS_SRC_ALPHA);
+	cmdb->setBlendFactors(0, BlendFactor::kSrcAlpha, BlendFactor::kOneMinusSrcAlpha);
 	cmdb->setDepthWrite(false);
 
 	for(U32 i = 0; i < count; ++i)
@@ -183,12 +184,12 @@ void LensFlare::runDrawFlares(const RenderingContext& ctx, CommandBufferPtr& cmd
 		cmdb->bindSampler(0, 1, m_r->getSamplers().m_trilinearRepeat);
 		cmdb->bindTexture(0, 2, TextureViewPtr(const_cast<TextureView*>(flareEl.m_textureView)));
 
-		cmdb->drawArraysIndirect(PrimitiveTopology::TRIANGLE_STRIP, 1, i * sizeof(DrawArraysIndirectInfo),
+		cmdb->drawArraysIndirect(PrimitiveTopology::kTriangleStrip, 1, i * sizeof(DrawArraysIndirectInfo),
 								 m_indirectBuff);
 	}
 
 	// Restore state
-	cmdb->setBlendFactors(0, BlendFactor::ONE, BlendFactor::ZERO);
+	cmdb->setBlendFactors(0, BlendFactor::kOne, BlendFactor::kZero);
 	cmdb->setDepthWrite(true);
 }
 

AnKi/Renderer/LightShading.cpp

@@ -88,7 +88,7 @@ Error LightShading::initLightShading()
 	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_aspect = DepthStencilAspectBit::DEPTH;
+	m_lightShading.m_fbDescr.m_depthStencilAttachment.m_aspect = DepthStencilAspectBit::kDepth;
 
 	if(getGrManager().getDeviceCapabilities().m_vrs && getConfig().getRVrs())
 	{
@@ -185,7 +185,7 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 		rgraphCtx.bindColorTexture(0, 8, m_r->getGBuffer().getColorRt(1));
 		rgraphCtx.bindColorTexture(0, 9, m_r->getGBuffer().getColorRt(2));
 		rgraphCtx.bindTexture(0, 10, m_r->getGBuffer().getDepthRt(),
-							  TextureSubresourceInfo(DepthStencilAspectBit::DEPTH));
+							  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
 		if(m_r->getRtShadowsEnabled())
 		{
@@ -212,7 +212,7 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 		rgraphCtx.bindColorTexture(0, 3, m_r->getIndirectSpecular().getRt());
 		rgraphCtx.bindColorTexture(0, 4, m_r->getDepthDownscale().getHiZRt());
 		rgraphCtx.bindTexture(0, 5, m_r->getGBuffer().getDepthRt(),
-							  TextureSubresourceInfo(DepthStencilAspectBit::DEPTH));
+							  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 		rgraphCtx.bindColorTexture(0, 6, m_r->getGBuffer().getColorRt(0));
 		rgraphCtx.bindColorTexture(0, 7, m_r->getGBuffer().getColorRt(1));
 		rgraphCtx.bindColorTexture(0, 8, m_r->getGBuffer().getColorRt(2));
@@ -224,18 +224,18 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 		const Vec4 pc(ctx.m_renderQueue->m_cameraNear, ctx.m_renderQueue->m_cameraFar, 0.0f, 0.0f);
 		cmdb->setPushConstants(&pc, sizeof(pc));
 
-		cmdb->setBlendFactors(0, BlendFactor::ONE, BlendFactor::ONE);
+		cmdb->setBlendFactors(0, BlendFactor::kOne, BlendFactor::kOne);
 
 		drawQuad(cmdb);
 
 		// Restore state
-		cmdb->setBlendFactors(0, BlendFactor::ONE, BlendFactor::ZERO);
+		cmdb->setBlendFactors(0, BlendFactor::kOne, BlendFactor::kZero);
 	}
 
 	// Skybox
 	if(rgraphCtx.m_currentSecondLevelCommandBufferIndex == 0)
 	{
-		cmdb->setDepthCompareOperation(CompareOperation::EQUAL);
+		cmdb->setDepthCompareOperation(CompareOperation::kEqual);
 
 		const Bool isSolidColor = ctx.m_renderQueue->m_skybox.m_skyboxTexture == nullptr;
 
@@ -271,7 +271,7 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 		drawQuad(cmdb);
 
 		// Restore state
-		cmdb->setDepthCompareOperation(CompareOperation::LESS);
+		cmdb->setDepthCompareOperation(CompareOperation::kLess);
 	}
 
 	// Do the fog apply
@@ -284,7 +284,7 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 		cmdb->bindSampler(0, 1, m_r->getSamplers().m_trilinearClamp);
 
 		rgraphCtx.bindTexture(0, 2, m_r->getGBuffer().getDepthRt(),
-							  TextureSubresourceInfo(DepthStencilAspectBit::DEPTH));
+							  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 		rgraphCtx.bindColorTexture(0, 3, m_r->getVolumetricFog().getRt());
 
 		class PushConsts
@@ -300,12 +300,12 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 		cmdb->setPushConstants(&regs, sizeof(regs));
 
 		// finalPixelColor = pixelWithoutFog * transmitance + inScattering (see the shader)
-		cmdb->setBlendFactors(0, BlendFactor::ONE, BlendFactor::SRC_ALPHA);
+		cmdb->setBlendFactors(0, BlendFactor::kOne, BlendFactor::kSrcAlpha);
 
 		drawQuad(cmdb);
 
 		// Reset state
-		cmdb->setBlendFactors(0, BlendFactor::ONE, BlendFactor::ZERO);
+		cmdb->setBlendFactors(0, BlendFactor::kOne, BlendFactor::kZero);
 	}
 
 	// Forward shading last
@@ -368,23 +368,22 @@ void LightShading::populateRenderGraph(RenderingContext& ctx)
 				 });
 	pass.setFramebufferInfo(m_lightShading.m_fbDescr, {m_runCtx.m_rt}, m_r->getGBuffer().getDepthRt(), sriRt);
 
-	const TextureUsageBit readUsage = TextureUsageBit::SAMPLED_FRAGMENT;
+	const TextureUsageBit readUsage = TextureUsageBit::kSampledFragment;
 
 	// All
 	if(enableVrs)
 	{
-		pass.newDependency(RenderPassDependency(sriRt, TextureUsageBit::FRAMEBUFFER_SHADING_RATE));
+		pass.newDependency(RenderPassDependency(sriRt, TextureUsageBit::kFramebufferShadingRate));
 	}
 
 	// Light shading
-	pass.newDependency(RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE));
+	pass.newDependency(RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite));
 	pass.newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(0), readUsage));
 	pass.newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(1), readUsage));
 	pass.newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(2), readUsage));
-	pass.newDependency(
-		RenderPassDependency(m_r->getGBuffer().getDepthRt(),
-							 TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ,
-							 TextureSubresourceInfo(DepthStencilAspectBit::DEPTH)));
+	pass.newDependency(RenderPassDependency(m_r->getGBuffer().getDepthRt(),
+											TextureUsageBit::kSampledFragment | TextureUsageBit::kFramebufferRead,
+											TextureSubresourceInfo(DepthStencilAspectBit::kDepth)));
 	pass.newDependency(RenderPassDependency(m_r->getShadowMapping().getShadowmapRt(), readUsage));
 	if(m_r->getRtShadowsEnabled())
 	{

AnKi/Renderer/MainRenderer.cpp

@@ -58,8 +58,8 @@ Error MainRenderer::init(const MainRendererInitInfo& inf)
 		alignRoundDown(2, resolution.y());
 		m_tmpRtDesc = m_r->create2DRenderTargetDescription(
 			resolution.x(), resolution.y(),
-			(m_r->getGrManager().getDeviceCapabilities().m_unalignedBbpTextureFormats) ? Format::R8G8B8_UNORM
-																					   : Format::R8G8B8A8_UNORM,
+			(m_r->getGrManager().getDeviceCapabilities().m_unalignedBbpTextureFormats) ? Format::kR8G8B8_Unorm
+																					   : Format::kR8G8B8A8_Unorm,
 			"Final Composite");
 		m_tmpRtDesc.bake();
 
@@ -90,7 +90,7 @@ Error MainRenderer::render(RenderQueue& rqueue, TexturePtr presentTex)
 	m_runCtx.m_secondaryTaskId.setNonAtomically(0);
 	ctx.m_renderGraphDescr.setStatisticsEnabled(m_statsEnabled);
 
-	RenderTargetHandle presentRt = ctx.m_renderGraphDescr.importRenderTarget(presentTex, TextureUsageBit::NONE);
+	RenderTargetHandle presentRt = ctx.m_renderGraphDescr.importRenderTarget(presentTex, TextureUsageBit::kNone);
 
 	if(m_rDrawToDefaultFb)
 	{
@@ -120,11 +120,11 @@ Error MainRenderer::render(RenderQueue& rqueue, TexturePtr presentTex)
 			cmdb->bindSampler(0, 0, m_r->getSamplers().m_trilinearClamp);
 			rgraphCtx.bindColorTexture(0, 1, m_runCtx.m_ctx->m_outRenderTarget);
 
-			cmdb->drawArrays(PrimitiveTopology::TRIANGLES, 3);
+			cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
 		});
 
-		pass.newDependency(RenderPassDependency(presentRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE));
-		pass.newDependency(RenderPassDependency(ctx.m_outRenderTarget, TextureUsageBit::SAMPLED_FRAGMENT));
+		pass.newDependency(RenderPassDependency(presentRt, TextureUsageBit::kFramebufferWrite));
+		pass.newDependency(RenderPassDependency(ctx.m_outRenderTarget, TextureUsageBit::kSampledFragment));
 	}
 
 	// Create a dummy pass to transition the presentable image to present
@@ -134,7 +134,7 @@ Error MainRenderer::render(RenderQueue& rqueue, TexturePtr presentTex)
 		pass.setWork([]([[maybe_unused]] RenderPassWorkContext& rgraphCtx) {
 			// Do nothing. This pass is dummy
 		});
-		pass.newDependency({presentRt, TextureUsageBit::PRESENT});
+		pass.newDependency({presentRt, TextureUsageBit::kPresent});
 	}
 
 	// Bake the render graph

AnKi/Renderer/MotionVectors.cpp

@@ -42,25 +42,25 @@ Error MotionVectors::initInternal()
 
 	// RTs
 	m_motionVectorsRtDescr = m_r->create2DRenderTargetDescription(
-		m_r->getInternalResolution().x(), m_r->getInternalResolution().y(), Format::R16G16_SFLOAT, "MotionVectors");
+		m_r->getInternalResolution().x(), m_r->getInternalResolution().y(), Format::kR16G16_Sfloat, "MotionVectors");
 	m_motionVectorsRtDescr.bake();
 
-	TextureUsageBit historyLengthUsage = TextureUsageBit::ALL_SAMPLED;
+	TextureUsageBit historyLengthUsage = TextureUsageBit::kAllSampled;
 	if(getConfig().getRPreferCompute())
 	{
-		historyLengthUsage |= TextureUsageBit::IMAGE_COMPUTE_WRITE;
+		historyLengthUsage |= TextureUsageBit::kImageComputeWrite;
 	}
 	else
 	{
-		historyLengthUsage |= TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE;
+		historyLengthUsage |= TextureUsageBit::kFramebufferWrite;
 	}
 
 	TextureInitInfo historyLengthTexInit =
 		m_r->create2DRenderTargetInitInfo(m_r->getInternalResolution().x(), m_r->getInternalResolution().y(),
-										  Format::R8_UNORM, historyLengthUsage, "MotionVectorsHistoryLen#1");
-	m_historyLengthTextures[0] = m_r->createAndClearRenderTarget(historyLengthTexInit, TextureUsageBit::ALL_SAMPLED);
+										  Format::kR8_Unorm, historyLengthUsage, "MotionVectorsHistoryLen#1");
+	m_historyLengthTextures[0] = m_r->createAndClearRenderTarget(historyLengthTexInit, TextureUsageBit::kAllSampled);
 	historyLengthTexInit.setName("MotionVectorsHistoryLen#2");
-	m_historyLengthTextures[1] = m_r->createAndClearRenderTarget(historyLengthTexInit, TextureUsageBit::ALL_SAMPLED);
+	m_historyLengthTextures[1] = m_r->createAndClearRenderTarget(historyLengthTexInit, TextureUsageBit::kAllSampled);
 
 	m_fbDescr.m_colorAttachmentCount = 2;
 	m_fbDescr.bake();
@@ -86,9 +86,9 @@ void MotionVectors::populateRenderGraph(RenderingContext& ctx)
 	else
 	{
 		m_runCtx.m_historyLengthWriteRtHandle =
-			rgraph.importRenderTarget(m_historyLengthTextures[writeHistoryLenTexIdx], TextureUsageBit::ALL_SAMPLED);
+			rgraph.importRenderTarget(m_historyLengthTextures[writeHistoryLenTexIdx], TextureUsageBit::kAllSampled);
 		m_runCtx.m_historyLengthReadRtHandle =
-			rgraph.importRenderTarget(m_historyLengthTextures[readHistoryLenTexIdx], TextureUsageBit::ALL_SAMPLED);
+			rgraph.importRenderTarget(m_historyLengthTextures[readHistoryLenTexIdx], TextureUsageBit::kAllSampled);
 
 		m_historyLengthTexturesImportedOnce = true;
 	}
@@ -100,8 +100,8 @@ void MotionVectors::populateRenderGraph(RenderingContext& ctx)
 	{
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("MotionVectors");
 
-		readUsage = TextureUsageBit::SAMPLED_COMPUTE;
-		writeUsage = TextureUsageBit::IMAGE_COMPUTE_WRITE;
+		readUsage = TextureUsageBit::kSampledCompute;
+		writeUsage = TextureUsageBit::kImageComputeWrite;
 		ppass = &pass;
 	}
 	else
@@ -109,8 +109,8 @@ void MotionVectors::populateRenderGraph(RenderingContext& ctx)
 		GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass("MotionVectors");
 		pass.setFramebufferInfo(m_fbDescr, {m_runCtx.m_motionVectorsRtHandle, m_runCtx.m_historyLengthWriteRtHandle});
 
-		readUsage = TextureUsageBit::SAMPLED_FRAGMENT;
-		writeUsage = TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE;
+		readUsage = TextureUsageBit::kSampledFragment;
+		writeUsage = TextureUsageBit::kFramebufferWrite;
 		ppass = &pass;
 	}
 
@@ -133,9 +133,9 @@ void MotionVectors::run(const RenderingContext& ctx, RenderPassWorkContext& rgra
 	cmdb->bindShaderProgram(m_grProg);
 
 	cmdb->bindSampler(0, 0, m_r->getSamplers().m_trilinearClamp);
-	rgraphCtx.bindTexture(0, 1, m_r->getGBuffer().getDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::DEPTH));
+	rgraphCtx.bindTexture(0, 1, m_r->getGBuffer().getDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 	rgraphCtx.bindTexture(0, 2, m_r->getGBuffer().getPreviousFrameDepthRt(),
-						  TextureSubresourceInfo(DepthStencilAspectBit::DEPTH));
+						  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 	rgraphCtx.bindColorTexture(0, 3, m_r->getGBuffer().getColorRt(3));
 	rgraphCtx.bindColorTexture(0, 4, m_runCtx.m_historyLengthReadRtHandle);
 
@@ -166,7 +166,7 @@ void MotionVectors::run(const RenderingContext& ctx, RenderPassWorkContext& rgra
 	{
 		cmdb->setViewport(0, 0, m_r->getInternalResolution().x(), m_r->getInternalResolution().y());
 
-		cmdb->drawArrays(PrimitiveTopology::TRIANGLES, 3);
+		cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
 	}
 }
 

AnKi/Renderer/ProbeReflections.cpp

@@ -53,11 +53,11 @@ Error ProbeReflections::initInternal()
 	ANKI_CHECK(getResourceManager().loadResource("EngineAssets/IblDfg.png", m_integrationLut));
 
 	SamplerInitInfo sinit;
-	sinit.m_minMagFilter = SamplingFilter::LINEAR;
-	sinit.m_mipmapFilter = SamplingFilter::BASE;
+	sinit.m_minMagFilter = SamplingFilter::kLinear;
+	sinit.m_mipmapFilter = SamplingFilter::kBase;
 	sinit.m_minLod = 0.0;
 	sinit.m_maxLod = 1.0;
-	sinit.m_addressing = SamplingAddressing::CLAMP;
+	sinit.m_addressing = SamplingAddressing::kClamp;
 	m_integrationLutSampler = getGrManager().newSampler(sinit);
 
 	return Error::NONE;
@@ -69,14 +69,13 @@ Error ProbeReflections::initGBuffer()
 
 	// Create RT descriptions
 	{
-		RenderTargetDescription texinit =
-			m_r->create2DRenderTargetDescription(m_gbuffer.m_tileSize * 6, m_gbuffer.m_tileSize,
-												 GBUFFER_COLOR_ATTACHMENT_PIXEL_FORMATS[0], "CubeRefl GBuffer");
+		RenderTargetDescription texinit = m_r->create2DRenderTargetDescription(
+			m_gbuffer.m_tileSize * 6, m_gbuffer.m_tileSize, kGBufferColorRenderTargetFormats[0], "CubeRefl GBuffer");
 
 		// Create color RT descriptions
-		for(U32 i = 0; i < GBUFFER_COLOR_ATTACHMENT_COUNT; ++i)
+		for(U32 i = 0; i < kGBufferColorRenderTargetCount; ++i)
 		{
-			texinit.m_format = GBUFFER_COLOR_ATTACHMENT_PIXEL_FORMATS[i];
+			texinit.m_format = kGBufferColorRenderTargetFormats[i];
 			m_gbuffer.m_colorRtDescrs[i] = texinit;
 			m_gbuffer.m_colorRtDescrs[i].setName(
 				StringAuto(getAllocator()).sprintf("CubeRefl GBuff Col #%u", i).toCString());
@@ -92,14 +91,14 @@ Error ProbeReflections::initGBuffer()
 
 	// Create FB descr
 	{
-		m_gbuffer.m_fbDescr.m_colorAttachmentCount = GBUFFER_COLOR_ATTACHMENT_COUNT;
+		m_gbuffer.m_fbDescr.m_colorAttachmentCount = kGBufferColorRenderTargetCount;
 
-		for(U j = 0; j < GBUFFER_COLOR_ATTACHMENT_COUNT; ++j)
+		for(U j = 0; j < kGBufferColorRenderTargetCount; ++j)
 		{
 			m_gbuffer.m_fbDescr.m_colorAttachments[j].m_loadOperation = AttachmentLoadOperation::CLEAR;
 		}
 
-		m_gbuffer.m_fbDescr.m_depthStencilAttachment.m_aspect = DepthStencilAspectBit::DEPTH;
+		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_clearValue.m_depthStencil.m_depth = 1.0f;
 
@@ -118,15 +117,15 @@ Error ProbeReflections::initLightShading()
 	{
 		TextureInitInfo texinit = m_r->create2DRenderTargetInitInfo(
 			m_lightShading.m_tileSize, m_lightShading.m_tileSize, m_r->getHdrFormat(),
-			TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::SAMPLED_COMPUTE | TextureUsageBit::IMAGE_COMPUTE_READ
-				| TextureUsageBit::IMAGE_COMPUTE_WRITE | TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT
-				| TextureUsageBit::GENERATE_MIPMAPS,
+			TextureUsageBit::kSampledFragment | TextureUsageBit::kSampledCompute | TextureUsageBit::kImageComputeRead
+				| TextureUsageBit::kImageComputeWrite | TextureUsageBit::kAllFramebuffer
+				| TextureUsageBit::kGenerateMipmaps,
 			"CubeRefl refl");
 		texinit.m_mipmapCount = U8(m_lightShading.m_mipCount);
-		texinit.m_type = TextureType::CUBE_ARRAY;
+		texinit.m_type = TextureType::kCubeArray;
 		texinit.m_layerCount = m_cacheEntries.getSize();
 
-		m_lightShading.m_cubeArr = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::SAMPLED_FRAGMENT);
+		m_lightShading.m_cubeArr = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
 	}
 
 	// Init deferred
@@ -193,7 +192,7 @@ Error ProbeReflections::initShadowMapping()
 
 	// FB descr
 	m_shadowMapping.m_fbDescr.m_colorAttachmentCount = 0;
-	m_shadowMapping.m_fbDescr.m_depthStencilAttachment.m_aspect = DepthStencilAspectBit::DEPTH;
+	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.bake();
@@ -500,7 +499,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 	{
 		// Just import and exit
 
-		m_ctx.m_lightShadingRt = rgraph.importRenderTarget(m_lightShading.m_cubeArr, TextureUsageBit::SAMPLED_FRAGMENT);
+		m_ctx.m_lightShadingRt = rgraph.importRenderTarget(m_lightShading.m_cubeArr, TextureUsageBit::kSampledFragment);
 		return;
 	}
 
@@ -516,7 +515,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 	{
 		// RTs
 		Array<RenderTargetHandle, MAX_COLOR_ATTACHMENTS> rts;
-		for(U i = 0; i < GBUFFER_COLOR_ATTACHMENT_COUNT; ++i)
+		for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 		{
 			m_ctx.m_gbufferColorRts[i] = rgraph.newRenderTarget(m_gbuffer.m_colorRtDescrs[i]);
 			rts[i] = m_ctx.m_gbufferColorRts[i];
@@ -538,13 +537,13 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 			runGBuffer(rgraphCtx);
 		});
 
-		for(U i = 0; i < GBUFFER_COLOR_ATTACHMENT_COUNT; ++i)
+		for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 		{
-			pass.newDependency({m_ctx.m_gbufferColorRts[i], TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
+			pass.newDependency({m_ctx.m_gbufferColorRts[i], TextureUsageBit::kFramebufferWrite});
 		}
 
-		TextureSubresourceInfo subresource(DepthStencilAspectBit::DEPTH);
-		pass.newDependency({m_ctx.m_gbufferDepthRt, TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT, subresource});
+		TextureSubresourceInfo subresource(DepthStencilAspectBit::kDepth);
+		pass.newDependency({m_ctx.m_gbufferDepthRt, TextureUsageBit::kAllFramebuffer, subresource});
 	}
 
 	// Shadow pass. Optional
@@ -587,8 +586,8 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 			runShadowMapping(rgraphCtx);
 		});
 
-		TextureSubresourceInfo subresource(DepthStencilAspectBit::DEPTH);
-		pass.newDependency({m_ctx.m_shadowMapRt, TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT, subresource});
+		TextureSubresourceInfo subresource(DepthStencilAspectBit::kDepth);
+		pass.newDependency({m_ctx.m_shadowMapRt, TextureUsageBit::kAllFramebuffer, subresource});
 	}
 	else
 	{
@@ -598,7 +597,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 	// Light shading passes
 	{
 		// RT
-		m_ctx.m_lightShadingRt = rgraph.importRenderTarget(m_lightShading.m_cubeArr, TextureUsageBit::SAMPLED_FRAGMENT);
+		m_ctx.m_lightShadingRt = rgraph.importRenderTarget(m_lightShading.m_cubeArr, TextureUsageBit::kSampledFragment);
 
 		// Passes
 		static constexpr Array<CString, 6> passNames = {"CubeRefl LightShad #0", "CubeRefl LightShad #1",
@@ -614,18 +613,18 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 			});
 
 			TextureSubresourceInfo subresource(TextureSurfaceInfo(0, 0, faceIdx, probeToUpdateCacheEntryIdx));
-			pass.newDependency({m_ctx.m_lightShadingRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE, subresource});
+			pass.newDependency({m_ctx.m_lightShadingRt, TextureUsageBit::kFramebufferWrite, subresource});
 
-			for(U i = 0; i < GBUFFER_COLOR_ATTACHMENT_COUNT; ++i)
+			for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 			{
-				pass.newDependency({m_ctx.m_gbufferColorRts[i], TextureUsageBit::SAMPLED_FRAGMENT});
+				pass.newDependency({m_ctx.m_gbufferColorRts[i], TextureUsageBit::kSampledFragment});
 			}
-			pass.newDependency({m_ctx.m_gbufferDepthRt, TextureUsageBit::SAMPLED_FRAGMENT,
-								TextureSubresourceInfo(DepthStencilAspectBit::DEPTH)});
+			pass.newDependency({m_ctx.m_gbufferDepthRt, TextureUsageBit::kSampledFragment,
+								TextureSubresourceInfo(DepthStencilAspectBit::kDepth)});
 
 			if(m_ctx.m_shadowMapRt.isValid())
 			{
-				pass.newDependency({m_ctx.m_shadowMapRt, TextureUsageBit::SAMPLED_FRAGMENT});
+				pass.newDependency({m_ctx.m_shadowMapRt, TextureUsageBit::kSampledFragment});
 			}
 		}
 	}
@@ -645,7 +644,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 		TextureSubresourceInfo readSubresource;
 		readSubresource.m_faceCount = 6;
 		readSubresource.m_firstLayer = probeToUpdateCacheEntryIdx;
-		pass.newDependency({m_ctx.m_lightShadingRt, TextureUsageBit::SAMPLED_COMPUTE, readSubresource});
+		pass.newDependency({m_ctx.m_lightShadingRt, TextureUsageBit::kSampledCompute, readSubresource});
 
 		pass.newDependency({m_ctx.m_irradianceDiceValuesBuffHandle, BufferUsageBit::STORAGE_COMPUTE_WRITE});
 	}
@@ -658,16 +657,16 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 			runIrradianceToRefl(rgraphCtx);
 		});
 
-		for(U i = 0; i < GBUFFER_COLOR_ATTACHMENT_COUNT - 1; ++i)
+		for(U i = 0; i < kGBufferColorRenderTargetCount - 1; ++i)
 		{
-			pass.newDependency({m_ctx.m_gbufferColorRts[i], TextureUsageBit::SAMPLED_COMPUTE});
+			pass.newDependency({m_ctx.m_gbufferColorRts[i], TextureUsageBit::kSampledCompute});
 		}
 
 		TextureSubresourceInfo subresource;
 		subresource.m_faceCount = 6;
 		subresource.m_firstLayer = probeToUpdateCacheEntryIdx;
 		pass.newDependency({m_ctx.m_lightShadingRt,
-							TextureUsageBit::IMAGE_COMPUTE_READ | TextureUsageBit::IMAGE_COMPUTE_WRITE, subresource});
+							TextureUsageBit::kImageComputeRead | TextureUsageBit::kImageComputeWrite, subresource});
 
 		pass.newDependency({m_ctx.m_irradianceDiceValuesBuffHandle, BufferUsageBit::STORAGE_COMPUTE_READ});
 	}
@@ -686,7 +685,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 			TextureSubresourceInfo subresource(TextureSurfaceInfo(0, 0, faceIdx, probeToUpdateCacheEntryIdx));
 			subresource.m_mipmapCount = m_lightShading.m_mipCount;
 
-			pass.newDependency({m_ctx.m_lightShadingRt, TextureUsageBit::GENERATE_MIPMAPS, subresource});
+			pass.newDependency({m_ctx.m_lightShadingRt, TextureUsageBit::kGenerateMipmaps, subresource});
 		}
 	}
 }

AnKi/Renderer/ProbeReflections.h

@@ -55,7 +55,7 @@ private:
 	{
 	public:
 		U32 m_tileSize = 0;
-		Array<RenderTargetDescription, GBUFFER_COLOR_ATTACHMENT_COUNT> m_colorRtDescrs;
+		Array<RenderTargetDescription, kGBufferColorRenderTargetCount> m_colorRtDescrs;
 		RenderTargetDescription m_depthRtDescr;
 		FramebufferDescription m_fbDescr;
 	} m_gbuffer; ///< G-buffer pass.
@@ -120,7 +120,7 @@ private:
 		const ReflectionProbeQueueElement* m_probe = nullptr;
 		U32 m_cacheEntryIdx = MAX_U32;
 
-		Array<RenderTargetHandle, GBUFFER_COLOR_ATTACHMENT_COUNT> m_gbufferColorRts;
+		Array<RenderTargetHandle, kGBufferColorRenderTargetCount> m_gbufferColorRts;
 		RenderTargetHandle m_gbufferDepthRt;
 		RenderTargetHandle m_lightShadingRt;
 		BufferHandle m_irradianceDiceValuesBuffHandle;

AnKi/Renderer/Renderer.cpp

@@ -152,16 +152,16 @@ Error Renderer::initInternal(UVec2 swapchainResolution)
 	{
 		TextureInitInfo texinit("RendererDummy");
 		texinit.m_width = texinit.m_height = 4;
-		texinit.m_usage = TextureUsageBit::ALL_SAMPLED | TextureUsageBit::IMAGE_COMPUTE_WRITE;
-		texinit.m_format = Format::R8G8B8A8_UNORM;
-		TexturePtr tex = createAndClearRenderTarget(texinit, TextureUsageBit::ALL_SAMPLED);
+		texinit.m_usage = TextureUsageBit::kAllSampled | TextureUsageBit::kImageComputeWrite;
+		texinit.m_format = Format::kR8G8B8A8_Unorm;
+		TexturePtr tex = createAndClearRenderTarget(texinit, TextureUsageBit::kAllSampled);
 
 		TextureViewInitInfo viewinit(tex);
 		m_dummyTexView2d = getGrManager().newTextureView(viewinit);
 
 		texinit.m_depth = 4;
-		texinit.m_type = TextureType::_3D;
-		tex = createAndClearRenderTarget(texinit, TextureUsageBit::ALL_SAMPLED);
+		texinit.m_type = TextureType::k3D;
+		tex = createAndClearRenderTarget(texinit, TextureUsageBit::kAllSampled);
 		viewinit = TextureViewInitInfo(tex);
 		m_dummyTexView3d = getGrManager().newTextureView(viewinit);
 
@@ -262,16 +262,16 @@ Error Renderer::initInternal(UVec2 swapchainResolution)
 	// Init samplers
 	{
 		SamplerInitInfo sinit("Renderer");
-		sinit.m_addressing = SamplingAddressing::CLAMP;
-		sinit.m_mipmapFilter = SamplingFilter::NEAREST;
-		sinit.m_minMagFilter = SamplingFilter::NEAREST;
+		sinit.m_addressing = SamplingAddressing::kClamp;
+		sinit.m_mipmapFilter = SamplingFilter::kNearest;
+		sinit.m_minMagFilter = SamplingFilter::kNearest;
 		m_samplers.m_nearestNearestClamp = m_gr->newSampler(sinit);
 
-		sinit.m_minMagFilter = SamplingFilter::LINEAR;
-		sinit.m_mipmapFilter = SamplingFilter::LINEAR;
+		sinit.m_minMagFilter = SamplingFilter::kLinear;
+		sinit.m_mipmapFilter = SamplingFilter::kLinear;
 		m_samplers.m_trilinearClamp = m_gr->newSampler(sinit);
 
-		sinit.m_addressing = SamplingAddressing::REPEAT;
+		sinit.m_addressing = SamplingAddressing::kRepeat;
 		m_samplers.m_trilinearRepeat = m_gr->newSampler(sinit);
 
 		sinit.m_anisotropyLevel = m_config->getRTextureAnisotropy();
@@ -409,15 +409,14 @@ void Renderer::finalize(const RenderingContext& ctx)
 
 TextureInitInfo Renderer::create2DRenderTargetInitInfo(U32 w, U32 h, Format format, TextureUsageBit usage, CString name)
 {
-	ANKI_ASSERT(!!(usage & TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE)
-				|| !!(usage & TextureUsageBit::IMAGE_COMPUTE_WRITE));
+	ANKI_ASSERT(!!(usage & TextureUsageBit::kFramebufferWrite) || !!(usage & TextureUsageBit::kImageComputeWrite));
 	TextureInitInfo init(name);
 
 	init.m_width = w;
 	init.m_height = h;
 	init.m_depth = 1;
 	init.m_layerCount = 1;
-	init.m_type = TextureType::_2D;
+	init.m_type = TextureType::k2D;
 	init.m_format = format;
 	init.m_mipmapCount = 1;
 	init.m_samples = 1;
@@ -434,11 +433,11 @@ RenderTargetDescription Renderer::create2DRenderTargetDescription(U32 w, U32 h,
 	init.m_height = h;
 	init.m_depth = 1;
 	init.m_layerCount = 1;
-	init.m_type = TextureType::_2D;
+	init.m_type = TextureType::k2D;
 	init.m_format = format;
 	init.m_mipmapCount = 1;
 	init.m_samples = 1;
-	init.m_usage = TextureUsageBit::NONE;
+	init.m_usage = TextureUsageBit::kNone;
 
 	return init;
 }
@@ -446,17 +445,17 @@ RenderTargetDescription Renderer::create2DRenderTargetDescription(U32 w, U32 h,
 TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, TextureUsageBit initialUsage,
 												const ClearValue& clearVal)
 {
-	ANKI_ASSERT(!!(inf.m_usage & TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE)
-				|| !!(inf.m_usage & TextureUsageBit::IMAGE_COMPUTE_WRITE));
+	ANKI_ASSERT(!!(inf.m_usage & TextureUsageBit::kFramebufferWrite)
+				|| !!(inf.m_usage & TextureUsageBit::kImageComputeWrite));
 
-	const U faceCount = (inf.m_type == TextureType::CUBE || inf.m_type == TextureType::CUBE_ARRAY) ? 6 : 1;
+	const U faceCount = (inf.m_type == TextureType::kCube || inf.m_type == TextureType::kCubeArray) ? 6 : 1;
 
 	Bool useCompute = false;
-	if(!!(inf.m_usage & TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE))
+	if(!!(inf.m_usage & TextureUsageBit::kFramebufferWrite))
 	{
 		useCompute = false;
 	}
-	else if(!!(inf.m_usage & TextureUsageBit::IMAGE_COMPUTE_WRITE))
+	else if(!!(inf.m_usage & TextureUsageBit::kImageComputeWrite))
 	{
 		useCompute = true;
 	}
@@ -489,19 +488,19 @@ TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, Text
 				{
 					FramebufferInitInfo fbInit("RendererClearRT");
 					Array<TextureUsageBit, MAX_COLOR_ATTACHMENTS> colUsage = {};
-					TextureUsageBit dsUsage = TextureUsageBit::NONE;
+					TextureUsageBit dsUsage = TextureUsageBit::kNone;
 
 					if(getFormatInfo(inf.m_format).isDepthStencil())
 					{
-						DepthStencilAspectBit aspect = DepthStencilAspectBit::NONE;
+						DepthStencilAspectBit aspect = DepthStencilAspectBit::kNone;
 						if(getFormatInfo(inf.m_format).isDepth())
 						{
-							aspect |= DepthStencilAspectBit::DEPTH;
+							aspect |= DepthStencilAspectBit::kDepth;
 						}
 
 						if(getFormatInfo(inf.m_format).isStencil())
 						{
-							aspect |= DepthStencilAspectBit::STENCIL;
+							aspect |= DepthStencilAspectBit::kStencil;
 						}
 
 						TextureViewPtr view = getGrManager().newTextureView(TextureViewInitInfo(tex, surf, aspect));
@@ -511,7 +510,7 @@ TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, Text
 						fbInit.m_depthStencilAttachment.m_stencilLoadOperation = AttachmentLoadOperation::CLEAR;
 						fbInit.m_depthStencilAttachment.m_clearValue = clearVal;
 
-						dsUsage = TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE;
+						dsUsage = TextureUsageBit::kFramebufferWrite;
 					}
 					else
 					{
@@ -522,12 +521,12 @@ TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, Text
 						fbInit.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::CLEAR;
 						fbInit.m_colorAttachments[0].m_clearValue = clearVal;
 
-						colUsage[0] = TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE;
+						colUsage[0] = TextureUsageBit::kFramebufferWrite;
 					}
 					FramebufferPtr fb = m_gr->newFramebuffer(fbInit);
 
-					TextureBarrierInfo barrier = {tex.get(), TextureUsageBit::NONE,
-												  TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE, surf};
+					TextureBarrierInfo barrier = {tex.get(), TextureUsageBit::kNone, TextureUsageBit::kFramebufferWrite,
+												  surf};
 					barrier.m_subresource.m_depthStencilAspect = tex->getDepthStencilAspect();
 					cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
@@ -536,7 +535,7 @@ TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, Text
 
 					if(!!initialUsage)
 					{
-						barrier.m_previousUsage = TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE;
+						barrier.m_previousUsage = TextureUsageBit::kFramebufferWrite;
 						barrier.m_nextUsage = initialUsage;
 						cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 					}
@@ -545,7 +544,7 @@ TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, Text
 				{
 					// Compute
 					ShaderProgramResourceVariantInitInfo variantInitInfo(m_clearTexComputeProg);
-					variantInitInfo.addMutation("TEXTURE_DIMENSIONS", I32((inf.m_type == TextureType::_3D) ? 3 : 2));
+					variantInitInfo.addMutation("TEXTURE_DIMENSIONS", I32((inf.m_type == TextureType::k3D) ? 3 : 2));
 
 					const FormatInfo formatInfo = getFormatInfo(inf.m_format);
 					I32 componentType = 0;
@@ -573,20 +572,20 @@ TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, Text
 					TextureViewPtr view = getGrManager().newTextureView(TextureViewInitInfo(tex, surf));
 					cmdb->bindImage(0, 0, view);
 
-					const TextureBarrierInfo barrier = {tex.get(), TextureUsageBit::NONE,
-														TextureUsageBit::IMAGE_COMPUTE_WRITE, surf};
+					const TextureBarrierInfo barrier = {tex.get(), TextureUsageBit::kNone,
+														TextureUsageBit::kImageComputeWrite, surf};
 					cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
 					UVec3 wgSize;
 					wgSize.x() = (8 - 1 + (tex->getWidth() >> mip)) / 8;
 					wgSize.y() = (8 - 1 + (tex->getHeight() >> mip)) / 8;
-					wgSize.z() = (inf.m_type == TextureType::_3D) ? ((8 - 1 + (tex->getDepth() >> mip)) / 8) : 1;
+					wgSize.z() = (inf.m_type == TextureType::k3D) ? ((8 - 1 + (tex->getDepth() >> mip)) / 8) : 1;
 
 					cmdb->dispatchCompute(wgSize.x(), wgSize.y(), wgSize.z());
 
 					if(!!initialUsage)
 					{
-						const TextureBarrierInfo barrier = {tex.get(), TextureUsageBit::IMAGE_COMPUTE_WRITE,
+						const TextureBarrierInfo barrier = {tex.get(), TextureUsageBit::kImageComputeWrite,
 															initialUsage, surf};
 
 						cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
@@ -655,15 +654,15 @@ Format Renderer::getHdrFormat() const
 	Format out;
 	if(!m_config->getRHighQualityHdr())
 	{
-		out = Format::B10G11R11_UFLOAT_PACK32;
+		out = Format::kB10G11R11_Ufloat_Pack32;
 	}
 	else if(m_gr->getDeviceCapabilities().m_unalignedBbpTextureFormats)
 	{
-		out = Format::R16G16B16_SFLOAT;
+		out = Format::kR16G16B16_Sfloat;
 	}
 	else
 	{
-		out = Format::R16G16B16A16_SFLOAT;
+		out = Format::kR16G16B16A16_Sfloat;
 	}
 	return out;
 }
@@ -672,11 +671,11 @@ Format Renderer::getDepthNoStencilFormat() const
 {
 	if(ANKI_PLATFORM_MOBILE)
 	{
-		return Format::X8_D24_UNORM_PACK32;
+		return Format::kX8_D24_Unorm_Pack32;
 	}
 	else
 	{
-		return Format::D32_SFLOAT;
+		return Format::kD32_Sfloat;
 	}
 }
 

AnKi/Renderer/RendererObject.cpp

@@ -64,9 +64,9 @@ U32 RendererObject::computeNumberOfSecondLevelCommandBuffers(U32 drawcallCount)
 {
 	const U32 drawcallsPerThread = drawcallCount / m_r->getThreadHive().getThreadCount();
 	U32 secondLevelCmdbCount;
-	if(drawcallsPerThread < MIN_DRAWCALLS_PER_2ND_LEVEL_COMMAND_BUFFER)
+	if(drawcallsPerThread < kMinDrawcallsPerSecondaryCommandBuffer)
 	{
-		secondLevelCmdbCount = max(1u, drawcallCount / MIN_DRAWCALLS_PER_2ND_LEVEL_COMMAND_BUFFER);
+		secondLevelCmdbCount = max(1u, drawcallCount / kMinDrawcallsPerSecondaryCommandBuffer);
 	}
 	else
 	{

AnKi/Renderer/RendererObject.h

@@ -59,7 +59,7 @@ protected:
 	/// Used in fullscreen quad draws.
 	static void drawQuad(CommandBufferPtr& cmdb)
 	{
-		cmdb->drawArrays(PrimitiveTopology::TRIANGLES, 3, 1);
+		cmdb->drawArrays(PrimitiveTopology::kTriangles, 3, 1);
 	}
 
 	/// Dispatch a compute job equivelent to drawQuad

AnKi/Renderer/RtShadows.cpp

@@ -133,32 +133,30 @@ Error RtShadows::initInternal()
 	// Quarter rez shadow RT
 	{
 		TextureInitInfo texinit = m_r->create2DRenderTargetInitInfo(
-			m_r->getInternalResolution().x() / 2, m_r->getInternalResolution().y() / 2, Format::R32G32_UINT,
-			TextureUsageBit::ALL_SAMPLED | TextureUsageBit::IMAGE_TRACE_RAYS_WRITE
-				| TextureUsageBit::IMAGE_COMPUTE_WRITE,
+			m_r->getInternalResolution().x() / 2, m_r->getInternalResolution().y() / 2, Format::kR32G32_Uint,
+			TextureUsageBit::kAllSampled | TextureUsageBit::kImageTraceRaysWrite | TextureUsageBit::kImageComputeWrite,
 			"RtShadows History");
-		m_historyRt = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::SAMPLED_FRAGMENT);
+		m_historyRt = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
 	}
 
 	// Temp shadow RT
 	{
 		m_intermediateShadowsRtDescr = m_r->create2DRenderTargetDescription(m_r->getInternalResolution().x() / 2,
 																			m_r->getInternalResolution().y() / 2,
-																			Format::R32G32_UINT, "RtShadows Tmp");
+																			Format::kR32G32_Uint, "RtShadows Tmp");
 		m_intermediateShadowsRtDescr.bake();
 	}
 
 	// Moments RT
 	{
 		TextureInitInfo texinit = m_r->create2DRenderTargetInitInfo(
-			m_r->getInternalResolution().x() / 2, m_r->getInternalResolution().y() / 2, Format::R32G32_SFLOAT,
-			TextureUsageBit::ALL_SAMPLED | TextureUsageBit::IMAGE_TRACE_RAYS_WRITE
-				| TextureUsageBit::IMAGE_COMPUTE_WRITE,
+			m_r->getInternalResolution().x() / 2, m_r->getInternalResolution().y() / 2, Format::kR32G32_Sfloat,
+			TextureUsageBit::kAllSampled | TextureUsageBit::kImageTraceRaysWrite | TextureUsageBit::kImageComputeWrite,
 			"RtShadows Moments #1");
-		m_momentsRts[0] = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::SAMPLED_FRAGMENT);
+		m_momentsRts[0] = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
 
 		texinit.setName("RtShadows Moments #2");
-		m_momentsRts[1] = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::SAMPLED_FRAGMENT);
+		m_momentsRts[1] = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
 	}
 
 	// Variance RT
@@ -166,7 +164,7 @@ Error RtShadows::initInternal()
 	{
 		m_varianceRtDescr = m_r->create2DRenderTargetDescription(m_r->getInternalResolution().x() / 2,
 																 m_r->getInternalResolution().y() / 2,
-																 Format::R32_SFLOAT, "RtShadows Variance");
+																 Format::kR32_Sfloat, "RtShadows Variance");
 		m_varianceRtDescr.bake();
 	}
 
@@ -174,7 +172,7 @@ Error RtShadows::initInternal()
 	{
 		m_upscaledRtDescr =
 			m_r->create2DRenderTargetDescription(m_r->getInternalResolution().x(), m_r->getInternalResolution().y(),
-												 Format::R32G32_UINT, "RtShadows Upscaled");
+												 Format::kR32G32_Uint, "RtShadows Upscaled");
 		m_upscaledRtDescr.bake();
 	}
 
@@ -197,10 +195,10 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 	{
 		if(ANKI_UNLIKELY(!m_rtsImportedOnce))
 		{
-			m_runCtx.m_historyRt = rgraph.importRenderTarget(m_historyRt, TextureUsageBit::SAMPLED_FRAGMENT);
+			m_runCtx.m_historyRt = rgraph.importRenderTarget(m_historyRt, TextureUsageBit::kSampledFragment);
 
 			m_runCtx.m_prevMomentsRt =
-				rgraph.importRenderTarget(m_momentsRts[prevRtIdx], TextureUsageBit::SAMPLED_FRAGMENT);
+				rgraph.importRenderTarget(m_momentsRts[prevRtIdx], TextureUsageBit::kSampledFragment);
 
 			m_rtsImportedOnce = true;
 		}
@@ -222,7 +220,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 			m_runCtx.m_intermediateShadowsRts[1] = m_runCtx.m_historyRt;
 		}
 
-		m_runCtx.m_currentMomentsRt = rgraph.importRenderTarget(m_momentsRts[!prevRtIdx], TextureUsageBit::NONE);
+		m_runCtx.m_currentMomentsRt = rgraph.importRenderTarget(m_momentsRts[!prevRtIdx], TextureUsageBit::kNone);
 
 		if(m_useSvgf)
 		{
@@ -237,8 +235,8 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 	}
 
 	const RenderPassDependency depthDependency(m_r->getDepthDownscale().getHiZRt(),
-											   TextureUsageBit::SAMPLED_TRACE_RAYS | TextureUsageBit::SAMPLED_COMPUTE,
-											   HIZ_HALF_DEPTH);
+											   TextureUsageBit::kSampledTraceRays | TextureUsageBit::kSampledCompute,
+											   kHiZHalfSurface);
 
 	// RT shadows pass
 	{
@@ -247,21 +245,21 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 			run(ctx, rgraphCtx);
 		});
 
-		rpass.newDependency(RenderPassDependency(m_runCtx.m_historyRt, TextureUsageBit::SAMPLED_TRACE_RAYS));
+		rpass.newDependency(RenderPassDependency(m_runCtx.m_historyRt, TextureUsageBit::kSampledTraceRays));
 		rpass.newDependency(
-			RenderPassDependency(m_runCtx.m_intermediateShadowsRts[0], TextureUsageBit::IMAGE_TRACE_RAYS_WRITE));
+			RenderPassDependency(m_runCtx.m_intermediateShadowsRts[0], TextureUsageBit::kImageTraceRaysWrite));
 		rpass.newDependency(
 			RenderPassDependency(m_r->getAccelerationStructureBuilder().getAccelerationStructureHandle(),
 								 AccelerationStructureUsageBit::TRACE_RAYS_READ));
 		rpass.newDependency(depthDependency);
 		rpass.newDependency(
-			RenderPassDependency(m_r->getMotionVectors().getMotionVectorsRt(), TextureUsageBit::SAMPLED_TRACE_RAYS));
+			RenderPassDependency(m_r->getMotionVectors().getMotionVectorsRt(), TextureUsageBit::kSampledTraceRays));
 		rpass.newDependency(
-			RenderPassDependency(m_r->getMotionVectors().getHistoryLengthRt(), TextureUsageBit::SAMPLED_TRACE_RAYS));
-		rpass.newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(2), TextureUsageBit::SAMPLED_TRACE_RAYS));
+			RenderPassDependency(m_r->getMotionVectors().getHistoryLengthRt(), TextureUsageBit::kSampledTraceRays));
+		rpass.newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(2), TextureUsageBit::kSampledTraceRays));
 
-		rpass.newDependency(RenderPassDependency(m_runCtx.m_prevMomentsRt, TextureUsageBit::SAMPLED_TRACE_RAYS));
-		rpass.newDependency(RenderPassDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::IMAGE_TRACE_RAYS_WRITE));
+		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));
@@ -276,15 +274,15 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 		});
 
 		rpass.newDependency(
-			RenderPassDependency(m_runCtx.m_intermediateShadowsRts[0], TextureUsageBit::SAMPLED_COMPUTE));
+			RenderPassDependency(m_runCtx.m_intermediateShadowsRts[0], TextureUsageBit::kSampledCompute));
 		rpass.newDependency(depthDependency);
-		rpass.newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(2), TextureUsageBit::SAMPLED_COMPUTE));
-		rpass.newDependency(RenderPassDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::SAMPLED_COMPUTE));
+		rpass.newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(2), TextureUsageBit::kSampledCompute));
+		rpass.newDependency(RenderPassDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kSampledCompute));
 		rpass.newDependency(
-			RenderPassDependency(m_r->getMotionVectors().getHistoryLengthRt(), TextureUsageBit::SAMPLED_COMPUTE));
+			RenderPassDependency(m_r->getMotionVectors().getHistoryLengthRt(), TextureUsageBit::kSampledCompute));
 
 		rpass.newDependency(
-			RenderPassDependency(m_runCtx.m_intermediateShadowsRts[1], TextureUsageBit::IMAGE_COMPUTE_WRITE));
+			RenderPassDependency(m_runCtx.m_intermediateShadowsRts[1], TextureUsageBit::kImageComputeWrite));
 	}
 
 	// Denoise pass vertical
@@ -296,14 +294,14 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 		});
 
 		rpass.newDependency(
-			RenderPassDependency(m_runCtx.m_intermediateShadowsRts[1], TextureUsageBit::SAMPLED_COMPUTE));
+			RenderPassDependency(m_runCtx.m_intermediateShadowsRts[1], TextureUsageBit::kSampledCompute));
 		rpass.newDependency(depthDependency);
-		rpass.newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(2), TextureUsageBit::SAMPLED_COMPUTE));
-		rpass.newDependency(RenderPassDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::SAMPLED_COMPUTE));
+		rpass.newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(2), TextureUsageBit::kSampledCompute));
+		rpass.newDependency(RenderPassDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kSampledCompute));
 		rpass.newDependency(
-			RenderPassDependency(m_r->getMotionVectors().getHistoryLengthRt(), TextureUsageBit::SAMPLED_COMPUTE));
+			RenderPassDependency(m_r->getMotionVectors().getHistoryLengthRt(), TextureUsageBit::kSampledCompute));
 
-		rpass.newDependency(RenderPassDependency(m_runCtx.m_historyRt, TextureUsageBit::IMAGE_COMPUTE_WRITE));
+		rpass.newDependency(RenderPassDependency(m_runCtx.m_historyRt, TextureUsageBit::kImageComputeWrite));
 	}
 
 	// Variance calculation pass
@@ -315,16 +313,16 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 		});
 
 		rpass.newDependency(
-			RenderPassDependency(m_runCtx.m_intermediateShadowsRts[0], TextureUsageBit::SAMPLED_COMPUTE));
-		rpass.newDependency(RenderPassDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::SAMPLED_COMPUTE));
+			RenderPassDependency(m_runCtx.m_intermediateShadowsRts[0], TextureUsageBit::kSampledCompute));
+		rpass.newDependency(RenderPassDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kSampledCompute));
 		rpass.newDependency(
-			RenderPassDependency(m_r->getMotionVectors().getHistoryLengthRt(), TextureUsageBit::SAMPLED_COMPUTE));
+			RenderPassDependency(m_r->getMotionVectors().getHistoryLengthRt(), TextureUsageBit::kSampledCompute));
 		rpass.newDependency(depthDependency);
-		rpass.newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(2), TextureUsageBit::SAMPLED_COMPUTE));
+		rpass.newDependency(RenderPassDependency(m_r->getGBuffer().getColorRt(2), TextureUsageBit::kSampledCompute));
 
 		rpass.newDependency(
-			RenderPassDependency(m_runCtx.m_intermediateShadowsRts[1], TextureUsageBit::IMAGE_COMPUTE_WRITE));
-		rpass.newDependency(RenderPassDependency(m_runCtx.m_varianceRts[1], TextureUsageBit::IMAGE_COMPUTE_WRITE));
+			RenderPassDependency(m_runCtx.m_intermediateShadowsRts[1], TextureUsageBit::kImageComputeWrite));
+		rpass.newDependency(RenderPassDependency(m_runCtx.m_varianceRts[1], TextureUsageBit::kImageComputeWrite));
 	}
 
 	// SVGF Atrous
@@ -344,23 +342,23 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 
 			rpass.newDependency(depthDependency);
 			rpass.newDependency(
-				RenderPassDependency(m_r->getGBuffer().getColorRt(2), TextureUsageBit::SAMPLED_COMPUTE));
+				RenderPassDependency(m_r->getGBuffer().getColorRt(2), TextureUsageBit::kSampledCompute));
 			rpass.newDependency(
-				RenderPassDependency(m_runCtx.m_intermediateShadowsRts[readRtIdx], TextureUsageBit::SAMPLED_COMPUTE));
+				RenderPassDependency(m_runCtx.m_intermediateShadowsRts[readRtIdx], TextureUsageBit::kSampledCompute));
 			rpass.newDependency(
-				RenderPassDependency(m_runCtx.m_varianceRts[readRtIdx], TextureUsageBit::SAMPLED_COMPUTE));
+				RenderPassDependency(m_runCtx.m_varianceRts[readRtIdx], TextureUsageBit::kSampledCompute));
 
 			if(!lastPass)
 			{
 				rpass.newDependency(RenderPassDependency(m_runCtx.m_intermediateShadowsRts[!readRtIdx],
-														 TextureUsageBit::IMAGE_COMPUTE_WRITE));
+														 TextureUsageBit::kImageComputeWrite));
 
 				rpass.newDependency(
-					RenderPassDependency(m_runCtx.m_varianceRts[!readRtIdx], TextureUsageBit::IMAGE_COMPUTE_WRITE));
+					RenderPassDependency(m_runCtx.m_varianceRts[!readRtIdx], TextureUsageBit::kImageComputeWrite));
 			}
 			else
 			{
-				rpass.newDependency(RenderPassDependency(m_runCtx.m_historyRt, TextureUsageBit::IMAGE_COMPUTE_WRITE));
+				rpass.newDependency(RenderPassDependency(m_runCtx.m_historyRt, TextureUsageBit::kImageComputeWrite));
 			}
 		}
 	}
@@ -372,11 +370,11 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 			runUpscale(rgraphCtx);
 		});
 
-		rpass.newDependency(RenderPassDependency(m_runCtx.m_historyRt, TextureUsageBit::SAMPLED_COMPUTE));
-		rpass.newDependency(RenderPassDependency(m_r->getGBuffer().getDepthRt(), TextureUsageBit::SAMPLED_COMPUTE));
+		rpass.newDependency(RenderPassDependency(m_runCtx.m_historyRt, TextureUsageBit::kSampledCompute));
+		rpass.newDependency(RenderPassDependency(m_r->getGBuffer().getDepthRt(), TextureUsageBit::kSampledCompute));
 		rpass.newDependency(depthDependency);
 
-		rpass.newDependency(RenderPassDependency(m_runCtx.m_upscaledRt, TextureUsageBit::IMAGE_COMPUTE_WRITE));
+		rpass.newDependency(RenderPassDependency(m_runCtx.m_upscaledRt, TextureUsageBit::kImageComputeWrite));
 	}
 
 	// Find out the lights that will take part in RT pass
@@ -468,7 +466,7 @@ void RtShadows::run(const RenderingContext& ctx, RenderPassWorkContext& rgraphCt
 	rgraphCtx.bindColorTexture(0, 7, m_runCtx.m_historyRt);
 	cmdb->bindSampler(0, 8, m_r->getSamplers().m_trilinearClamp);
 	cmdb->bindSampler(0, 9, m_r->getSamplers().m_nearestNearestClamp);
-	rgraphCtx.bindTexture(0, 10, m_r->getDepthDownscale().getHiZRt(), HIZ_HALF_DEPTH);
+	rgraphCtx.bindTexture(0, 10, m_r->getDepthDownscale().getHiZRt(), kHiZHalfSurface);
 	rgraphCtx.bindColorTexture(0, 11, m_r->getMotionVectors().getMotionVectorsRt());
 	rgraphCtx.bindColorTexture(0, 12, m_r->getMotionVectors().getHistoryLengthRt());
 	rgraphCtx.bindColorTexture(0, 13, m_r->getGBuffer().getColorRt(2));
@@ -499,7 +497,7 @@ void RtShadows::runDenoise(const RenderingContext& ctx, RenderPassWorkContext& r
 	cmdb->bindSampler(0, 0, m_r->getSamplers().m_nearestNearestClamp);
 	cmdb->bindSampler(0, 1, m_r->getSamplers().m_trilinearClamp);
 	rgraphCtx.bindColorTexture(0, 2, m_runCtx.m_intermediateShadowsRts[m_runCtx.m_denoiseOrientation]);
-	rgraphCtx.bindTexture(0, 3, m_r->getDepthDownscale().getHiZRt(), HIZ_HALF_DEPTH);
+	rgraphCtx.bindTexture(0, 3, m_r->getDepthDownscale().getHiZRt(), kHiZHalfSurface);
 	rgraphCtx.bindColorTexture(0, 4, m_r->getGBuffer().getColorRt(2));
 	rgraphCtx.bindColorTexture(0, 5, m_runCtx.m_currentMomentsRt);
 	rgraphCtx.bindColorTexture(0, 6, m_r->getMotionVectors().getHistoryLengthRt());
@@ -529,7 +527,7 @@ void RtShadows::runSvgfVariance(const RenderingContext& ctx, RenderPassWorkConte
 	rgraphCtx.bindColorTexture(0, 2, m_runCtx.m_intermediateShadowsRts[0]);
 	rgraphCtx.bindColorTexture(0, 3, m_runCtx.m_currentMomentsRt);
 	rgraphCtx.bindColorTexture(0, 4, m_r->getMotionVectors().getHistoryLengthRt());
-	rgraphCtx.bindTexture(0, 5, m_r->getDepthDownscale().getHiZRt(), HIZ_HALF_DEPTH);
+	rgraphCtx.bindTexture(0, 5, m_r->getDepthDownscale().getHiZRt(), kHiZHalfSurface);
 
 	rgraphCtx.bindImage(0, 6, m_runCtx.m_intermediateShadowsRts[1]);
 	rgraphCtx.bindImage(0, 7, m_runCtx.m_varianceRts[1]);
@@ -559,7 +557,7 @@ void RtShadows::runSvgfAtrous(const RenderingContext& ctx, RenderPassWorkContext
 	cmdb->bindSampler(0, 0, m_r->getSamplers().m_nearestNearestClamp);
 	cmdb->bindSampler(0, 1, m_r->getSamplers().m_trilinearClamp);
 
-	rgraphCtx.bindTexture(0, 2, m_r->getDepthDownscale().getHiZRt(), HIZ_HALF_DEPTH);
+	rgraphCtx.bindTexture(0, 2, m_r->getDepthDownscale().getHiZRt(), kHiZHalfSurface);
 	rgraphCtx.bindColorTexture(0, 3, m_runCtx.m_intermediateShadowsRts[readRtIdx]);
 	rgraphCtx.bindColorTexture(0, 4, m_runCtx.m_varianceRts[readRtIdx]);
 
@@ -592,8 +590,8 @@ void RtShadows::runUpscale(RenderPassWorkContext& rgraphCtx)
 
 	rgraphCtx.bindColorTexture(0, 2, m_runCtx.m_historyRt);
 	rgraphCtx.bindImage(0, 3, m_runCtx.m_upscaledRt);
-	rgraphCtx.bindTexture(0, 4, m_r->getDepthDownscale().getHiZRt(), HIZ_HALF_DEPTH);
-	rgraphCtx.bindTexture(0, 5, m_r->getGBuffer().getDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::DEPTH));
+	rgraphCtx.bindTexture(0, 4, m_r->getDepthDownscale().getHiZRt(), kHiZHalfSurface);
+	rgraphCtx.bindTexture(0, 5, m_r->getGBuffer().getDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
 	dispatchPPCompute(cmdb, 8, 8, m_r->getInternalResolution().x(), m_r->getInternalResolution().y());
 }

AnKi/Renderer/Scale.cpp

@@ -149,11 +149,11 @@ Error Scale::init()
 	}
 	else if(getGrManager().getDeviceCapabilities().m_unalignedBbpTextureFormats)
 	{
-		format = Format::R8G8B8_UNORM;
+		format = Format::kR8G8B8_Unorm;
 	}
 	else
 	{
-		format = Format::R8G8B8A8_UNORM;
+		format = Format::kR8G8B8A8_Unorm;
 	}
 
 	m_upscaleAndSharpenRtDescr = m_r->create2DRenderTargetDescription(
@@ -163,8 +163,8 @@ Error Scale::init()
 	if(m_neeedsTonemapping)
 	{
 		const Format fmt = (getGrManager().getDeviceCapabilities().m_unalignedBbpTextureFormats)
-							   ? Format::R8G8B8_UNORM
-							   : Format::R8G8B8A8_UNORM;
+							   ? Format::kR8G8B8_Unorm
+							   : Format::kR8G8B8A8_Unorm;
 		m_tonemapedRtDescr = m_r->create2DRenderTargetDescription(
 			m_r->getPostProcessResolution().x(), m_r->getPostProcessResolution().y(), fmt, "Tonemapped");
 		m_tonemapedRtDescr.bake();
@@ -199,13 +199,13 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		ComputeRenderPassDescription& pass = ctx.m_renderGraphDescr.newComputeRenderPass("DLSS");
 
 		// DLSS says input textures in sampled state and out as storage image
-		const TextureUsageBit readUsage = TextureUsageBit::ALL_SAMPLED & TextureUsageBit::ALL_COMPUTE;
-		const TextureUsageBit writeUsage = TextureUsageBit::ALL_IMAGE & TextureUsageBit::ALL_COMPUTE;
+		const TextureUsageBit readUsage = TextureUsageBit::kAllSampled & TextureUsageBit::kAllCompute;
+		const TextureUsageBit writeUsage = TextureUsageBit::kAllImage & TextureUsageBit::kAllCompute;
 
 		pass.newDependency(RenderPassDependency(m_r->getLightShading().getRt(), readUsage));
 		pass.newDependency(RenderPassDependency(m_r->getMotionVectors().getMotionVectorsRt(), readUsage));
 		pass.newDependency(RenderPassDependency(m_r->getGBuffer().getDepthRt(), readUsage,
-												TextureSubresourceInfo(DepthStencilAspectBit::DEPTH)));
+												TextureSubresourceInfo(DepthStencilAspectBit::kDepth)));
 		pass.newDependency(RenderPassDependency(m_runCtx.m_upscaledHdrRt, writeUsage));
 
 		pass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
@@ -222,8 +222,8 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		if(preferCompute)
 		{
 			ComputeRenderPassDescription& pass = ctx.m_renderGraphDescr.newComputeRenderPass("Scale");
-			pass.newDependency(RenderPassDependency(inRt, TextureUsageBit::SAMPLED_COMPUTE));
-			pass.newDependency(RenderPassDependency(outRt, TextureUsageBit::IMAGE_COMPUTE_WRITE));
+			pass.newDependency(RenderPassDependency(inRt, TextureUsageBit::kSampledCompute));
+			pass.newDependency(RenderPassDependency(outRt, TextureUsageBit::kImageComputeWrite));
 
 			pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 				runFsrOrBilinearScaling(rgraphCtx);
@@ -233,8 +233,8 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		{
 			GraphicsRenderPassDescription& pass = ctx.m_renderGraphDescr.newGraphicsRenderPass("Scale");
 			pass.setFramebufferInfo(m_fbDescr, {outRt});
-			pass.newDependency(RenderPassDependency(inRt, TextureUsageBit::SAMPLED_FRAGMENT));
-			pass.newDependency(RenderPassDependency(outRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE));
+			pass.newDependency(RenderPassDependency(inRt, TextureUsageBit::kSampledFragment));
+			pass.newDependency(RenderPassDependency(outRt, TextureUsageBit::kFramebufferWrite));
 
 			pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 				runFsrOrBilinearScaling(rgraphCtx);
@@ -259,8 +259,8 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		if(preferCompute)
 		{
 			ComputeRenderPassDescription& pass = ctx.m_renderGraphDescr.newComputeRenderPass("Tonemap");
-			pass.newDependency(RenderPassDependency(inRt, TextureUsageBit::SAMPLED_COMPUTE));
-			pass.newDependency(RenderPassDependency(outRt, TextureUsageBit::IMAGE_COMPUTE_WRITE));
+			pass.newDependency(RenderPassDependency(inRt, TextureUsageBit::kSampledCompute));
+			pass.newDependency(RenderPassDependency(outRt, TextureUsageBit::kImageComputeWrite));
 
 			pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 				runTonemapping(rgraphCtx);
@@ -270,8 +270,8 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		{
 			GraphicsRenderPassDescription& pass = ctx.m_renderGraphDescr.newGraphicsRenderPass("Sharpen");
 			pass.setFramebufferInfo(m_fbDescr, {outRt});
-			pass.newDependency(RenderPassDependency(inRt, TextureUsageBit::SAMPLED_FRAGMENT));
-			pass.newDependency(RenderPassDependency(outRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE));
+			pass.newDependency(RenderPassDependency(inRt, TextureUsageBit::kSampledFragment));
+			pass.newDependency(RenderPassDependency(outRt, TextureUsageBit::kFramebufferWrite));
 
 			pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 				runTonemapping(rgraphCtx);
@@ -293,8 +293,8 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		if(preferCompute)
 		{
 			ComputeRenderPassDescription& pass = ctx.m_renderGraphDescr.newComputeRenderPass("Sharpen");
-			pass.newDependency(RenderPassDependency(inRt, TextureUsageBit::SAMPLED_COMPUTE));
-			pass.newDependency(RenderPassDependency(outRt, TextureUsageBit::IMAGE_COMPUTE_WRITE));
+			pass.newDependency(RenderPassDependency(inRt, TextureUsageBit::kSampledCompute));
+			pass.newDependency(RenderPassDependency(outRt, TextureUsageBit::kImageComputeWrite));
 
 			pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 				runRcasSharpening(rgraphCtx);
@@ -304,8 +304,8 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		{
 			GraphicsRenderPassDescription& pass = ctx.m_renderGraphDescr.newGraphicsRenderPass("Sharpen");
 			pass.setFramebufferInfo(m_fbDescr, {outRt});
-			pass.newDependency(RenderPassDependency(inRt, TextureUsageBit::SAMPLED_FRAGMENT));
-			pass.newDependency(RenderPassDependency(outRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE));
+			pass.newDependency(RenderPassDependency(inRt, TextureUsageBit::kSampledFragment));
+			pass.newDependency(RenderPassDependency(outRt, TextureUsageBit::kFramebufferWrite));
 
 			pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 				runRcasSharpening(rgraphCtx);
@@ -380,7 +380,7 @@ void Scale::runFsrOrBilinearScaling(RenderPassWorkContext& rgraphCtx)
 	else
 	{
 		cmdb->setViewport(0, 0, m_r->getPostProcessResolution().x(), m_r->getPostProcessResolution().y());
-		cmdb->drawArrays(PrimitiveTopology::TRIANGLES, 3);
+		cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
 	}
 }
 
@@ -428,7 +428,7 @@ void Scale::runRcasSharpening(RenderPassWorkContext& rgraphCtx)
 	else
 	{
 		cmdb->setViewport(0, 0, m_r->getPostProcessResolution().x(), m_r->getPostProcessResolution().y());
-		cmdb->drawArrays(PrimitiveTopology::TRIANGLES, 3);
+		cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
 	}
 }
 
@@ -484,7 +484,7 @@ void Scale::runTonemapping(RenderPassWorkContext& rgraphCtx)
 	else
 	{
 		cmdb->setViewport(0, 0, m_r->getPostProcessResolution().x(), m_r->getPostProcessResolution().y());
-		cmdb->drawArrays(PrimitiveTopology::TRIANGLES, 3);
+		cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
 	}
 }
 

AnKi/Renderer/ShadowMapping.cpp

@@ -83,7 +83,7 @@ Error ShadowMapping::initScratch()
 		// FB
 		m_scratch.m_fbDescr.m_depthStencilAttachment.m_loadOperation = AttachmentLoadOperation::CLEAR;
 		m_scratch.m_fbDescr.m_depthStencilAttachment.m_clearValue.m_depthStencil.m_depth = 1.0f;
-		m_scratch.m_fbDescr.m_depthStencilAttachment.m_aspect = DepthStencilAspectBit::DEPTH;
+		m_scratch.m_fbDescr.m_depthStencilAttachment.m_aspect = DepthStencilAspectBit::kDepth;
 		m_scratch.m_fbDescr.bake();
 	}
 
@@ -102,15 +102,15 @@ Error ShadowMapping::initAtlas()
 		m_atlas.m_tileCountBothAxis = getConfig().getRShadowMappingTileCountPerRowOrColumn();
 
 		// RT
-		const Format texFormat = (ANKI_EVSM4) ? Format::R32G32B32A32_SFLOAT : Format::R32G32_SFLOAT;
-		TextureUsageBit usage = TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::SAMPLED_COMPUTE;
-		usage |= (preferCompute) ? TextureUsageBit::IMAGE_COMPUTE_WRITE : TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT;
+		const Format texFormat = (ANKI_EVSM4) ? Format::kR32G32B32A32_Sfloat : Format::kR32G32_Sfloat;
+		TextureUsageBit usage = TextureUsageBit::kSampledFragment | TextureUsageBit::kSampledCompute;
+		usage |= (preferCompute) ? TextureUsageBit::kImageComputeWrite : TextureUsageBit::kAllFramebuffer;
 		TextureInitInfo texinit = m_r->create2DRenderTargetInitInfo(
 			m_atlas.m_tileResolution * m_atlas.m_tileCountBothAxis,
 			m_atlas.m_tileResolution * m_atlas.m_tileCountBothAxis, texFormat, usage, "SM atlas");
 		ClearValue clearVal;
 		clearVal.m_colorf[0] = 1.0f;
-		m_atlas.m_tex = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::SAMPLED_FRAGMENT, clearVal);
+		m_atlas.m_tex = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment, clearVal);
 	}
 
 	// Tiles
@@ -182,7 +182,7 @@ void ShadowMapping::runAtlas(RenderPassWorkContext& rgraphCtx)
 
 	// Continue
 	cmdb->bindSampler(0, 1, m_r->getSamplers().m_trilinearClamp);
-	rgraphCtx.bindTexture(0, 2, m_scratch.m_rt, TextureSubresourceInfo(DepthStencilAspectBit::DEPTH));
+	rgraphCtx.bindTexture(0, 2, m_scratch.m_rt, TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
 	if(getConfig().getRPreferCompute())
 	{
@@ -198,7 +198,7 @@ void ShadowMapping::runAtlas(RenderPassWorkContext& rgraphCtx)
 	{
 		cmdb->setViewport(0, 0, m_atlas.m_tex->getWidth(), m_atlas.m_tex->getHeight());
 
-		cmdb->drawArrays(PrimitiveTopology::TRIANGLES, 6, m_atlas.m_resolveWorkItems.getSize());
+		cmdb->drawArrays(PrimitiveTopology::kTriangles, 6, m_atlas.m_resolveWorkItems.getSize());
 	}
 }
 
@@ -268,8 +268,8 @@ void ShadowMapping::populateRenderGraph(RenderingContext& ctx)
 				runShadowMapping(rgraphCtx);
 			});
 
-			TextureSubresourceInfo subresource = TextureSubresourceInfo(DepthStencilAspectBit::DEPTH);
-			pass.newDependency({m_scratch.m_rt, TextureUsageBit::ALL_FRAMEBUFFER_ATTACHMENT, subresource});
+			TextureSubresourceInfo subresource = TextureSubresourceInfo(DepthStencilAspectBit::kDepth);
+			pass.newDependency({m_scratch.m_rt, TextureUsageBit::kAllFramebuffer, subresource});
 		}
 
 		// Atlas pass
@@ -280,7 +280,7 @@ void ShadowMapping::populateRenderGraph(RenderingContext& ctx)
 			}
 			else
 			{
-				m_atlas.m_rt = rgraph.importRenderTarget(m_atlas.m_tex, TextureUsageBit::SAMPLED_FRAGMENT);
+				m_atlas.m_rt = rgraph.importRenderTarget(m_atlas.m_tex, TextureUsageBit::kSampledFragment);
 				m_atlas.m_rtImportedOnce = true;
 			}
 
@@ -292,9 +292,9 @@ void ShadowMapping::populateRenderGraph(RenderingContext& ctx)
 					runAtlas(rgraphCtx);
 				});
 
-				pass.newDependency(RenderPassDependency(m_scratch.m_rt, TextureUsageBit::SAMPLED_COMPUTE,
-														TextureSubresourceInfo(DepthStencilAspectBit::DEPTH)));
-				pass.newDependency(RenderPassDependency(m_atlas.m_rt, TextureUsageBit::IMAGE_COMPUTE_WRITE));
+				pass.newDependency(RenderPassDependency(m_scratch.m_rt, TextureUsageBit::kSampledCompute,
+														TextureSubresourceInfo(DepthStencilAspectBit::kDepth)));
+				pass.newDependency(RenderPassDependency(m_atlas.m_rt, TextureUsageBit::kImageComputeWrite));
 			}
 			else
 			{
@@ -305,11 +305,10 @@ void ShadowMapping::populateRenderGraph(RenderingContext& ctx)
 					runAtlas(rgraphCtx);
 				});
 
-				pass.newDependency(RenderPassDependency(m_scratch.m_rt, TextureUsageBit::SAMPLED_FRAGMENT,
-														TextureSubresourceInfo(DepthStencilAspectBit::DEPTH)));
-				pass.newDependency(
-					RenderPassDependency(m_atlas.m_rt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ
-														   | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE));
+				pass.newDependency(RenderPassDependency(m_scratch.m_rt, TextureUsageBit::kSampledFragment,
+														TextureSubresourceInfo(DepthStencilAspectBit::kDepth)));
+				pass.newDependency(RenderPassDependency(m_atlas.m_rt, TextureUsageBit::kFramebufferRead
+																		  | TextureUsageBit::kFramebufferWrite));
 			}
 		}
 	}
@@ -322,7 +321,7 @@ void ShadowMapping::populateRenderGraph(RenderingContext& ctx)
 		}
 		else
 		{
-			m_atlas.m_rt = rgraph.importRenderTarget(m_atlas.m_tex, TextureUsageBit::SAMPLED_FRAGMENT);
+			m_atlas.m_rt = rgraph.importRenderTarget(m_atlas.m_tex, TextureUsageBit::kSampledFragment);
 			m_atlas.m_rtImportedOnce = true;
 		}
 	}

AnKi/Renderer/ShadowmapsResolve.cpp

@@ -35,7 +35,7 @@ Error ShadowmapsResolve::initInternal()
 
 	ANKI_R_LOGV("Initializing shadowmaps resolve. Resolution %ux%u", width, height);
 
-	m_rtDescr = m_r->create2DRenderTargetDescription(width, height, Format::R8G8B8A8_UNORM, "SM resolve");
+	m_rtDescr = m_r->create2DRenderTargetDescription(width, height, Format::kR8G8B8A8_Unorm, "SM resolve");
 	m_rtDescr.bake();
 
 	// Create FB descr
@@ -75,12 +75,12 @@ void ShadowmapsResolve::populateRenderGraph(RenderingContext& ctx)
 			run(ctx, rgraphCtx);
 		});
 
-		rpass.newDependency(RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::IMAGE_COMPUTE_WRITE));
+		rpass.newDependency(RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::kImageComputeWrite));
 		rpass.newDependency(
 			RenderPassDependency((m_quarterRez) ? m_r->getDepthDownscale().getHiZRt() : m_r->getGBuffer().getDepthRt(),
-								 TextureUsageBit::SAMPLED_COMPUTE, TextureSurfaceInfo(0, 0, 0, 0)));
+								 TextureUsageBit::kSampledCompute, TextureSurfaceInfo(0, 0, 0, 0)));
 		rpass.newDependency(
-			RenderPassDependency(m_r->getShadowMapping().getShadowmapRt(), TextureUsageBit::SAMPLED_COMPUTE));
+			RenderPassDependency(m_r->getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledCompute));
 
 		rpass.newDependency(
 			RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::STORAGE_COMPUTE_READ));
@@ -94,12 +94,12 @@ void ShadowmapsResolve::populateRenderGraph(RenderingContext& ctx)
 			run(ctx, rgraphCtx);
 		});
 
-		rpass.newDependency(RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE));
+		rpass.newDependency(RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite));
 		rpass.newDependency(
 			RenderPassDependency((m_quarterRez) ? m_r->getDepthDownscale().getHiZRt() : m_r->getGBuffer().getDepthRt(),
-								 TextureUsageBit::SAMPLED_FRAGMENT, TextureSurfaceInfo(0, 0, 0, 0)));
+								 TextureUsageBit::kSampledFragment, TextureSurfaceInfo(0, 0, 0, 0)));
 		rpass.newDependency(
-			RenderPassDependency(m_r->getShadowMapping().getShadowmapRt(), TextureUsageBit::SAMPLED_FRAGMENT));
+			RenderPassDependency(m_r->getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledFragment));
 
 		rpass.newDependency(
 			RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::STORAGE_FRAGMENT_READ));
@@ -128,7 +128,7 @@ void ShadowmapsResolve::run(const RenderingContext& ctx, RenderPassWorkContext&
 	else
 	{
 		rgraphCtx.bindTexture(0, 6, m_r->getGBuffer().getDepthRt(),
-							  TextureSubresourceInfo(DepthStencilAspectBit::DEPTH));
+							  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 	}
 
 	if(getConfig().getRPreferCompute())
@@ -139,7 +139,7 @@ void ShadowmapsResolve::run(const RenderingContext& ctx, RenderPassWorkContext&
 	else
 	{
 		cmdb->setViewport(0, 0, m_rtDescr.m_width, m_rtDescr.m_height);
-		cmdb->drawArrays(PrimitiveTopology::TRIANGLES, 3);
+		cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
 	}
 }
 

AnKi/Renderer/TemporalAA.cpp

@@ -62,21 +62,21 @@ Error TemporalAA::initInternal()
 
 	for(U i = 0; i < 2; ++i)
 	{
-		TextureUsageBit usage = TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::SAMPLED_COMPUTE;
-		usage |= (getConfig().getRPreferCompute()) ? TextureUsageBit::IMAGE_COMPUTE_WRITE
-												   : TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE;
+		TextureUsageBit usage = TextureUsageBit::kSampledFragment | TextureUsageBit::kSampledCompute;
+		usage |= (getConfig().getRPreferCompute()) ? TextureUsageBit::kImageComputeWrite
+												   : TextureUsageBit::kFramebufferWrite;
 
 		TextureInitInfo texinit =
 			m_r->create2DRenderTargetInitInfo(m_r->getInternalResolution().x(), m_r->getInternalResolution().y(),
 											  m_r->getHdrFormat(), usage, "TemporalAA");
 
-		m_rtTextures[i] = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::SAMPLED_FRAGMENT);
+		m_rtTextures[i] = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
 	}
 
 	m_tonemappedRtDescr = m_r->create2DRenderTargetDescription(
 		m_r->getInternalResolution().x(), m_r->getInternalResolution().y(),
-		(getGrManager().getDeviceCapabilities().m_unalignedBbpTextureFormats) ? Format::R8G8B8_UNORM
-																			  : Format::R8G8B8A8_UNORM,
+		(getGrManager().getDeviceCapabilities().m_unalignedBbpTextureFormats) ? Format::kR8G8B8_Unorm
+																			  : Format::kR8G8B8A8_Unorm,
 		"TemporalAA Tonemapped");
 	m_tonemappedRtDescr.bake();
 
@@ -101,11 +101,11 @@ void TemporalAA::populateRenderGraph(RenderingContext& ctx)
 	}
 	else
 	{
-		m_runCtx.m_historyRt = rgraph.importRenderTarget(m_rtTextures[historyRtIdx], TextureUsageBit::SAMPLED_FRAGMENT);
+		m_runCtx.m_historyRt = rgraph.importRenderTarget(m_rtTextures[historyRtIdx], TextureUsageBit::kSampledFragment);
 		m_rtTexturesImportedOnce[historyRtIdx] = true;
 	}
 
-	m_runCtx.m_renderRt = rgraph.importRenderTarget(m_rtTextures[renderRtIdx], TextureUsageBit::NONE);
+	m_runCtx.m_renderRt = rgraph.importRenderTarget(m_rtTextures[renderRtIdx], TextureUsageBit::kNone);
 	m_runCtx.m_tonemappedRt = rgraph.newRenderTarget(m_tonemappedRtDescr);
 
 	// Create pass
@@ -115,10 +115,10 @@ void TemporalAA::populateRenderGraph(RenderingContext& ctx)
 	{
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("TemporalAA");
 
-		pass.newDependency(RenderPassDependency(m_runCtx.m_renderRt, TextureUsageBit::IMAGE_COMPUTE_WRITE));
-		pass.newDependency(RenderPassDependency(m_runCtx.m_tonemappedRt, TextureUsageBit::IMAGE_COMPUTE_WRITE));
+		pass.newDependency(RenderPassDependency(m_runCtx.m_renderRt, TextureUsageBit::kImageComputeWrite));
+		pass.newDependency(RenderPassDependency(m_runCtx.m_tonemappedRt, TextureUsageBit::kImageComputeWrite));
 
-		readUsage = TextureUsageBit::SAMPLED_COMPUTE;
+		readUsage = TextureUsageBit::kSampledCompute;
 
 		prpass = &pass;
 	}
@@ -127,17 +127,16 @@ void TemporalAA::populateRenderGraph(RenderingContext& ctx)
 		GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass("TemporalAA");
 		pass.setFramebufferInfo(m_fbDescr, {m_runCtx.m_renderRt, m_runCtx.m_tonemappedRt});
 
-		pass.newDependency(RenderPassDependency(m_runCtx.m_renderRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE));
-		pass.newDependency(
-			RenderPassDependency(m_runCtx.m_tonemappedRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE));
+		pass.newDependency(RenderPassDependency(m_runCtx.m_renderRt, TextureUsageBit::kFramebufferWrite));
+		pass.newDependency(RenderPassDependency(m_runCtx.m_tonemappedRt, TextureUsageBit::kFramebufferWrite));
 
-		readUsage = TextureUsageBit::SAMPLED_FRAGMENT;
+		readUsage = TextureUsageBit::kSampledFragment;
 
 		prpass = &pass;
 	}
 
 	prpass->newDependency(RenderPassDependency(m_r->getGBuffer().getDepthRt(), readUsage,
-											   TextureSubresourceInfo(DepthStencilAspectBit::DEPTH)));
+											   TextureSubresourceInfo(DepthStencilAspectBit::kDepth)));
 	prpass->newDependency(RenderPassDependency(m_r->getLightShading().getRt(), readUsage));
 	prpass->newDependency(RenderPassDependency(m_runCtx.m_historyRt, readUsage));
 	prpass->newDependency(RenderPassDependency(m_r->getMotionVectors().getMotionVectorsRt(), readUsage));
@@ -149,7 +148,7 @@ void TemporalAA::populateRenderGraph(RenderingContext& ctx)
 
 		cmdb->bindSampler(0, 0, m_r->getSamplers().m_trilinearClamp);
 		rgraphCtx.bindTexture(0, 1, m_r->getGBuffer().getDepthRt(),
-							  TextureSubresourceInfo(DepthStencilAspectBit::DEPTH));
+							  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 		rgraphCtx.bindColorTexture(0, 2, m_r->getLightShading().getRt());
 		rgraphCtx.bindColorTexture(0, 3, m_runCtx.m_historyRt);
 		rgraphCtx.bindColorTexture(0, 4, m_r->getMotionVectors().getMotionVectorsRt());
@@ -166,7 +165,7 @@ void TemporalAA::populateRenderGraph(RenderingContext& ctx)
 		{
 			cmdb->setViewport(0, 0, m_r->getInternalResolution().x(), m_r->getInternalResolution().y());
 
-			cmdb->drawArrays(PrimitiveTopology::TRIANGLES, 3);
+			cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
 		}
 	});
 }

AnKi/Renderer/Tonemapping.cpp

@@ -41,12 +41,12 @@ 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::ALL_IMAGE;
+	const TextureUsageBit usage = TextureUsageBit::kAllImage;
 	const TextureInitInfo texinit =
-		m_r->create2DRenderTargetInitInfo(1, 1, Format::R16G16_SFLOAT, usage, "ExposureAndAvgLum1x1");
+		m_r->create2DRenderTargetInitInfo(1, 1, Format::kR16G16_Sfloat, usage, "ExposureAndAvgLum1x1");
 	ClearValue clearValue;
 	clearValue.m_colorf = {0.5f, 0.5f, 0.5f, 0.5f};
-	m_exposureAndAvgLuminance1x1 = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::ALL_IMAGE, clearValue);
+	m_exposureAndAvgLuminance1x1 = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::kAllImage, clearValue);
 
 	return Error::NONE;
 }
@@ -55,7 +55,7 @@ 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, TextureUsageBit::ALL_IMAGE);
+		ctx.m_renderGraphDescr.importRenderTarget(m_exposureAndAvgLuminance1x1, TextureUsageBit::kAllImage);
 }
 
 void Tonemapping::populateRenderGraph(RenderingContext& ctx)
@@ -80,7 +80,7 @@ void Tonemapping::populateRenderGraph(RenderingContext& ctx)
 
 	TextureSubresourceInfo inputTexSubresource;
 	inputTexSubresource.m_firstMipmap = m_inputTexMip;
-	pass.newDependency({m_r->getDownscaleBlur().getRt(), TextureUsageBit::SAMPLED_COMPUTE, inputTexSubresource});
+	pass.newDependency({m_r->getDownscaleBlur().getRt(), TextureUsageBit::kSampledCompute, inputTexSubresource});
 }
 
 } // end namespace anki

AnKi/Renderer/TraditionalDeferredShading.cpp

@@ -55,10 +55,10 @@ Error TraditionalDeferredLightShading::init()
 	// Shadow sampler
 	{
 		SamplerInitInfo inf;
-		inf.m_compareOperation = CompareOperation::LESS_EQUAL;
-		inf.m_addressing = SamplingAddressing::CLAMP;
-		inf.m_mipmapFilter = SamplingFilter::BASE;
-		inf.m_minMagFilter = SamplingFilter::LINEAR;
+		inf.m_compareOperation = CompareOperation::kLessEqual;
+		inf.m_addressing = SamplingAddressing::kClamp;
+		inf.m_mipmapFilter = SamplingFilter::kBase;
+		inf.m_minMagFilter = SamplingFilter::kLinear;
 		m_shadowSampler = getGrManager().newSampler(inf);
 	}
 
@@ -121,7 +121,7 @@ void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShading
 
 		cmdb->bindSampler(0, 0, m_r->getSamplers().m_nearestNearestClamp);
 		rgraphCtx.bindTexture(0, 1, info.m_gbufferDepthRenderTarget,
-							  TextureSubresourceInfo(DepthStencilAspectBit::DEPTH));
+							  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
 		if(!isSolidColor)
 		{
@@ -142,7 +142,7 @@ void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShading
 
 	// Set common state for all light drawcalls
 	{
-		cmdb->setBlendFactors(0, BlendFactor::ONE, BlendFactor::ONE);
+		cmdb->setBlendFactors(0, BlendFactor::kOne, BlendFactor::kOne);
 
 		// NOTE: Use nearest sampler because we don't want the result to sample the near tiles
 		cmdb->bindSampler(0, 2, m_r->getSamplers().m_nearestNearestClamp);
@@ -152,7 +152,7 @@ void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShading
 		rgraphCtx.bindColorTexture(0, 5, info.m_gbufferRenderTargets[2]);
 
 		rgraphCtx.bindTexture(0, 6, info.m_gbufferDepthRenderTarget,
-							  TextureSubresourceInfo(DepthStencilAspectBit::DEPTH));
+							  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
 		// Set shadowmap resources
 		cmdb->bindSampler(0, 7, m_shadowSampler);
@@ -162,7 +162,7 @@ void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShading
 			ANKI_ASSERT(info.m_directionalLightShadowmapRenderTarget.isValid());
 
 			rgraphCtx.bindTexture(0, 8, info.m_directionalLightShadowmapRenderTarget,
-								  TextureSubresourceInfo(DepthStencilAspectBit::DEPTH));
+								  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 		}
 		else
 		{
@@ -209,7 +209,7 @@ void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShading
 	}
 
 	// Set other light state
-	cmdb->setCullMode(FaceSelectionBit::FRONT);
+	cmdb->setCullMode(FaceSelectionBit::kFront);
 
 	// Do point lights
 	U32 indexCount;
@@ -240,7 +240,7 @@ void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShading
 		light->m_diffuseColor = plightEl.m_diffuseColor;
 
 		// Draw
-		cmdb->drawElements(PrimitiveTopology::TRIANGLES, indexCount);
+		cmdb->drawElements(PrimitiveTopology::kTriangles, indexCount);
 	}
 
 	// Do spot lights
@@ -288,12 +288,12 @@ void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShading
 		light->m_innerCos = cos(splightEl.m_innerAngle / 2.0f);
 
 		// Draw
-		cmdb->drawElements(PrimitiveTopology::TRIANGLES, indexCount);
+		cmdb->drawElements(PrimitiveTopology::kTriangles, indexCount);
 	}
 
 	// Restore state
-	cmdb->setBlendFactors(0, BlendFactor::ONE, BlendFactor::ZERO);
-	cmdb->setCullMode(FaceSelectionBit::BACK);
+	cmdb->setBlendFactors(0, BlendFactor::kOne, BlendFactor::kZero);
+	cmdb->setCullMode(FaceSelectionBit::kBack);
 }
 
 } // end namespace anki

AnKi/Renderer/TraditionalDeferredShading.h

@@ -35,7 +35,7 @@ public:
 	Bool m_computeSpecular = false;
 
 	// Render targets
-	Array<RenderTargetHandle, GBUFFER_COLOR_ATTACHMENT_COUNT - 1> m_gbufferRenderTargets;
+	Array<RenderTargetHandle, kGBufferColorRenderTargetCount - 1> m_gbufferRenderTargets;
 	RenderTargetHandle m_gbufferDepthRenderTarget;
 	RenderTargetHandle m_directionalLightShadowmapRenderTarget;
 

AnKi/Renderer/UiStage.cpp

@@ -52,9 +52,9 @@ void UiStage::draw(U32 width, U32 height, RenderingContext& ctx, CommandBufferPt
 	m_canvas->appendToCommandBuffer(cmdb);
 
 	// UI messes with the state, restore it
-	cmdb->setBlendFactors(0, BlendFactor::ONE, BlendFactor::ZERO);
-	cmdb->setBlendOperation(0, BlendOperation::ADD);
-	cmdb->setCullMode(FaceSelectionBit::BACK);
+	cmdb->setBlendFactors(0, BlendFactor::kOne, BlendFactor::kZero);
+	cmdb->setBlendOperation(0, BlendOperation::kAdd);
+	cmdb->setCullMode(FaceSelectionBit::kBack);
 }
 
 } // end namespace anki

AnKi/Renderer/VolumetricFog.cpp

@@ -43,9 +43,9 @@ Error VolumetricFog::init()
 
 	// RT descr
 	m_rtDescr =
-		m_r->create2DRenderTargetDescription(m_volumeSize[0], m_volumeSize[1], Format::R16G16B16A16_SFLOAT, "Fog");
+		m_r->create2DRenderTargetDescription(m_volumeSize[0], m_volumeSize[1], Format::kR16G16B16A16_Sfloat, "Fog");
 	m_rtDescr.m_depth = m_volumeSize[2];
-	m_rtDescr.m_type = TextureType::_3D;
+	m_rtDescr.m_type = TextureType::k3D;
 	m_rtDescr.bake();
 
 	return Error::NONE;
@@ -59,8 +59,8 @@ void VolumetricFog::populateRenderGraph(RenderingContext& ctx)
 
 	ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("Vol fog");
 
-	pass.newDependency({m_runCtx.m_rt, TextureUsageBit::IMAGE_COMPUTE_WRITE});
-	pass.newDependency({m_r->getVolumetricLightingAccumulation().getRt(), TextureUsageBit::SAMPLED_COMPUTE});
+	pass.newDependency({m_runCtx.m_rt, TextureUsageBit::kImageComputeWrite});
+	pass.newDependency({m_r->getVolumetricLightingAccumulation().getRt(), TextureUsageBit::kSampledCompute});
 
 	pass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) -> void {
 		CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;

AnKi/Renderer/VolumetricLightingAccumulation.cpp

@@ -60,14 +60,14 @@ Error VolumetricLightingAccumulation::init()
 
 	// Create RTs
 	TextureInitInfo texinit =
-		m_r->create2DRenderTargetInitInfo(m_volumeSize[0], m_volumeSize[1], Format::R16G16B16A16_SFLOAT,
-										  TextureUsageBit::IMAGE_COMPUTE_READ | TextureUsageBit::IMAGE_COMPUTE_WRITE
-											  | TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::SAMPLED_COMPUTE,
+		m_r->create2DRenderTargetInitInfo(m_volumeSize[0], m_volumeSize[1], Format::kR16G16B16A16_Sfloat,
+										  TextureUsageBit::kImageComputeRead | TextureUsageBit::kImageComputeWrite
+											  | TextureUsageBit::kSampledFragment | TextureUsageBit::kSampledCompute,
 										  "VolLight");
 	texinit.m_depth = m_volumeSize[2];
-	texinit.m_type = TextureType::_3D;
-	m_rtTextures[0] = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::SAMPLED_FRAGMENT);
-	m_rtTextures[1] = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::SAMPLED_FRAGMENT);
+	texinit.m_type = TextureType::k3D;
+	m_rtTextures[0] = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
+	m_rtTextures[1] = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
 
 	return Error::NONE;
 }
@@ -78,8 +78,8 @@ void VolumetricLightingAccumulation::populateRenderGraph(RenderingContext& ctx)
 
 	const U readRtIdx = m_r->getFrameCount() & 1;
 
-	m_runCtx.m_rts[0] = rgraph.importRenderTarget(m_rtTextures[readRtIdx], TextureUsageBit::SAMPLED_FRAGMENT);
-	m_runCtx.m_rts[1] = rgraph.importRenderTarget(m_rtTextures[!readRtIdx], TextureUsageBit::NONE);
+	m_runCtx.m_rts[0] = rgraph.importRenderTarget(m_rtTextures[readRtIdx], TextureUsageBit::kSampledFragment);
+	m_runCtx.m_rts[1] = rgraph.importRenderTarget(m_rtTextures[!readRtIdx], TextureUsageBit::kNone);
 
 	ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("Vol light");
 
@@ -87,15 +87,15 @@ void VolumetricLightingAccumulation::populateRenderGraph(RenderingContext& ctx)
 		run(ctx, rgraphCtx);
 	});
 
-	pass.newDependency(RenderPassDependency(m_runCtx.m_rts[0], TextureUsageBit::SAMPLED_COMPUTE));
-	pass.newDependency(RenderPassDependency(m_runCtx.m_rts[1], TextureUsageBit::IMAGE_COMPUTE_WRITE));
+	pass.newDependency(RenderPassDependency(m_runCtx.m_rts[0], TextureUsageBit::kSampledCompute));
+	pass.newDependency(RenderPassDependency(m_runCtx.m_rts[1], TextureUsageBit::kImageComputeWrite));
 	pass.newDependency(
-		RenderPassDependency(m_r->getShadowMapping().getShadowmapRt(), TextureUsageBit::SAMPLED_COMPUTE));
+		RenderPassDependency(m_r->getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledCompute));
 
 	pass.newDependency(
 		RenderPassDependency(ctx.m_clusteredShading.m_clustersBufferHandle, BufferUsageBit::STORAGE_COMPUTE_READ));
 
-	m_r->getIndirectDiffuseProbes().setRenderGraphDependencies(ctx, pass, TextureUsageBit::SAMPLED_COMPUTE);
+	m_r->getIndirectDiffuseProbes().setRenderGraphDependencies(ctx, pass, TextureUsageBit::kSampledCompute);
 }
 
 void VolumetricLightingAccumulation::run(const RenderingContext& ctx, RenderPassWorkContext& rgraphCtx)

AnKi/Renderer/VrsSriGeneration.cpp

@@ -46,15 +46,15 @@ Error VrsSriGeneration::initInternal()
 
 	// Create textures
 	const TextureUsageBit texUsage =
-		TextureUsageBit::FRAMEBUFFER_SHADING_RATE | TextureUsageBit::IMAGE_COMPUTE_WRITE | TextureUsageBit::ALL_SAMPLED;
+		TextureUsageBit::kFramebufferShadingRate | TextureUsageBit::kImageComputeWrite | TextureUsageBit::kAllSampled;
 	TextureInitInfo sriInitInfo =
-		m_r->create2DRenderTargetInitInfo(rez.x(), rez.y(), Format::R8_UINT, texUsage, "VrsSri");
-	m_sriTex = m_r->createAndClearRenderTarget(sriInitInfo, TextureUsageBit::FRAMEBUFFER_SHADING_RATE);
+		m_r->create2DRenderTargetInitInfo(rez.x(), rez.y(), Format::kR8_Uint, texUsage, "VrsSri");
+	m_sriTex = m_r->createAndClearRenderTarget(sriInitInfo, TextureUsageBit::kFramebufferShadingRate);
 
 	const UVec2 rezDownscaled = (m_r->getInternalResolution() / 2 + m_sriTexelDimension - 1) / m_sriTexelDimension;
-	sriInitInfo = m_r->create2DRenderTargetInitInfo(rezDownscaled.x(), rezDownscaled.y(), Format::R8_UINT, texUsage,
+	sriInitInfo = m_r->create2DRenderTargetInitInfo(rezDownscaled.x(), rezDownscaled.y(), Format::kR8_Uint, texUsage,
 													"VrsSriDownscaled");
-	m_downscaledSriTex = m_r->createAndClearRenderTarget(sriInitInfo, TextureUsageBit::FRAMEBUFFER_SHADING_RATE);
+	m_downscaledSriTex = m_r->createAndClearRenderTarget(sriInitInfo, TextureUsageBit::kFramebufferShadingRate);
 
 	// Load programs
 	ANKI_CHECK(getResourceManager().loadResource("ShaderBinaries/VrsSriGenerationCompute.ankiprogbin", m_prog));
@@ -127,9 +127,9 @@ void VrsSriGeneration::importRenderTargets(RenderingContext& ctx)
 	}
 	else
 	{
-		m_runCtx.m_rt = ctx.m_renderGraphDescr.importRenderTarget(m_sriTex, TextureUsageBit::FRAMEBUFFER_SHADING_RATE);
+		m_runCtx.m_rt = ctx.m_renderGraphDescr.importRenderTarget(m_sriTex, TextureUsageBit::kFramebufferShadingRate);
 		m_runCtx.m_downscaledRt =
-			ctx.m_renderGraphDescr.importRenderTarget(m_downscaledSriTex, TextureUsageBit::FRAMEBUFFER_SHADING_RATE);
+			ctx.m_renderGraphDescr.importRenderTarget(m_downscaledSriTex, TextureUsageBit::kFramebufferShadingRate);
 		m_sriTexImportedOnce = true;
 	}
 }
@@ -148,8 +148,8 @@ void VrsSriGeneration::populateRenderGraph(RenderingContext& ctx)
 	{
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("VRS SRI generation");
 
-		pass.newDependency(RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::IMAGE_COMPUTE_WRITE));
-		pass.newDependency(RenderPassDependency(m_r->getLightShading().getRt(), TextureUsageBit::SAMPLED_COMPUTE));
+		pass.newDependency(RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::kImageComputeWrite));
+		pass.newDependency(RenderPassDependency(m_r->getLightShading().getRt(), TextureUsageBit::kSampledCompute));
 
 		pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
@@ -172,8 +172,8 @@ void VrsSriGeneration::populateRenderGraph(RenderingContext& ctx)
 	{
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("VRS SRI downscale");
 
-		pass.newDependency(RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::SAMPLED_COMPUTE));
-		pass.newDependency(RenderPassDependency(m_runCtx.m_downscaledRt, TextureUsageBit::IMAGE_COMPUTE_WRITE));
+		pass.newDependency(RenderPassDependency(m_runCtx.m_rt, TextureUsageBit::kSampledCompute));
+		pass.newDependency(RenderPassDependency(m_runCtx.m_downscaledRt, TextureUsageBit::kImageComputeWrite));
 
 		pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 			const UVec2 rezDownscaled =

AnKi/Resource/ImageResource.cpp

@@ -72,7 +72,7 @@ Error ImageResource::load(const ResourceFilename& filename, Bool async)
 	getFilepathFilename(filename, filenameExt);
 
 	TextureInitInfo init(filenameExt);
-	init.m_usage = TextureUsageBit::ALL_SAMPLED | TextureUsageBit::TRANSFER_DESTINATION;
+	init.m_usage = TextureUsageBit::kAllSampled | TextureUsageBit::kTransferDestination;
 	U32 faces = 0;
 
 	ResourceFilePtr file;
@@ -87,25 +87,25 @@ Error ImageResource::load(const ResourceFilename& filename, Bool async)
 	switch(loader.getImageType())
 	{
 	case ImageBinaryType::_2D:
-		init.m_type = TextureType::_2D;
+		init.m_type = TextureType::k2D;
 		init.m_depth = 1;
 		faces = 1;
 		init.m_layerCount = 1;
 		break;
 	case ImageBinaryType::CUBE:
-		init.m_type = TextureType::CUBE;
+		init.m_type = TextureType::kCube;
 		init.m_depth = 1;
 		faces = 6;
 		init.m_layerCount = 1;
 		break;
 	case ImageBinaryType::_2D_ARRAY:
-		init.m_type = TextureType::_2D_ARRAY;
+		init.m_type = TextureType::k2DArray;
 		init.m_layerCount = loader.getLayerCount();
 		init.m_depth = 1;
 		faces = 1;
 		break;
 	case ImageBinaryType::_3D:
-		init.m_type = TextureType::_3D;
+		init.m_type = TextureType::k3D;
 		init.m_depth = loader.getDepth();
 		init.m_layerCount = 1;
 		faces = 1;
@@ -120,20 +120,20 @@ Error ImageResource::load(const ResourceFilename& filename, Bool async)
 		switch(loader.getCompression())
 		{
 		case ImageBinaryDataCompression::RAW:
-			init.m_format = Format::R8G8B8_UNORM;
+			init.m_format = Format::kR8G8B8_Unorm;
 			break;
 		case ImageBinaryDataCompression::S3TC:
-			init.m_format = Format::BC1_RGB_UNORM_BLOCK;
+			init.m_format = Format::kBC1_RGB_Unorm_Block;
 			break;
 		case ImageBinaryDataCompression::ASTC:
 			if(loader.getAstcBlockSize() == UVec2(4u))
 			{
-				init.m_format = Format::ASTC_4x4_UNORM_BLOCK;
+				init.m_format = Format::kASTC_4x4_Unorm_Block;
 			}
 			else
 			{
 				ANKI_ASSERT(loader.getAstcBlockSize() == UVec2(8u));
-				init.m_format = Format::ASTC_8x8_UNORM_BLOCK;
+				init.m_format = Format::kASTC_8x8_Unorm_Block;
 			}
 			break;
 		default:
@@ -145,20 +145,20 @@ Error ImageResource::load(const ResourceFilename& filename, Bool async)
 		switch(loader.getCompression())
 		{
 		case ImageBinaryDataCompression::RAW:
-			init.m_format = Format::R8G8B8A8_UNORM;
+			init.m_format = Format::kR8G8B8A8_Unorm;
 			break;
 		case ImageBinaryDataCompression::S3TC:
-			init.m_format = Format::BC3_UNORM_BLOCK;
+			init.m_format = Format::kBC3_Unorm_Block;
 			break;
 		case ImageBinaryDataCompression::ASTC:
 			if(loader.getAstcBlockSize() == UVec2(4u))
 			{
-				init.m_format = Format::ASTC_4x4_UNORM_BLOCK;
+				init.m_format = Format::kASTC_4x4_Unorm_Block;
 			}
 			else
 			{
 				ANKI_ASSERT(loader.getAstcBlockSize() == UVec2(8u));
-				init.m_format = Format::ASTC_8x8_UNORM_BLOCK;
+				init.m_format = Format::kASTC_8x8_Unorm_Block;
 			}
 			break;
 		default:
@@ -170,11 +170,11 @@ Error ImageResource::load(const ResourceFilename& filename, Bool async)
 		switch(loader.getCompression())
 		{
 		case ImageBinaryDataCompression::S3TC:
-			init.m_format = Format::BC6H_UFLOAT_BLOCK;
+			init.m_format = Format::kBC6H_Ufloat_Block;
 			break;
 		case ImageBinaryDataCompression::ASTC:
 			ANKI_ASSERT(loader.getAstcBlockSize() == UVec2(8u));
-			init.m_format = Format::ASTC_8x8_SFLOAT_BLOCK_EXT;
+			init.m_format = Format::kASTC_8x8_Sfloat_Block;
 			break;
 		default:
 			ANKI_ASSERT(0);
@@ -185,11 +185,11 @@ Error ImageResource::load(const ResourceFilename& filename, Bool async)
 		switch(loader.getCompression())
 		{
 		case ImageBinaryDataCompression::RAW:
-			init.m_format = Format::R32G32B32A32_SFLOAT;
+			init.m_format = Format::kR32G32B32A32_Sfloat;
 			break;
 		case ImageBinaryDataCompression::ASTC:
 			ANKI_ASSERT(loader.getAstcBlockSize() == UVec2(8u));
-			init.m_format = Format::ASTC_8x8_SFLOAT_BLOCK_EXT;
+			init.m_format = Format::kASTC_8x8_Sfloat_Block;
 			break;
 		default:
 			ANKI_ASSERT(0);
@@ -217,7 +217,7 @@ Error ImageResource::load(const ResourceFilename& filename, Bool async)
 		subresource.m_layerCount = init.m_layerCount;
 		subresource.m_mipmapCount = init.m_mipmapCount;
 
-		const TextureBarrierInfo barrier = {m_tex.get(), TextureUsageBit::NONE, TextureUsageBit::ALL_SAMPLED,
+		const TextureBarrierInfo barrier = {m_tex.get(), TextureUsageBit::kNone, TextureUsageBit::kAllSampled,
 											subresource};
 		cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
@@ -276,10 +276,10 @@ Error ImageResource::load(LoadingContext& ctx)
 			unflatten3dArrayIndex(ctx.m_layerCount, ctx.m_faces, ctx.m_loader.getMipmapCount(), i, layer, face, mip);
 
 			TextureBarrierInfo& barrier = barriers[barrierCount++];
-			barrier = {ctx.m_tex.get(), TextureUsageBit::NONE, TextureUsageBit::TRANSFER_DESTINATION,
+			barrier = {ctx.m_tex.get(), TextureUsageBit::kNone, TextureUsageBit::kTransferDestination,
 					   TextureSubresourceInfo()};
 
-			if(ctx.m_texType == TextureType::_3D)
+			if(ctx.m_texType == TextureType::k3D)
 			{
 				barrier.m_subresource = TextureVolumeInfo(mip);
 				TextureVolumeInfo vol(mip);
@@ -303,7 +303,7 @@ Error ImageResource::load(LoadingContext& ctx)
 			const void* surfOrVolData;
 			PtrSize allocationSize;
 
-			if(ctx.m_texType == TextureType::_3D)
+			if(ctx.m_texType == TextureType::k3D)
 			{
 				const auto& vol = ctx.m_loader.getVolume(mip);
 				surfOrVolSize = vol.m_data.getSize();
@@ -332,7 +332,7 @@ Error ImageResource::load(LoadingContext& ctx)
 
 			// Create temp tex view
 			TextureSubresourceInfo subresource;
-			if(ctx.m_texType == TextureType::_3D)
+			if(ctx.m_texType == TextureType::k3D)
 			{
 				subresource = TextureSubresourceInfo(TextureVolumeInfo(mip));
 			}
@@ -354,10 +354,10 @@ Error ImageResource::load(LoadingContext& ctx)
 			unflatten3dArrayIndex(ctx.m_layerCount, ctx.m_faces, ctx.m_loader.getMipmapCount(), i, layer, face, mip);
 
 			TextureBarrierInfo& barrier = barriers[barrierCount++];
-			barrier.m_previousUsage = TextureUsageBit::TRANSFER_DESTINATION;
-			barrier.m_nextUsage = TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::SAMPLED_GEOMETRY;
+			barrier.m_previousUsage = TextureUsageBit::kTransferDestination;
+			barrier.m_nextUsage = TextureUsageBit::kSampledFragment | TextureUsageBit::kSampledGeometry;
 
-			if(ctx.m_texType == TextureType::_3D)
+			if(ctx.m_texType == TextureType::k3D)
 			{
 				barrier.m_subresource = TextureVolumeInfo(mip);
 			}

AnKi/Resource/MaterialResource.cpp

@@ -10,10 +10,10 @@
 
 namespace anki {
 
-inline constexpr Array<CString, U32(BuiltinMutatorId::COUNT)> BUILTIN_MUTATOR_NAMES = {
+inline constexpr Array<CString, U32(BuiltinMutatorId::kCount)> BUILTIN_MUTATOR_NAMES = {
 	{"NONE", "ANKI_TECHNIQUE", "ANKI_LOD", "ANKI_BONES", "ANKI_VELOCITY"}};
 
-inline constexpr Array<CString, U(RenderingTechnique::COUNT)> TECHNIQUE_NAMES = {
+inline constexpr Array<CString, U(RenderingTechnique::kCount)> TECHNIQUE_NAMES = {
 	{"GBuffer", "GBufferEarlyZ", "Shadow", "Forward", "RtShadow"}};
 
 // This is some trickery to select calling between XmlElement::getAttributeNumber and XmlElement::getAttributeNumbers
@@ -72,7 +72,7 @@ class MaterialResource::Program
 public:
 	ShaderProgramResourcePtr m_prog;
 
-	mutable Array4d<MaterialVariant, U(RenderingTechnique::COUNT), MAX_LOD_COUNT, 2, 2> m_variantMatrix;
+	mutable Array4d<MaterialVariant, U(RenderingTechnique::kCount), MAX_LOD_COUNT, 2, 2> m_variantMatrix;
 	mutable RWMutex m_variantMatrixMtx;
 
 	DynamicArray<PartialMutation> m_partialMutation; ///< Only with the non-builtins.
@@ -356,7 +356,7 @@ Error MaterialResource::createVars(Program& prog)
 		initInfo.addMutation(m.m_mutator->m_name, m.m_value);
 	}
 
-	Array<const ShaderProgramResourceMutator*, U(BuiltinMutatorId::COUNT)> mutatorPtrs = {};
+	Array<const ShaderProgramResourceMutator*, U(BuiltinMutatorId::kCount)> mutatorPtrs = {};
 	for(BuiltinMutatorId id : EnumIterable<BuiltinMutatorId>())
 	{
 		mutatorPtrs[id] = prog.m_prog->tryFindMutator(BUILTIN_MUTATOR_NAMES[id]);
@@ -531,7 +531,7 @@ Error MaterialResource::findBuiltinMutators(Program& prog)
 		for(U32 i = 0; i < techniqueMutator->m_values.getSize(); ++i)
 		{
 			const MutatorValue mvalue = techniqueMutator->m_values[i];
-			if(mvalue >= MutatorValue(RenderingTechnique::COUNT) || mvalue < MutatorValue(RenderingTechnique::FIRST))
+			if(mvalue >= MutatorValue(RenderingTechnique::kCount) || mvalue < MutatorValue(RenderingTechnique::kFirst))
 			{
 				ANKI_RESOURCE_LOGE("Mutator %s has a wrong value %d", techniqueMutatorName.cstr(), mvalue);
 				return Error::USER_DATA;

AnKi/Resource/MaterialResource.h

@@ -30,8 +30,8 @@ enum class BuiltinMutatorId : U8
 	BONES,
 	VELOCITY,
 
-	COUNT,
-	FIRST = 0
+	kCount,
+	kFirst = 0
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(BuiltinMutatorId)
 
@@ -273,7 +273,7 @@ private:
 
 	DynamicArray<Program> m_programs;
 
-	Array<U8, U(RenderingTechnique::COUNT)> m_techniqueToProgram;
+	Array<U8, U(RenderingTechnique::kCount)> m_techniqueToProgram;
 	RenderingTechniqueBit m_techniquesMask = RenderingTechniqueBit::NONE;
 
 	DynamicArray<MaterialVariable> m_vars;

AnKi/Resource/MeshBinary.h

@@ -132,9 +132,9 @@ class MeshBinaryHeader
 public:
 	Array<U8, 8> m_magic;
 	MeshBinaryFlag m_flags;
-	Array<MeshBinaryVertexBuffer, U32(VertexAttributeId::COUNT)> m_vertexBuffers;
+	Array<MeshBinaryVertexBuffer, U32(VertexAttributeId::kCount)> m_vertexBuffers;
 	U32 m_vertexBufferCount;
-	Array<MeshBinaryVertexAttribute, U32(VertexAttributeId::COUNT)> m_vertexAttributes;
+	Array<MeshBinaryVertexAttribute, U32(VertexAttributeId::kCount)> m_vertexAttributes;
 	IndexType m_indexType;
 	Array<U8, 3> m_padding;
 	U32 m_totalIndexCount;

AnKi/Resource/MeshBinary.xml

@@ -51,9 +51,9 @@ ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(MeshBinaryFlag)
 			<members>
 				<member name="m_magic" type="U8" array_size="8"/>
 				<member name="m_flags" type="MeshBinaryFlag"/>
-				<member name="m_vertexBuffers" type="MeshBinaryVertexBuffer" array_size="U32(VertexAttributeId::COUNT)"/>
+				<member name="m_vertexBuffers" type="MeshBinaryVertexBuffer" array_size="U32(VertexAttributeId::kCount)"/>
 				<member name="m_vertexBufferCount" type="U32"/>
-				<member name="m_vertexAttributes" type="MeshBinaryVertexAttribute" array_size="U32(VertexAttributeId::COUNT)"/>
+				<member name="m_vertexAttributes" type="MeshBinaryVertexAttribute" array_size="U32(VertexAttributeId::kCount)"/>
 				<member name="m_indexType" type="IndexType"/>
 				<member name="m_padding" type="U8" array_size="3"/>
 				<member name="m_totalIndexCount" type="U32"/>

AnKi/Resource/MeshBinaryLoader.cpp

@@ -137,15 +137,15 @@ Error MeshBinaryLoader::checkHeader() const
 	}
 
 	// Attributes
-	ANKI_CHECK(checkFormat(VertexAttributeId::POSITION, Array<Format, 1>{{Format::R32G32B32_SFLOAT}}, 0, 0));
-	ANKI_CHECK(checkFormat(VertexAttributeId::NORMAL, Array<Format, 1>{{Format::A2B10G10R10_SNORM_PACK32}}, 1, 0));
-	ANKI_CHECK(checkFormat(VertexAttributeId::TANGENT, Array<Format, 1>{{Format::A2B10G10R10_SNORM_PACK32}}, 1, 4));
-	ANKI_CHECK(checkFormat(VertexAttributeId::UV0, Array<Format, 1>{{Format::R32G32_SFLOAT}}, 1, 8));
-	ANKI_CHECK(checkFormat(VertexAttributeId::UV1, Array<Format, 1>{{Format::NONE}}, 1, 0));
+	ANKI_CHECK(checkFormat(VertexAttributeId::POSITION, Array<Format, 1>{{Format::kR32G32B32_Sfloat}}, 0, 0));
+	ANKI_CHECK(checkFormat(VertexAttributeId::NORMAL, Array<Format, 1>{{Format::kA2B10G10R10_Snorm_Pack32}}, 1, 0));
+	ANKI_CHECK(checkFormat(VertexAttributeId::TANGENT, Array<Format, 1>{{Format::kA2B10G10R10_Snorm_Pack32}}, 1, 4));
+	ANKI_CHECK(checkFormat(VertexAttributeId::UV0, Array<Format, 1>{{Format::kR32G32_Sfloat}}, 1, 8));
+	ANKI_CHECK(checkFormat(VertexAttributeId::UV1, Array<Format, 1>{{Format::kNone}}, 1, 0));
 	ANKI_CHECK(
-		checkFormat(VertexAttributeId::BONE_INDICES, Array<Format, 2>{{Format::NONE, Format::R8G8B8A8_UINT}}, 2, 0));
+		checkFormat(VertexAttributeId::BONE_INDICES, Array<Format, 2>{{Format::kNone, Format::kR8G8B8A8_Uint}}, 2, 0));
 	ANKI_CHECK(
-		checkFormat(VertexAttributeId::BONE_WEIGHTS, Array<Format, 2>{{Format::NONE, Format::R8G8B8A8_UNORM}}, 2, 4));
+		checkFormat(VertexAttributeId::BONE_WEIGHTS, Array<Format, 2>{{Format::kNone, Format::kR8G8B8A8_Unorm}}, 2, 4));
 
 	// Vertex buffers
 	if(m_header.m_vertexBufferCount != 2 + U32(hasBoneInfo()))
@@ -277,7 +277,7 @@ Error MeshBinaryLoader::storeIndicesAndPosition(DynamicArrayAuto<U32>& indices,
 	{
 		positions.resize(m_header.m_totalVertexCount);
 		const MeshBinaryVertexAttribute& attrib = m_header.m_vertexAttributes[VertexAttributeId::POSITION];
-		ANKI_ASSERT(attrib.m_format == Format::R32G32B32_SFLOAT);
+		ANKI_ASSERT(attrib.m_format == Format::kR32G32B32_Sfloat);
 		ANKI_CHECK(storeVertexBuffer(attrib.m_bufferBinding, &positions[0], positions.getSizeInBytes()));
 	}
 

AnKi/Resource/MeshBinaryLoader.h

@@ -47,7 +47,7 @@ public:
 	Bool hasBoneInfo() const
 	{
 		ANKI_ASSERT(isLoaded());
-		return m_header.m_vertexAttributes[VertexAttributeId::BONE_INDICES].m_format != Format::NONE;
+		return m_header.m_vertexAttributes[VertexAttributeId::BONE_INDICES].m_format != Format::kNone;
 	}
 
 	ConstWeakArray<MeshBinarySubMesh> getSubMeshes() const

AnKi/Resource/MeshResource.cpp

@@ -150,7 +150,7 @@ Error MeshResource::load(const ResourceFilename& filename, Bool async)
 		m_vertexBufferInfos[i].m_offset += m_vertexBuffersOffset;
 	}
 
-	for(VertexAttributeId attrib = VertexAttributeId::FIRST; attrib < VertexAttributeId::COUNT; ++attrib)
+	for(VertexAttributeId attrib = VertexAttributeId::kFirst; attrib < VertexAttributeId::kCount; ++attrib)
 	{
 		AttribInfo& out = m_attributes[attrib];
 		const MeshBinaryVertexAttribute& in = header.m_vertexAttributes[attrib];

AnKi/Resource/MeshResource.h

@@ -144,14 +144,14 @@ private:
 	class AttribInfo
 	{
 	public:
-		Format m_format = Format::NONE;
+		Format m_format = Format::kNone;
 		U32 m_relativeOffset = 0;
 		U32 m_buffIdx = 0;
 	};
 
 	DynamicArray<SubMesh> m_subMeshes;
 	DynamicArray<VertBuffInfo> m_vertexBufferInfos;
-	Array<AttribInfo, U(VertexAttributeId::COUNT)> m_attributes;
+	Array<AttribInfo, U(VertexAttributeId::kCount)> m_attributes;
 
 	BufferPtr m_vertexBuffer; ///< Contains all data (vertices and indices).