Merge branch 'master' into master

AnKi/Collision/Aabb.cpp

@@ -21,7 +21,7 @@ Aabb Aabb::getTransformed(const Transform& trf) const
 	Vec4 newC = trf.transform(center);
 	Vec4 newE = Vec4(absM * (extend * trf.getScale()), 0.0f);
 
-	return Aabb(newC - newE, newC + newE + Vec4(EPSILON, EPSILON, EPSILON, 0.0f));
+	return Aabb(newC - newE, newC + newE + Vec4(kEpsilonf, kEpsilonf, kEpsilonf, 0.0f));
 }
 
 Aabb Aabb::getCompoundShape(const Aabb& b) const
@@ -48,8 +48,8 @@ void Aabb::setFromPointCloud(const Vec3* pointBuffer, U pointCount, PtrSize poin
 	ANKI_ASSERT((pointStride % sizeof(F32)) == 0 && "Weird strides that breaks strict aliasing rules");
 	ANKI_ASSERT(buffSize >= pointStride * pointCount);
 
-	m_min = Vec4(Vec3(MAX_F32), 0.0f);
-	m_max = Vec4(Vec3(MIN_F32), 0.0f);
+	m_min = Vec4(Vec3(kMaxF32), 0.0f);
+	m_max = Vec4(Vec3(kMinF32), 0.0f);
 
 	// Iterate
 	const U8* ptr = reinterpret_cast<const U8*>(pointBuffer);

AnKi/Collision/Aabb.h

@@ -16,7 +16,7 @@ namespace anki {
 class Aabb
 {
 public:
-	static constexpr CollisionShapeType CLASS_TYPE = CollisionShapeType::AABB;
+	static constexpr CollisionShapeType kClassType = CollisionShapeType::kAABB;
 
 	/// Will not initialize any memory, nothing.
 	Aabb()
@@ -106,13 +106,13 @@ public:
 private:
 	Vec4 m_min
 #if ANKI_ENABLE_ASSERTIONS
-		= Vec4(MAX_F32)
+		= Vec4(kMaxF32)
 #endif
 		;
 
 	Vec4 m_max
 #if ANKI_ENABLE_ASSERTIONS
-		= Vec4(MIN_F32)
+		= Vec4(kMinF32)
 #endif
 		;
 

AnKi/Collision/Common.h

@@ -17,43 +17,43 @@ namespace anki {
 /// The 6 frustum planes.
 enum class FrustumPlaneType : U8
 {
-	NEAR,
-	FAR,
-	LEFT,
-	RIGHT,
-	TOP,
-	BOTTOM,
-
-	COUNT,
-	FIRST = 0
+	kNear,
+	kFar,
+	kLeft,
+	kRight,
+	kTop,
+	kBottom,
+
+	kCount,
+	kFirst = 0
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(FrustumPlaneType)
 
 /// Collision shape type.
 enum class CollisionShapeType : U8
 {
-	PLANE,
-	LINE_SEGMENT,
-	RAY,
-	AABB,
-	SPHERE,
-	OBB,
-	CONVEX_HULL,
-	CONE,
-
-	COUNT,
-	FIRST = 0
+	kPlane,
+	kLineSegment,
+	kRay,
+	kAABB,
+	kSphere,
+	kOBB,
+	kConvexHull,
+	kCone,
+
+	kCount,
+	kFirst = 0
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(CollisionShapeType)
 
 /// Frustum type
 enum class FrustumType : U8
 {
-	PERSPECTIVE,
-	ORTHOGRAPHIC,
+	kPerspective,
+	kOrthographic,
 
-	COUNT,
-	FIRST = 0
+	kCount,
+	kFirst = 0
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(FrustumType)
 /// @}

AnKi/Collision/Cone.h

@@ -16,7 +16,7 @@ namespace anki {
 class Cone
 {
 public:
-	static constexpr CollisionShapeType CLASS_TYPE = CollisionShapeType::CONE;
+	static constexpr CollisionShapeType kClassType = CollisionShapeType::kCone;
 
 	/// Will not initialize any memory, nothing.
 	Cone()
@@ -73,7 +73,7 @@ public:
 
 	void setLength(F32 len)
 	{
-		ANKI_ASSERT(len > EPSILON);
+		ANKI_ASSERT(len > kEpsilonf);
 		m_length = len;
 	}
 
@@ -85,7 +85,7 @@ public:
 
 	void setAngle(F32 ang)
 	{
-		ANKI_ASSERT(ang > 0.0f && ang < 2.0f * PI);
+		ANKI_ASSERT(ang > 0.0f && ang < 2.0f * kPi);
 		m_angle = ang;
 	}
 
@@ -107,13 +107,13 @@ public:
 private:
 	Vec4 m_origin
 #if ANKI_ENABLE_ASSERTIONS
-		= Vec4(MAX_F32)
+		= Vec4(kMaxF32)
 #endif
 		;
 
 	Vec4 m_dir
 #if ANKI_ENABLE_ASSERTIONS
-		= Vec4(MAX_F32)
+		= Vec4(kMaxF32)
 #endif
 		;
 
@@ -134,7 +134,7 @@ private:
 		ANKI_ASSERT(m_origin.w() == 0.0f);
 		ANKI_ASSERT(m_dir.w() == 0.0f);
 		ANKI_ASSERT(m_length > 0.0f);
-		ANKI_ASSERT(m_angle > 0.0f && m_angle < 2.0f * PI);
+		ANKI_ASSERT(m_angle > 0.0f && m_angle < 2.0f * kPi);
 	}
 };
 /// @}

AnKi/Collision/ConvexHullShape.cpp

@@ -32,7 +32,7 @@ Vec4 ConvexHullShape::computeSupport(const Vec4& dir) const
 {
 	check();
 
-	F32 m = MIN_F32;
+	F32 m = kMinF32;
 	U index = 0;
 
 	const Vec4 d = (m_trfIdentity) ? dir : (m_invTrf.getRotation() * dir).xyz0();

AnKi/Collision/ConvexHullShape.h

@@ -17,7 +17,7 @@ namespace anki {
 class ConvexHullShape
 {
 public:
-	static constexpr CollisionShapeType CLASS_TYPE = CollisionShapeType::CONVEX_HULL;
+	static constexpr CollisionShapeType kClassType = CollisionShapeType::kConvexHull;
 
 	/// Will not initialize any memory, nothing.
 	ConvexHullShape()

AnKi/Collision/FunctionsComputeAabb.cpp

@@ -31,15 +31,15 @@ Aabb computeAabb(const Obb& obb)
 	const Vec4 newE = Vec4(absM * obb.getExtend(), 0.0f);
 
 	// Add a small epsilon to avoid some assertions
-	const Vec4 epsilon(Vec3(EPSILON * 100.0f), 0.0f);
+	const Vec4 epsilon(Vec3(kEpsilonf * 100.0f), 0.0f);
 
 	return Aabb(obb.getCenter() - newE, obb.getCenter() + newE + epsilon);
 }
 
 Aabb computeAabb(const ConvexHullShape& hull)
 {
-	Vec4 mina(MAX_F32);
-	Vec4 maxa(MIN_F32);
+	Vec4 mina(kMaxF32);
+	Vec4 maxa(kMinF32);
 
 	for(const Vec4& point : hull.getPoints())
 	{

AnKi/Collision/FunctionsMisc.cpp

@@ -21,12 +21,12 @@ void extractClipPlane(const Mat4& mvp, FrustumPlaneType id, Plane& plane)
 
 	switch(id)
 	{
-		ANKI_CASE(FrustumPlaneType::NEAR, 3, +, 2)
-		ANKI_CASE(FrustumPlaneType::FAR, 3, -, 2)
-		ANKI_CASE(FrustumPlaneType::LEFT, 3, +, 0)
-		ANKI_CASE(FrustumPlaneType::RIGHT, 3, -, 0)
-		ANKI_CASE(FrustumPlaneType::TOP, 3, -, 1)
-		ANKI_CASE(FrustumPlaneType::BOTTOM, 3, +, 1)
+		ANKI_CASE(FrustumPlaneType::kNear, 3, +, 2)
+		ANKI_CASE(FrustumPlaneType::kFar, 3, -, 2)
+		ANKI_CASE(FrustumPlaneType::kLeft, 3, +, 0)
+		ANKI_CASE(FrustumPlaneType::kRight, 3, -, 0)
+		ANKI_CASE(FrustumPlaneType::kTop, 3, -, 1)
+		ANKI_CASE(FrustumPlaneType::kBottom, 3, +, 1)
 	default:
 		ANKI_ASSERT(0);
 	}

AnKi/Collision/FunctionsTestCollision.cpp

@@ -112,8 +112,8 @@ Bool testCollision(const Aabb& aabb, const ConvexHullShape& hull)
 
 Bool testCollision(const Aabb& aabb, const LineSegment& ls)
 {
-	F32 maxS = MIN_F32;
-	F32 minT = MAX_F32;
+	F32 maxS = kMinF32;
+	F32 minT = kMaxF32;
 
 	// do tests against three sets of planes
 	for(U i = 0; i < 3; ++i)
@@ -235,8 +235,8 @@ Bool testCollision(const Obb& obb, const ConvexHullShape& hull)
 
 Bool testCollision(const Obb& obb, const LineSegment& ls)
 {
-	F32 maxS = MIN_F32;
-	F32 minT = MAX_F32;
+	F32 maxS = kMinF32;
+	F32 minT = kMaxF32;
 
 	// compute difference vector
 	const Vec4 diff = obb.getCenter() - ls.getOrigin();

AnKi/Collision/FunctionsTestPlane.cpp

@@ -119,8 +119,8 @@ F32 testPlane(const Plane& plane, const ConvexHullShape& hull)
 	// Compute the invert transformation of the plane instead
 	const Plane pa = (hull.isTransformIdentity()) ? plane : plane.getTransformed(hull.getInvertTransform());
 
-	F32 minDist = MAX_F32;
-	F32 maxDist = MIN_F32;
+	F32 minDist = kMaxF32;
+	F32 maxDist = kMinF32;
 
 	ConstWeakArray<Vec4> points = hull.getPoints();
 	for(const Vec4& point : points)

AnKi/Collision/LineSegment.h

@@ -17,7 +17,7 @@ namespace anki {
 class LineSegment
 {
 public:
-	static constexpr CollisionShapeType CLASS_TYPE = CollisionShapeType::LINE_SEGMENT;
+	static constexpr CollisionShapeType kClassType = CollisionShapeType::kLineSegment;
 
 	/// Will not initialize any memory, nothing.
 	LineSegment()
@@ -78,13 +78,13 @@ public:
 private:
 	Vec4 m_origin ///< P0
 #if ANKI_ENABLE_ASSERTIONS
-		= Vec4(MAX_F32)
+		= Vec4(kMaxF32)
 #endif
 		;
 
 	Vec4 m_dir ///< P1 = origin+dir so dir = P1-origin
 #if ANKI_ENABLE_ASSERTIONS
-		= Vec4(MAX_F32)
+		= Vec4(kMaxF32)
 #endif
 		;
 

AnKi/Collision/Obb.cpp

@@ -83,8 +83,8 @@ void Obb::setFromPointCloud(const Vec3* pointBuffer, U pointCount, PtrSize point
 	ANKI_ASSERT(pointStride >= sizeof(Vec3));
 	ANKI_ASSERT(buffSize >= pointStride * pointCount);
 
-	Vec4 min = Vec4(Vec3(MAX_F32), 0.0);
-	Vec4 max = Vec4(Vec3(MIN_F32), 0.0);
+	Vec4 min = Vec4(Vec3(kMaxF32), 0.0);
+	Vec4 max = Vec4(Vec3(kMinF32), 0.0);
 
 	// Iterate
 	const U8* ptr = reinterpret_cast<const U8*>(pointBuffer);

AnKi/Collision/Obb.h

@@ -18,7 +18,7 @@ namespace anki {
 class Obb
 {
 public:
-	static constexpr CollisionShapeType CLASS_TYPE = CollisionShapeType::OBB;
+	static constexpr CollisionShapeType kClassType = CollisionShapeType::kOBB;
 
 	/// Will not initialize any memory, nothing.
 	Obb()
@@ -110,27 +110,27 @@ public:
 private:
 	Vec4 m_center
 #if ANKI_ENABLE_ASSERTIONS
-		= Vec4(MAX_F32)
+		= Vec4(kMaxF32)
 #endif
 		;
 
 	Vec4 m_extend /// With identity rotation this points to max (front, right, top in our case)
 #if ANKI_ENABLE_ASSERTIONS
-		= Vec4(MAX_F32)
+		= Vec4(kMaxF32)
 #endif
 		;
 
 	Mat3x4 m_rotation
 #if ANKI_ENABLE_ASSERTIONS
-		= Mat3x4(MAX_F32)
+		= Mat3x4(kMaxF32)
 #endif
 		;
 
 	void check() const
 	{
-		ANKI_ASSERT(m_center != Vec4(MAX_F32));
-		ANKI_ASSERT(m_extend != Vec4(MAX_F32));
-		ANKI_ASSERT(m_rotation != Mat3x4(MAX_F32));
+		ANKI_ASSERT(m_center != Vec4(kMaxF32));
+		ANKI_ASSERT(m_extend != Vec4(kMaxF32));
+		ANKI_ASSERT(m_rotation != Mat3x4(kMaxF32));
 		ANKI_ASSERT(m_center.w() == 0.0f && m_extend.w() == 0.0f);
 	}
 };

AnKi/Collision/Plane.h

@@ -16,7 +16,7 @@ namespace anki {
 class Plane
 {
 public:
-	static constexpr CollisionShapeType CLASS_TYPE = CollisionShapeType::PLANE;
+	static constexpr CollisionShapeType kClassType = CollisionShapeType::kPlane;
 
 	/// Will not initialize any memory, nothing.
 	Plane()
@@ -91,20 +91,20 @@ public:
 private:
 	Vec4 m_normal
 #if ANKI_ENABLE_ASSERTIONS
-		= Vec4(MAX_F32)
+		= Vec4(kMaxF32)
 #endif
 		;
 
 	F32 m_offset
 #if ANKI_ENABLE_ASSERTIONS
-		= MAX_F32
+		= kMaxF32
 #endif
 		;
 
 	void check() const
 	{
 		ANKI_ASSERT(m_normal.w() == 0.0f);
-		ANKI_ASSERT(m_offset != MAX_F32);
+		ANKI_ASSERT(m_offset != kMaxF32);
 	}
 };
 /// @}

AnKi/Collision/Ray.h

@@ -16,7 +16,7 @@ namespace anki {
 class Ray
 {
 public:
-	static constexpr CollisionShapeType CLASS_TYPE = CollisionShapeType::RAY;
+	static constexpr CollisionShapeType kClassType = CollisionShapeType::kRay;
 
 	/// Will not initialize any memory, nothing.
 	Ray()
@@ -96,20 +96,20 @@ public:
 private:
 	Vec4 m_origin
 #if ANKI_ENABLE_ASSERTIONS
-		= Vec4(MAX_F32)
+		= Vec4(kMaxF32)
 #endif
 		;
 
 	Vec4 m_dir
 #if ANKI_ENABLE_ASSERTIONS
-		= Vec4(MAX_F32)
+		= Vec4(kMaxF32)
 #endif
 		;
 
 	void check() const
 	{
 		ANKI_ASSERT(m_origin.w() == 0.0f && m_dir.w() == 0.0f
-					&& isZero(m_dir.getLengthSquared() - 1.0f, EPSILON * 100.0f));
+					&& isZero(m_dir.getLengthSquared() - 1.0f, kEpsilonf * 100.0f));
 	}
 };
 /// @}

AnKi/Collision/Sphere.cpp

@@ -36,8 +36,8 @@ void Sphere::setFromPointCloud(const Vec3* pointBuffer, U pointCount, PtrSize po
 {
 	// Calc center
 	{
-		Vec4 min(Vec3(MAX_F32), 0.0f);
-		Vec4 max(Vec3(MIN_F32), 0.0f);
+		Vec4 min(Vec3(kMaxF32), 0.0f);
+		Vec4 max(Vec3(kMinF32), 0.0f);
 
 		// Iterate
 		const U8* ptr = reinterpret_cast<const U8*>(pointBuffer);
@@ -57,7 +57,7 @@ void Sphere::setFromPointCloud(const Vec3* pointBuffer, U pointCount, PtrSize po
 
 	// Calc radius
 	{
-		F32 maxDist = MIN_F32;
+		F32 maxDist = kMinF32;
 
 		const U8* ptr = reinterpret_cast<const U8*>(pointBuffer);
 		while(pointCount-- != 0)

AnKi/Collision/Sphere.h

@@ -16,7 +16,7 @@ namespace anki {
 class Sphere
 {
 public:
-	static constexpr CollisionShapeType CLASS_TYPE = CollisionShapeType::SPHERE;
+	static constexpr CollisionShapeType kClassType = CollisionShapeType::kSphere;
 
 	/// Will not initialize any memory, nothing.
 	Sphere()
@@ -112,7 +112,7 @@ public:
 private:
 	Vec4 m_center
 #if ANKI_ENABLE_ASSERTIONS
-		= Vec4(MAX_F32)
+		= Vec4(kMaxF32)
 #endif
 		;
 

AnKi/Config.h.cmake

@@ -233,6 +233,9 @@ inline int __builtin_ctzll(unsigned long long x)
 #endif
 
 // Define the main() function.
+namespace anki {
+void preMainInit();
+}
 #if ANKI_OS_ANDROID
 extern "C" {
 struct android_app;
@@ -250,6 +253,7 @@ void cleanupGetAndroidCommandLineArguments(void* ptr);
 	extern "C" void android_main(android_app* app) \
 	{ \
 		anki::g_androidApp = app; \
+		preMainInit(); \
 		char** argv; \
 		int argc; \
 		void* cleanupToken = anki::getAndroidCommandLineArguments(argc, argv); \
@@ -261,6 +265,7 @@ void cleanupGetAndroidCommandLineArguments(void* ptr);
 	int myMain(int argc, char* argv[]); \
 	int main(int argc, char* argv[]) \
 	{ \
+		preMainInit(); \
 		return myMain(argc, argv); \
 	}
 #endif

AnKi/Core/App.cpp

@@ -174,8 +174,6 @@ Error App::initInternal(AllocAlignedCallback allocCb, void* allocCbUserData)
 
 	setSignalHandlers();
 
-	Thread::setNameOfCurrentThread("AnKiMain");
-
 	initMemoryCallbacks(allocCb, allocCbUserData);
 	m_heapAlloc = HeapAllocator<U8>(m_allocCb, m_allocCbData, "Core");
 
@@ -270,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);
 	}
@@ -373,7 +371,7 @@ Error App::initInternal(AllocAlignedCallback allocCb, void* allocCbUserData)
 
 	ANKI_CORE_LOGI("Application initialized");
 
-	return Error::NONE;
+	return Error::kNone;
 }
 
 Error App::initDirs()
@@ -414,7 +412,7 @@ Error App::initDirs()
 		ANKI_CHECK(createDirectory(m_cacheDir.toCString()));
 	}
 
-	return Error::NONE;
+	return Error::kNone;
 }
 
 Error App::mainLoop()
@@ -451,7 +449,7 @@ Error App::mainLoop()
 
 			// Render
 			TexturePtr presentableTex = m_gr->acquireNextPresentableTexture();
-			m_renderer->setStatsEnabled(m_config->getCoreDisplayStats()
+			m_renderer->setStatsEnabled(m_config->getCoreDisplayStats() > 0
 #if ANKI_ENABLE_TRACE
 										|| TracerSingleton::get().getEnabled()
 #endif
@@ -483,36 +481,47 @@ Error App::mainLoop()
 			}
 
 			// Stats
-			if(m_config->getCoreDisplayStats())
+			if(m_config->getCoreDisplayStats() > 0)
 			{
-				StatsUi& statsUi = *static_cast<StatsUi*>(m_statsUi.get());
+				StatsUiInput in;
+				in.m_cpuFrameTime = frameTime;
+				in.m_rendererTime = m_renderer->getStats().m_renderingCpuTime;
+				in.m_sceneUpdateTime = m_scene->getStats().m_updateTime;
+				in.m_visibilityTestsTime = m_scene->getStats().m_visibilityTestsTime;
+				in.m_physicsTime = m_scene->getStats().m_physicsUpdate;
 
-				statsUi.setFrameTime(frameTime);
-				statsUi.setRenderTime(m_renderer->getStats().m_renderingCpuTime);
-				statsUi.setSceneUpdateTime(m_scene->getStats().m_updateTime);
-				statsUi.setVisibilityTestsTime(m_scene->getStats().m_visibilityTestsTime);
-				statsUi.setPhysicsTime(m_scene->getStats().m_physicsUpdate);
+				in.m_gpuFrameTime = m_renderer->getStats().m_renderingGpuTime;
 
-				statsUi.setGpuTime(m_renderer->getStats().m_renderingGpuTime);
 				if(m_maliHwCounters)
 				{
 					MaliHwCountersOut out;
 					m_maliHwCounters->sample(out);
-
-					statsUi.setGpuActiveCycles(out.m_gpuActive);
-					statsUi.setGpuReadBandwidth(out.m_readBandwidth);
-					statsUi.setGpuWriteBandwidth(out.m_writeBandwidth);
+					in.m_gpuActiveCycles = out.m_gpuActive;
+					in.m_gpuReadBandwidth = out.m_readBandwidth;
+					in.m_gpuWriteBandwidth = out.m_writeBandwidth;
 				}
 
-				statsUi.setAllocatedCpuMemory(m_memStats.m_allocatedMem.load());
-				statsUi.setCpuAllocationCount(m_memStats.m_allocCount.load());
-				statsUi.setCpuFreeCount(m_memStats.m_freeCount.load());
-				statsUi.setGrStats(m_gr->getStats());
+				in.m_cpuAllocatedMemory = m_memStats.m_allocatedMem.load();
+				in.m_cpuAllocationCount = m_memStats.m_allocCount.load();
+				in.m_cpuFreeCount = m_memStats.m_freeCount.load();
+
+				const GrManagerStats grStats = m_gr->getStats();
 				BuddyAllocatorBuilderStats vertMemStats;
 				m_vertexMem->getMemoryStats(vertMemStats);
-				statsUi.setGlobalVertexMemoryPoolStats(vertMemStats);
 
-				statsUi.setDrawableCount(rqueue.countAllRenderables());
+				in.m_gpuDeviceMemoryAllocated = grStats.m_deviceMemoryAllocated;
+				in.m_gpuDeviceMemoryInUse = grStats.m_deviceMemoryInUse;
+				in.m_globalVertexAllocated = vertMemStats.m_realAllocatedSize;
+				in.m_globalVertexUsed = vertMemStats.m_userAllocatedSize;
+				in.m_globalVertexExternalFragmentation = vertMemStats.m_externalFragmentation;
+
+				in.m_drawableCount = rqueue.countAllRenderables();
+				in.m_vkCommandBufferCount = grStats.m_commandBufferCount;
+
+				StatsUi& statsUi = *static_cast<StatsUi*>(m_statsUi.get());
+				const StatsUiDetail detail =
+					(m_config->getCoreDisplayStats() == 1) ? StatsUiDetail::kFpsOnly : StatsUiDetail::kDetailed;
+				statsUi.setStats(in, detail);
 			}
 
 #if ANKI_ENABLE_TRACE
@@ -532,15 +541,15 @@ Error App::mainLoop()
 #endif
 	}
 
-	return Error::NONE;
+	return Error::kNone;
 }
 
 void App::injectUiElements(DynamicArrayAuto<UiQueueElement>& newUiElementArr, RenderQueue& rqueue)
 {
 	const U32 originalCount = rqueue.m_uis.getSize();
-	if(m_config->getCoreDisplayStats() || m_consoleEnabled)
+	if(m_config->getCoreDisplayStats() > 0 || m_consoleEnabled)
 	{
-		const U32 extraElements = m_config->getCoreDisplayStats() + (m_consoleEnabled != 0);
+		const U32 extraElements = (m_config->getCoreDisplayStats() > 0) + (m_consoleEnabled != 0);
 		newUiElementArr.create(originalCount + extraElements);
 
 		if(originalCount > 0)
@@ -552,7 +561,7 @@ void App::injectUiElements(DynamicArrayAuto<UiQueueElement>& newUiElementArr, Re
 	}
 
 	U32 count = originalCount;
-	if(m_config->getCoreDisplayStats())
+	if(m_config->getCoreDisplayStats() > 0)
 	{
 		newUiElementArr[count].m_userData = m_statsUi.get();
 		newUiElementArr[count].m_drawCallback = [](CanvasPtr& canvas, void* userData) -> void {
@@ -573,7 +582,7 @@ void App::injectUiElements(DynamicArrayAuto<UiQueueElement>& newUiElementArr, Re
 
 void App::initMemoryCallbacks(AllocAlignedCallback allocCb, void* allocCbUserData)
 {
-	if(m_config->getCoreDisplayStats())
+	if(m_config->getCoreDisplayStats() > 1)
 	{
 		m_memStats.m_originalAllocCallback = allocCb;
 		m_memStats.m_originalUserData = allocCbUserData;

AnKi/Core/App.h

@@ -86,7 +86,7 @@ public:
 	virtual Error userMainLoop([[maybe_unused]] Bool& quit, [[maybe_unused]] Second elapsedTime)
 	{
 		// Do nothing
-		return Error::NONE;
+		return Error::kNone;
 	}
 
 	const ConfigSet& getConfig() const

AnKi/Core/CMakeLists.txt

@@ -19,6 +19,7 @@ set(headers
 	MaliHwCounters.h
 	NativeWindow.h
 	StatsUi.h
+	StatsUi.defs.h
 	StdinListener.h)
 
 if(ANKI_HEADLESS)

AnKi/Core/Common.h

@@ -10,9 +10,9 @@
 
 namespace anki {
 
-#define ANKI_CORE_LOGI(...) ANKI_LOG("CORE", NORMAL, __VA_ARGS__)
-#define ANKI_CORE_LOGE(...) ANKI_LOG("CORE", ERROR, __VA_ARGS__)
-#define ANKI_CORE_LOGW(...) ANKI_LOG("CORE", WARNING, __VA_ARGS__)
-#define ANKI_CORE_LOGF(...) ANKI_LOG("CORE", FATAL, __VA_ARGS__)
+#define ANKI_CORE_LOGI(...) ANKI_LOG("CORE", kNormal, __VA_ARGS__)
+#define ANKI_CORE_LOGE(...) ANKI_LOG("CORE", kError, __VA_ARGS__)
+#define ANKI_CORE_LOGW(...) ANKI_LOG("CORE", kWarning, __VA_ARGS__)
+#define ANKI_CORE_LOGF(...) ANKI_LOG("CORE", kFatal, __VA_ARGS__)
 
 } // end namespace anki

AnKi/Core/ConfigSet.cpp

@@ -143,7 +143,7 @@ Error ConfigSet::loadFromFile(CString filename)
 		else \
 		{ \
 			ANKI_CORE_LOGE("Wrong value for %s", m_##name.m_name.cstr()); \
-			return Error::USER_DATA; \
+			return Error::kUserData; \
 		} \
 	}
 
@@ -159,7 +159,7 @@ Error ConfigSet::loadFromFile(CString filename)
 #include <AnKi/Core/AllConfigVars.defs.h>
 #undef ANKI_NUMERIC
 
-	return Error::NONE;
+	return Error::kNone;
 }
 
 Error ConfigSet::saveToFile(CString filename) const
@@ -170,7 +170,7 @@ Error ConfigSet::saveToFile(CString filename) const
 	File file;
 	ANKI_CHECK(file.open(filename, FileOpenFlag::WRITE));
 
-	ANKI_CHECK(file.writeTextf("%s\n<config>\n", XmlDocument::XML_HEADER.cstr()));
+	ANKI_CHECK(file.writeTextf("%s\n<config>\n", XmlDocument::kXmlHeader.cstr()));
 
 #define ANKI_NUMERIC_UINT(name) \
 	ANKI_CHECK(file.writeTextf("\t<!-- %s -->\n", m_##name.m_description.cstr())); \
@@ -192,7 +192,7 @@ Error ConfigSet::saveToFile(CString filename) const
 #undef ANKI_NUMERIC_UINT
 
 	ANKI_CHECK(file.writeText("</config>\n"));
-	return Error::NONE;
+	return Error::kNone;
 }
 
 Error ConfigSet::setFromCommandLineArguments(U32 cmdLineArgsCount, char* cmdLineArgs[])
@@ -209,7 +209,7 @@ Error ConfigSet::setFromCommandLineArguments(U32 cmdLineArgsCount, char* cmdLine
 		if(i >= cmdLineArgsCount)
 		{
 			ANKI_CORE_LOGE("Expecting a command line argument after %s", varName.cstr());
-			return Error::USER_DATA;
+			return Error::kUserData;
 		}
 
 		ANKI_ASSERT(cmdLineArgs[i]);
@@ -254,7 +254,7 @@ Error ConfigSet::setFromCommandLineArguments(U32 cmdLineArgsCount, char* cmdLine
 		}
 	}
 
-	return Error::NONE;
+	return Error::kNone;
 }
 
 } // end namespace anki

AnKi/Core/ConfigVars.defs.h

@@ -17,8 +17,8 @@ ANKI_CONFIG_VAR_U32(Width, 1920, 16, 16 * 1024, "Width")
 ANKI_CONFIG_VAR_U32(Height, 1080, 16, 16 * 1024, "Height")
 ANKI_CONFIG_VAR_U32(WindowFullscreen, 1, 0, 2, "0: windowed, 1: borderless fullscreen, 2: exclusive fullscreen")
 
-ANKI_CONFIG_VAR_U32(CoreTargetFps, 60u, 30u, MAX_U32, "Target FPS")
+ANKI_CONFIG_VAR_U32(CoreTargetFps, 60u, 30u, kMaxU32, "Target FPS")
 ANKI_CONFIG_VAR_U32(CoreJobThreadCount, max(2u, getCpuCoresCount() / 2u), 2u, 1024u, "Number of job thread")
-ANKI_CONFIG_VAR_BOOL(CoreDisplayStats, false, "Display stats")
+ANKI_CONFIG_VAR_U32(CoreDisplayStats, 0, 0, 2, "Display stats, 0: None, 1: Simple, 2: Detailed")
 ANKI_CONFIG_VAR_BOOL(CoreClearCaches, false, "Clear all caches")
 ANKI_CONFIG_VAR_BOOL(CoreVerboseLog, false, "Verbose logging")

AnKi/Core/CoreTracer.cpp

@@ -126,12 +126,12 @@ Error CoreTracer::init(GenericMemoryPoolAllocator<U8> alloc, CString directory)
 
 	ANKI_CHECK(m_countersCsvFile.open(StringAuto(alloc).sprintf("%scounters.csv", fname.cstr()), FileOpenFlag::WRITE));
 
-	return Error::NONE;
+	return Error::kNone;
 }
 
 Error CoreTracer::threadWorker()
 {
-	Error err = Error::NONE;
+	Error err = Error::kNone;
 	Bool quit = false;
 
 	while(!err && !quit)
@@ -200,7 +200,7 @@ Error CoreTracer::writeEvents(ThreadWorkItem& item)
 	// Store counters
 	// TODO
 
-	return Error::NONE;
+	return Error::kNone;
 }
 
 void CoreTracer::gatherCounters(ThreadWorkItem& item)
@@ -334,7 +334,7 @@ Error CoreTracer::writeCountersForReal()
 {
 	if(!m_countersCsvFile.isOpen() || m_frameCounters.getSize() == 0)
 	{
-		return Error::NONE;
+		return Error::kNone;
 	}
 
 	// Write the header
@@ -385,7 +385,7 @@ Error CoreTracer::writeCountersForReal()
 		ANKI_CHECK(m_countersCsvFile.writeText("\n"));
 	}
 
-	return Error::NONE;
+	return Error::kNone;
 }
 
 } // end namespace anki

AnKi/Core/DeveloperConsole.cpp

@@ -15,6 +15,7 @@ DeveloperConsole::~DeveloperConsole()
 	{
 		LogItem* item = &m_logItems.getFront();
 		m_logItems.popFront();
+		item->m_threadName.destroy(m_alloc);
 		item->m_msg.destroy(m_alloc);
 		m_alloc.deleteInstance(item);
 	}
@@ -32,7 +33,7 @@ Error DeveloperConsole::init(AllocAlignedCallback allocCb, void* allocCbUserData
 
 	ANKI_CHECK(m_scriptEnv.init(scriptManager));
 
-	return Error::NONE;
+	return Error::kNone;
 }
 
 void DeveloperConsole::build(CanvasPtr ctx)
@@ -57,24 +58,24 @@ void DeveloperConsole::build(CanvasPtr ctx)
 	{
 		switch(item.m_type)
 		{
-		case LoggerMessageType::NORMAL:
+		case LoggerMessageType::kNormal:
 			ImGui::PushStyleColor(ImGuiCol_Text, Vec4(0.0f, 1.0f, 0.0f, 1.0f));
 			break;
-		case LoggerMessageType::ERROR:
-		case LoggerMessageType::FATAL:
+		case LoggerMessageType::kError:
+		case LoggerMessageType::kFatal:
 			ImGui::PushStyleColor(ImGuiCol_Text, Vec4(1.0f, 0.0f, 0.0f, 1.0f));
 			break;
-		case LoggerMessageType::WARNING:
+		case LoggerMessageType::kWarning:
 			ImGui::PushStyleColor(ImGuiCol_Text, Vec4(0.9f, 0.6f, 0.14f, 1.0f));
 			break;
 		default:
 			ANKI_ASSERT(0);
 		}
 
-		static constexpr Array<const char*, static_cast<U>(LoggerMessageType::COUNT)> MSG_TEXT = {"I", "E", "W", "F"};
-		ImGui::TextWrapped("[%s][%s] %s (%s:%d %s)", MSG_TEXT[static_cast<U>(item.m_type)],
+		constexpr Array<const Char*, U(LoggerMessageType::kCount)> kMsgText = {"I", "E", "W", "F"};
+		ImGui::TextWrapped("[%s][%s] %s [%s:%d][%s][%s]", kMsgText[item.m_type],
 						   (item.m_subsystem) ? item.m_subsystem : "N/A ", item.m_msg.cstr(), item.m_file, item.m_line,
-						   item.m_func);
+						   item.m_func, item.m_threadName.cstr());
 
 		ImGui::PopStyleColor();
 	}
@@ -93,7 +94,7 @@ void DeveloperConsole::build(CanvasPtr ctx)
 	// Commands
 	ImGui::Separator();
 	ImGui::PushItemWidth(-1.0f); // Use the whole size
-	if(ImGui::InputText("", &m_inputText[0], m_inputText.getSizeInBytes(), ImGuiInputTextFlags_EnterReturnsTrue,
+	if(ImGui::InputText("##noname", &m_inputText[0], m_inputText.getSizeInBytes(), ImGuiInputTextFlags_EnterReturnsTrue,
 						nullptr, nullptr))
 	{
 		const Error err = m_scriptEnv.evalString(&m_inputText[0]);
@@ -117,12 +118,13 @@ void DeveloperConsole::newLogItem(const LoggerMessageInfo& inf)
 	LogItem* newLogItem;
 
 	// Pop first
-	if(m_logItemCount + 1 > MAX_LOG_ITEMS)
+	if(m_logItemCount + 1 > kMaxLogItems)
 	{
 		LogItem* first = &m_logItems.getFront();
 		m_logItems.popFront();
 
 		first->m_msg.destroy(m_alloc);
+		first->m_threadName.destroy(m_alloc);
 
 		// Re-use the log item
 		newLogItem = first;
@@ -137,6 +139,7 @@ void DeveloperConsole::newLogItem(const LoggerMessageInfo& inf)
 	newLogItem->m_file = inf.m_file;
 	newLogItem->m_func = inf.m_func;
 	newLogItem->m_subsystem = inf.m_subsystem;
+	newLogItem->m_threadName.create(m_alloc, inf.m_threadName);
 	newLogItem->m_msg.create(m_alloc, inf.m_msg);
 	newLogItem->m_line = inf.m_line;
 	newLogItem->m_type = inf.m_type;

AnKi/Core/DeveloperConsole.h

@@ -31,14 +31,15 @@ public:
 	void build(CanvasPtr ctx) override;
 
 private:
-	static constexpr U MAX_LOG_ITEMS = 64;
+	static constexpr U kMaxLogItems = 64;
 
 	class LogItem : public IntrusiveListEnabled<LogItem>
 	{
 	public:
-		const char* m_file;
-		const char* m_func;
-		const char* m_subsystem;
+		const Char* m_file;
+		const Char* m_func;
+		const Char* m_subsystem;
+		String m_threadName;
 		String m_msg;
 		I32 m_line;
 		LoggerMessageType m_type;

AnKi/Core/GpuMemoryPools.cpp

@@ -25,13 +25,13 @@ Error VertexGpuMemoryPool::init(GenericMemoryPoolAllocator<U8> alloc, GrManager*
 	if(!isPowerOfTwo(bufferInit.m_size))
 	{
 		ANKI_CORE_LOGE("core_globalVertexMemorySize should be a power of two (because of the buddy allocator");
-		return Error::USER_DATA;
+		return Error::kUserData;
 	}
 
-	bufferInit.m_usage = BufferUsageBit::VERTEX | BufferUsageBit::INDEX | BufferUsageBit::TRANSFER_DESTINATION;
+	bufferInit.m_usage = BufferUsageBit::kVertex | BufferUsageBit::kIndex | BufferUsageBit::kTransferDestination;
 	if(gr->getDeviceCapabilities().m_rayTracingEnabled)
 	{
-		bufferInit.m_usage |= BufferUsageBit::ACCELERATION_STRUCTURE_BUILD;
+		bufferInit.m_usage |= BufferUsageBit::kAccelerationStructureBuild;
 	}
 
 	m_vertBuffer = gr->newBuffer(bufferInit);
@@ -39,7 +39,7 @@ Error VertexGpuMemoryPool::init(GenericMemoryPoolAllocator<U8> alloc, GrManager*
 	// Init the rest
 	m_buddyAllocator.init(alloc, __builtin_ctzll(bufferInit.m_size));
 
-	return Error::NONE;
+	return Error::kNone;
 }
 
 Error VertexGpuMemoryPool::allocate(PtrSize size, PtrSize& offset)
@@ -53,12 +53,12 @@ Error VertexGpuMemoryPool::allocate(PtrSize size, PtrSize& offset)
 		ANKI_CORE_LOGE("Failed to allocate vertex memory of size %zu. The allocator has %zu (user requested %zu) out "
 					   "%zu allocated",
 					   size, stats.m_realAllocatedSize, stats.m_userAllocatedSize, m_vertBuffer->getSize());
-		return Error::OUT_OF_MEMORY;
+		return Error::kOutOfMemory;
 	}
 
 	offset = offset32;
 
-	return Error::NONE;
+	return Error::kNone;
 }
 
 void VertexGpuMemoryPool::free(PtrSize size, PtrSize offset)
@@ -87,20 +87,20 @@ Error StagingGpuMemoryPool::init(GrManager* gr, const ConfigSet& cfg)
 	m_perFrameBuffers[StagingGpuMemoryType::TEXTURE].m_size = cfg.getCoreTextureBufferPerFrameMemorySize();
 
 	initBuffer(StagingGpuMemoryType::UNIFORM, gr->getDeviceCapabilities().m_uniformBufferBindOffsetAlignment,
-			   gr->getDeviceCapabilities().m_uniformBufferMaxRange, BufferUsageBit::ALL_UNIFORM, *gr);
+			   gr->getDeviceCapabilities().m_uniformBufferMaxRange, BufferUsageBit::kAllUniform, *gr);
 
 	initBuffer(StagingGpuMemoryType::STORAGE,
 			   max(gr->getDeviceCapabilities().m_storageBufferBindOffsetAlignment,
 				   gr->getDeviceCapabilities().m_sbtRecordAlignment),
-			   gr->getDeviceCapabilities().m_storageBufferMaxRange, BufferUsageBit::ALL_STORAGE | BufferUsageBit::SBT,
+			   gr->getDeviceCapabilities().m_storageBufferMaxRange, BufferUsageBit::kAllStorage | BufferUsageBit::kSBT,
 			   *gr);
 
-	initBuffer(StagingGpuMemoryType::VERTEX, 16, MAX_U32, BufferUsageBit::VERTEX | BufferUsageBit::INDEX, *gr);
+	initBuffer(StagingGpuMemoryType::VERTEX, 16, kMaxU32, BufferUsageBit::kVertex | BufferUsageBit::kIndex, *gr);
 
 	initBuffer(StagingGpuMemoryType::TEXTURE, gr->getDeviceCapabilities().m_textureBufferBindOffsetAlignment,
-			   gr->getDeviceCapabilities().m_textureBufferMaxRange, BufferUsageBit::ALL_TEXTURE, *gr);
+			   gr->getDeviceCapabilities().m_textureBufferMaxRange, BufferUsageBit::kAllTexture, *gr);
 
-	return Error::NONE;
+	return Error::kNone;
 }
 
 void StagingGpuMemoryPool::initBuffer(StagingGpuMemoryType type, U32 alignment, PtrSize maxAllocSize,
@@ -108,9 +108,9 @@ void StagingGpuMemoryPool::initBuffer(StagingGpuMemoryType type, U32 alignment,
 {
 	PerFrameBuffer& perframe = m_perFrameBuffers[type];
 
-	perframe.m_buff = gr.newBuffer(BufferInitInfo(perframe.m_size, usage, BufferMapAccessBit::WRITE, "Staging"));
+	perframe.m_buff = gr.newBuffer(BufferInitInfo(perframe.m_size, usage, BufferMapAccessBit::kWrite, "Staging"));
 	perframe.m_alloc.init(perframe.m_size, alignment, maxAllocSize);
-	perframe.m_mappedMem = static_cast<U8*>(perframe.m_buff->map(0, perframe.m_size, BufferMapAccessBit::WRITE));
+	perframe.m_mappedMem = static_cast<U8*>(perframe.m_buff->map(0, perframe.m_size, BufferMapAccessBit::kWrite));
 }
 
 void* StagingGpuMemoryPool::allocateFrame(PtrSize size, StagingGpuMemoryType usage, StagingGpuMemoryToken& token)

AnKi/Core/GpuMemoryPools.h

@@ -82,12 +82,12 @@ public:
 
 	void markUnused()
 	{
-		m_offset = m_range = MAX_U32;
+		m_offset = m_range = kMaxU32;
 	}
 
 	Bool isUnused() const
 	{
-		return m_offset == MAX_U32 && m_range == MAX_U32;
+		return m_offset == kMaxU32 && m_range == kMaxU32;
 	}
 };
 
@@ -108,11 +108,11 @@ public:
 	void endFrame();
 
 	/// Allocate staging memory for various operations. The memory will be reclaimed at the begining of the
-	/// N-(MAX_FRAMES_IN_FLIGHT-1) frame.
+	/// N-(kMaxFramesInFlight-1) frame.
 	void* allocateFrame(PtrSize size, StagingGpuMemoryType usage, StagingGpuMemoryToken& token);
 
 	/// Allocate staging memory for various operations. The memory will be reclaimed at the begining of the
-	/// N-(MAX_FRAMES_IN_FLIGHT-1) frame.
+	/// N-(kMaxFramesInFlight-1) frame.
 	void* tryAllocateFrame(PtrSize size, StagingGpuMemoryType usage, StagingGpuMemoryToken& token);
 
 private:

AnKi/Core/NativeWindowAndroid.cpp

@@ -24,7 +24,7 @@ Error NativeWindow::newInstance(const NativeWindowInitInfo& initInfo, NativeWind
 	else
 	{
 		nativeWindow = andwin;
-		return Error::NONE;
+		return Error::kNone;
 	}
 }
 
@@ -38,7 +38,7 @@ void NativeWindow::deleteInstance(NativeWindow* window)
 	}
 }
 
-void NativeWindow::setWindowTitle(CString title)
+void NativeWindow::setWindowTitle([[maybe_unused]] CString title)
 {
 	// Nothing
 }
@@ -67,7 +67,7 @@ NativeWindowAndroid::~NativeWindowAndroid()
 	m_nativeWindow = nullptr;
 }
 
-Error NativeWindowAndroid::init(const NativeWindowInitInfo& init)
+Error NativeWindowAndroid::init([[maybe_unused]] const NativeWindowInitInfo& init)
 {
 	ANKI_CORE_LOGI("Initializing Android window");
 
@@ -94,7 +94,7 @@ Error NativeWindowAndroid::init(const NativeWindowInitInfo& init)
 	m_width = ANativeWindow_getWidth(g_androidApp->window);
 	m_height = ANativeWindow_getHeight(g_androidApp->window);
 
-	return Error::NONE;
+	return Error::kNone;
 }
 
 } // end namespace anki

AnKi/Core/NativeWindowHeadless.cpp

@@ -16,7 +16,7 @@ Error NativeWindow::newInstance(const NativeWindowInitInfo& initInfo, NativeWind
 	hwin->m_height = initInfo.m_height;
 
 	nativeWindow = hwin;
-	return Error::NONE;
+	return Error::kNone;
 }
 
 void NativeWindow::deleteInstance(NativeWindow* window)

AnKi/Core/NativeWindowSdl.cpp

@@ -28,7 +28,7 @@ Error NativeWindow::newInstance(const NativeWindowInitInfo& initInfo, NativeWind
 	else
 	{
 		nativeWindow = sdlwin;
-		return Error::NONE;
+		return Error::kNone;
 	}
 }
 
@@ -64,14 +64,14 @@ Error NativeWindowSdl::init(const NativeWindowInitInfo& init)
 	if(SDL_Init(INIT_SUBSYSTEMS) != 0)
 	{
 		ANKI_CORE_LOGE("SDL_Init() failed: %s", SDL_GetError());
-		return Error::FUNCTION_FAILED;
+		return Error::kFunctionFailed;
 	}
 
 #if ANKI_GR_BACKEND_VULKAN
 	if(SDL_Vulkan_LoadLibrary(nullptr))
 	{
 		ANKI_CORE_LOGE("SDL_Vulkan_LoadLibrary() failed: %s", SDL_GetError());
-		return Error::FUNCTION_FAILED;
+		return Error::kFunctionFailed;
 	}
 #endif
 
@@ -110,7 +110,7 @@ Error NativeWindowSdl::init(const NativeWindowInitInfo& init)
 		if(SDL_GetDesktopDisplayMode(0, &mode))
 		{
 			ANKI_CORE_LOGE("SDL_GetDesktopDisplayMode() failed: %s", SDL_GetError());
-			return Error::FUNCTION_FAILED;
+			return Error::kFunctionFailed;
 		}
 
 		m_width = mode.w;
@@ -128,7 +128,7 @@ Error NativeWindowSdl::init(const NativeWindowInitInfo& init)
 	if(m_window == nullptr)
 	{
 		ANKI_CORE_LOGE("SDL_CreateWindow() failed");
-		return Error::FUNCTION_FAILED;
+		return Error::kFunctionFailed;
 	}
 
 	// Final check
@@ -139,7 +139,7 @@ Error NativeWindowSdl::init(const NativeWindowInitInfo& init)
 	}
 
 	ANKI_CORE_LOGI("SDL window created");
-	return Error::NONE;
+	return Error::kNone;
 }
 
 } // end namespace anki

AnKi/Core/StatsUi.cpp

@@ -18,7 +18,7 @@ Error StatsUi::init()
 {
 	ANKI_CHECK(m_manager->newInstance(m_font, "EngineAssets/UbuntuMonoRegular.ttf", Array<U32, 1>{24}));
 
-	return Error::NONE;
+	return Error::kNone;
 }
 
 void StatsUi::labelBytes(PtrSize val, CString name) const
@@ -56,18 +56,27 @@ void StatsUi::labelBytes(PtrSize val, CString name) const
 	ImGui::TextUnformatted(timestamp.cstr());
 }
 
-void StatsUi::build(CanvasPtr canvas)
+void StatsUi::setStats(const StatsUiInput& input, StatsUiDetail detail)
 {
-	// Misc
-	++m_bufferedFrames;
 	Bool flush = false;
-	if(m_bufferedFrames == BUFFERED_FRAMES)
+	if(m_bufferedFrames == kBufferedFrames)
 	{
 		flush = true;
 		m_bufferedFrames = 0;
 	}
+	++m_bufferedFrames;
+
+#define ANKI_STATS_UI_BEGIN_GROUP(x)
+#define ANKI_STATS_UI_VALUE(type, name, text, flags) m_##name.update(input.m_##name, flags, flush);
+#include <AnKi/Core/StatsUi.defs.h>
+#undef ANKI_STATS_UI_BEGIN_GROUP
+#undef ANKI_STATS_UI_VALUE
+
+	m_detail = detail;
+}
 
-	// Start drawing the UI
+void StatsUi::build(CanvasPtr canvas)
+{
 	canvas->pushFont(m_font, 24);
 
 	const Vec4 oldWindowColor = ImGui::GetStyle().Colors[ImGuiCol_WindowBg];
@@ -78,48 +87,61 @@ void StatsUi::build(CanvasPtr canvas)
 		ImGui::SetWindowPos(Vec2(5.0f, 5.0f));
 		ImGui::SetWindowSize(Vec2(230.0f, 450.0f));
 
-		ImGui::Text("CPU Time:");
-		labelTime(m_frameTime.get(flush), "Total frame");
-		labelTime(m_renderTime.get(flush), "Renderer");
-		labelTime(m_sceneUpdateTime.get(flush), "Scene update");
-		labelTime(m_visTestsTime.get(flush), "Visibility");
-		labelTime(m_physicsTime.get(flush), "Physics");
-
-		ImGui::Text("----");
-		ImGui::Text("GPU:");
-		labelTime(m_gpuTime.get(flush), "Total frame");
-		const U64 gpuActive = m_gpuActive.get(flush);
-		if(gpuActive)
+		auto writeText = [this](const Value& v, const Char* text, ValueFlag flags, Bool isFloat) {
+			if(isFloat)
+			{
+				if(!!(flags & ValueFlag::kSeconds))
+				{
+					labelTime(v.m_float, text);
+				}
+				else
+				{
+					ImGui::Text("%s: %f", text, v.m_float);
+				}
+			}
+			else
+			{
+				U64 val;
+				if(!!(flags & ValueFlag::kAverage))
+				{
+					val = U64(v.m_avg);
+				}
+				else
+				{
+					val = v.m_int;
+				}
+
+				if(!!(flags & ValueFlag::kBytes))
+				{
+					labelBytes(val, text);
+				}
+				else
+				{
+					ImGui::Text("%s: %zu", text, val);
+				}
+			}
+		};
+
+		if(m_detail == StatsUiDetail::kDetailed)
 		{
-			ImGui::Text("%s: %luK cycles", "Active Cycles", gpuActive / 1000);
-			labelBytes(m_gpuReadBandwidth.get(flush), "Read bandwidth");
-			labelBytes(m_gpuWriteBandwidth.get(flush), "Write bandwidth");
+#define ANKI_STATS_UI_BEGIN_GROUP(x) \
+	ImGui::Text("----"); \
+	ImGui::Text(x); \
+	ImGui::Text("----");
+#define ANKI_STATS_UI_VALUE(type, name, text, flags) \
+	writeText(m_##name, text, flags, std::is_floating_point<type>::value);
+#include <AnKi/Core/StatsUi.defs.h>
+#undef ANKI_STATS_UI_BEGIN_GROUP
+#undef ANKI_STATS_UI_VALUE
+		}
+		else
+		{
+			const Second maxTime = max(m_cpuFrameTime.m_float, m_gpuFrameTime.m_float);
+			const F32 fps = F32(1.0 / maxTime);
+			const Bool cpuBound = m_cpuFrameTime.m_float > m_gpuFrameTime.m_float;
+			ImGui::TextColored((cpuBound) ? Vec4(1.0f, 0.5f, 0.5f, 1.0f) : Vec4(0.5f, 1.0f, 0.5f, 1.0f), "FPS %.1f",
+							   fps);
 		}
-
-		ImGui::Text("----");
-		ImGui::Text("CPU Memory:");
-		labelBytes(m_allocatedCpuMem, "Total CPU");
-		labelUint(m_allocCount, "Total allocations");
-		labelUint(m_freeCount, "Total frees");
-
-		ImGui::Text("----");
-		ImGui::Text("GPU Memory:");
-		labelBytes(m_grStats.m_hostMemoryAllocated, "Host");
-		labelBytes(m_grStats.m_hostMemoryInUse, "Host in use");
-		labelUint(m_grStats.m_hostMemoryAllocationCount, "Host allocations");
-		labelBytes(m_grStats.m_deviceMemoryAllocated, "Device");
-		labelBytes(m_grStats.m_deviceMemoryInUse, "Device in use");
-		labelUint(m_grStats.m_deviceMemoryAllocationCount, "Device allocations");
-		labelBytes(m_globalVertexPoolStats.m_userAllocatedSize, "Vertex/Index GPU memory");
-		labelBytes(m_globalVertexPoolStats.m_realAllocatedSize, "Actual Vertex/Index GPU memory");
-
-		ImGui::Text("----");
-		ImGui::Text("Vulkan:");
-		labelUint(m_grStats.m_commandBufferCount, "Cmd buffers");
-
-		ImGui::Text("----");
-		ImGui::Text("Other:");
-		labelUint(m_drawableCount, "Drawbles");
 	}
 
 	ImGui::End();

AnKi/Core/StatsUi.defs.h

@@ -0,0 +1,33 @@
+// Copyright (C) 2009-2022, Panagiotis Christopoulos Charitos and contributors.
+// All rights reserved.
+// Code licensed under the BSD License.
+// http://www.anki3d.org/LICENSE
+
+ANKI_STATS_UI_BEGIN_GROUP("CPU")
+ANKI_STATS_UI_VALUE(Second, cpuFrameTime, "Total frame", ValueFlag::kAverage | ValueFlag::kSeconds)
+ANKI_STATS_UI_VALUE(Second, rendererTime, "Renderer", ValueFlag::kAverage | ValueFlag::kSeconds)
+ANKI_STATS_UI_VALUE(Second, sceneUpdateTime, "Scene update", ValueFlag::kAverage | ValueFlag::kSeconds)
+ANKI_STATS_UI_VALUE(Second, visibilityTestsTime, "Visibility tests", ValueFlag::kAverage | ValueFlag::kSeconds)
+ANKI_STATS_UI_VALUE(Second, physicsTime, "Physics", ValueFlag::kAverage | ValueFlag::kSeconds)
+
+ANKI_STATS_UI_BEGIN_GROUP("GPU")
+ANKI_STATS_UI_VALUE(Second, gpuFrameTime, "Total frame", ValueFlag::kAverage | ValueFlag::kSeconds)
+ANKI_STATS_UI_VALUE(U64, gpuActiveCycles, "GPU cycles", ValueFlag::kAverage)
+ANKI_STATS_UI_VALUE(U64, gpuReadBandwidth, "Read bandwidth", ValueFlag::kAverage | ValueFlag::kBytes)
+ANKI_STATS_UI_VALUE(U64, gpuWriteBandwidth, "Write bandwidth", ValueFlag::kAverage | ValueFlag::kBytes)
+
+ANKI_STATS_UI_BEGIN_GROUP("CPU memory")
+ANKI_STATS_UI_VALUE(PtrSize, cpuAllocatedMemory, "Total", ValueFlag::kNone | ValueFlag::kBytes)
+ANKI_STATS_UI_VALUE(PtrSize, cpuAllocationCount, "Number of allocations", ValueFlag::kNone)
+ANKI_STATS_UI_VALUE(PtrSize, cpuFreeCount, "Number of frees", ValueFlag::kNone)
+
+ANKI_STATS_UI_BEGIN_GROUP("GPU memory")
+ANKI_STATS_UI_VALUE(PtrSize, gpuDeviceMemoryAllocated, "Really allocated", ValueFlag::kNone | ValueFlag::kBytes)
+ANKI_STATS_UI_VALUE(PtrSize, gpuDeviceMemoryInUse, "Used", ValueFlag::kNone | ValueFlag::kBytes)
+ANKI_STATS_UI_VALUE(PtrSize, globalVertexAllocated, "Vertex really allocated", ValueFlag::kNone | ValueFlag::kBytes)
+ANKI_STATS_UI_VALUE(PtrSize, globalVertexUsed, "Vertex used", ValueFlag::kNone | ValueFlag::kBytes)
+ANKI_STATS_UI_VALUE(F32, globalVertexExternalFragmentation, "Vertex external fragmentation", ValueFlag::kNone)
+
+ANKI_STATS_UI_BEGIN_GROUP("Other")
+ANKI_STATS_UI_VALUE(U32, drawableCount, "Render queue drawbles", ValueFlag::kNone)
+ANKI_STATS_UI_VALUE(U32, vkCommandBufferCount, "VK command buffers", ValueFlag::kNone)

AnKi/Core/StatsUi.h

@@ -15,6 +15,24 @@ namespace anki {
 /// @addtogroup core
 /// @{
 
+/// @memberof StatsUi
+class StatsUiInput
+{
+public:
+#define ANKI_STATS_UI_BEGIN_GROUP(x)
+#define ANKI_STATS_UI_VALUE(type, name, text, flags) type m_##name = {};
+#include <AnKi/Core/StatsUi.defs.h>
+#undef ANKI_STATS_UI_BEGIN_GROUP
+#undef ANKI_STATS_UI_VALUE
+};
+
+/// @memberof StatsUi
+enum class StatsUiDetail : U8
+{
+	kDetailed,
+	kFpsOnly
+};
+
 /// UI for displaying on-screen stats.
 class StatsUi : public UiImmediateModeBuilder
 {
@@ -30,136 +48,79 @@ public:
 
 	void build(CanvasPtr ctx) override;
 
-	void setFrameTime(Second v)
-	{
-		m_frameTime.set(v);
-	}
-
-	void setRenderTime(Second v)
-	{
-		m_renderTime.set(v);
-	}
-
-	void setSceneUpdateTime(Second v)
-	{
-		m_sceneUpdateTime.set(v);
-	}
-
-	void setVisibilityTestsTime(Second v)
-	{
-		m_visTestsTime.set(v);
-	}
-
-	void setPhysicsTime(Second v)
-	{
-		m_physicsTime.set(v);
-	}
+	void setStats(const StatsUiInput& input, StatsUiDetail detail);
 
-	void setGpuTime(Second v)
-	{
-		m_gpuTime.set(v);
-	}
-
-	void setGpuActiveCycles(U64 v)
-	{
-		m_gpuActive.set(v);
-	}
-
-	void setGpuReadBandwidth(PtrSize v)
-	{
-		m_gpuReadBandwidth.set(v);
-	}
-
-	void setGpuWriteBandwidth(PtrSize v)
-	{
-		m_gpuWriteBandwidth.set(v);
-	}
-
-	void setAllocatedCpuMemory(PtrSize v)
-	{
-		m_allocatedCpuMem = v;
-	}
-
-	void setCpuAllocationCount(U64 v)
-	{
-		m_allocCount = v;
-	}
-
-	void setCpuFreeCount(U64 v)
-	{
-		m_freeCount = v;
-	}
+private:
+	static constexpr U32 kBufferedFrames = 16;
 
-	void setGrStats(const GrManagerStats& stats)
+	enum class ValueFlag : U8
 	{
-		m_grStats = stats;
-	}
+		kNone = 0,
+		kAverage = 1 << 0,
+		kSeconds = 1 << 1,
+		kBytes = 1 << 2,
+	};
+	ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS_FRIEND(ValueFlag)
 
-	void setDrawableCount(U64 v)
+	class Value
 	{
-		m_drawableCount = v;
-	}
+	public:
+		union
+		{
+			U64 m_int = 0;
+			F64 m_float;
+			F64 m_avg;
+		};
 
-	void setGlobalVertexMemoryPoolStats(const BuddyAllocatorBuilderStats& stats)
-	{
-		m_globalVertexPoolStats = stats;
-	}
+		F64 m_rollingAvg = 0.0;
 
-private:
-	static constexpr U32 BUFFERED_FRAMES = 16;
+		template<typename T, ANKI_ENABLE(std::is_floating_point<T>::value)>
+		void update(T x, ValueFlag flags, Bool flush)
+		{
+			if(!!(flags & ValueFlag::kAverage))
+			{
+				setAverage(x, flush);
+			}
+			else
+			{
+				m_float = x;
+			}
+		}
 
-	template<typename T>
-	class BufferedValue
-	{
-	public:
-		void set(T x)
+		template<typename T, ANKI_ENABLE(std::is_integral<T>::value)>
+		void update(T x, ValueFlag flags, Bool flush)
 		{
-			m_rollongAvg += x / T(BUFFERED_FRAMES);
+			if(!!(flags & ValueFlag::kAverage))
+			{
+				setAverage(F64(x), flush);
+			}
+			else
+			{
+				m_int = x;
+			}
 		}
 
-		T get(Bool flush)
+		void setAverage(F64 x, Bool flush)
 		{
+			m_rollingAvg += x / F64(kBufferedFrames);
+
 			if(flush)
 			{
-				m_avg = m_rollongAvg;
-				m_rollongAvg = T(0);
+				m_avg = m_rollingAvg;
+				m_rollingAvg = 0.0;
 			}
-
-			return m_avg;
 		}
-
-	private:
-		T m_rollongAvg = T(0);
-		T m_avg = T(0);
 	};
 
+#define ANKI_STATS_UI_BEGIN_GROUP(x)
+#define ANKI_STATS_UI_VALUE(type, name, text, flags) Value m_##name;
+#include <AnKi/Core/StatsUi.defs.h>
+#undef ANKI_STATS_UI_BEGIN_GROUP
+#undef ANKI_STATS_UI_VALUE
+
 	FontPtr m_font;
 	U32 m_bufferedFrames = 0;
-
-	// CPU
-	BufferedValue<Second> m_frameTime;
-	BufferedValue<Second> m_renderTime;
-	BufferedValue<Second> m_sceneUpdateTime;
-	BufferedValue<Second> m_visTestsTime;
-	BufferedValue<Second> m_physicsTime;
-
-	// GPU
-	BufferedValue<Second> m_gpuTime;
-	BufferedValue<U64> m_gpuActive;
-	BufferedValue<PtrSize> m_gpuReadBandwidth;
-	BufferedValue<PtrSize> m_gpuWriteBandwidth;
-
-	// Memory
-	PtrSize m_allocatedCpuMem = 0;
-	U64 m_allocCount = 0;
-	U64 m_freeCount = 0;
-	BuddyAllocatorBuilderStats m_globalVertexPoolStats = {};
-
-	// GR
-	GrManagerStats m_grStats = {};
-
-	// Other
-	PtrSize m_drawableCount = 0;
+	StatsUiDetail m_detail = StatsUiDetail::kDetailed;
 
 	static void labelTime(Second val, CString name)
 	{

AnKi/Core/StdinListener.cpp

@@ -32,7 +32,7 @@ Error StdinListener::create(HeapAllocator<String>& alloc)
 	m_alloc = alloc;
 	m_thrd.start(this, workingFunc);
 
-	return Error::NONE;
+	return Error::kNone;
 }
 
 Error StdinListener::workingFunc(ThreadCallbackInfo& info)
@@ -52,7 +52,7 @@ Error StdinListener::workingFunc(ThreadCallbackInfo& info)
 		self.m_q.getBack().create(alloc, &buff[0]);
 	}
 
-	return Error::NONE;
+	return Error::kNone;
 }
 
 String StdinListener::getLine()

AnKi/Core/StdinListener.h

@@ -20,7 +20,7 @@ class StdinListener
 {
 public:
 	StdinListener()
-		: m_thrd("anki_stdin")
+		: m_thrd("Stdin")
 	{
 	}
 

AnKi/Gr/AccelerationStructure.h

@@ -21,18 +21,18 @@ public:
 	BufferPtr m_indexBuffer;
 	PtrSize m_indexBufferOffset = 0;
 	U32 m_indexCount = 0;
-	IndexType m_indexType = IndexType::COUNT;
+	IndexType m_indexType = IndexType::kCount;
 
 	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
+		if(m_indexBuffer.get() == nullptr || m_indexCount == 0 || m_indexType == IndexType::kCount
+		   || m_positionBuffer.get() == nullptr || m_positionStride == 0 || m_positionsFormat == Format::kNone
 		   || m_positionCount == 0)
 		{
 			return false;
@@ -50,7 +50,7 @@ public:
 			return false;
 		}
 
-		const PtrSize idxStride = (m_indexType == IndexType::U16) ? 2 : 4;
+		const PtrSize idxStride = (m_indexType == IndexType::kU16) ? 2 : 4;
 		if(m_indexBufferOffset + idxStride * m_indexCount > m_indexBuffer->getSize())
 		{
 			return false;
@@ -87,7 +87,7 @@ public:
 class AccelerationStructureInitInfo : public GrBaseInitInfo
 {
 public:
-	AccelerationStructureType m_type = AccelerationStructureType::COUNT;
+	AccelerationStructureType m_type = AccelerationStructureType::kCount;
 	BottomLevelAccelerationStructureInitInfo m_bottomLevel;
 	TopLevelAccelerationStructureInitInfo m_topLevel;
 
@@ -98,12 +98,12 @@ public:
 
 	Bool isValid() const
 	{
-		if(m_type == AccelerationStructureType::COUNT)
+		if(m_type == AccelerationStructureType::kCount)
 		{
 			return false;
 		}
 
-		return (m_type == AccelerationStructureType::BOTTOM_LEVEL) ? m_bottomLevel.isValid() : m_topLevel.isValid();
+		return (m_type == AccelerationStructureType::kBottomLevel) ? m_bottomLevel.isValid() : m_topLevel.isValid();
 	}
 };
 
@@ -113,20 +113,20 @@ class AccelerationStructure : public GrObject
 	ANKI_GR_OBJECT
 
 public:
-	static constexpr GrObjectType CLASS_TYPE = GrObjectType::ACCELERATION_STRUCTURE;
+	static constexpr GrObjectType kClassType = GrObjectType::kAccelerationStructure;
 
 	AccelerationStructureType getType() const
 	{
-		ANKI_ASSERT(m_type != AccelerationStructureType::COUNT);
+		ANKI_ASSERT(m_type != AccelerationStructureType::kCount);
 		return m_type;
 	}
 
 protected:
-	AccelerationStructureType m_type = AccelerationStructureType::COUNT;
+	AccelerationStructureType m_type = AccelerationStructureType::kCount;
 
 	/// Construct.
 	AccelerationStructure(GrManager* manager, CString name)
-		: GrObject(manager, CLASS_TYPE, name)
+		: GrObject(manager, kClassType, name)
 	{
 	}
 

AnKi/Gr/Buffer.h

@@ -19,8 +19,8 @@ class BufferInitInfo : public GrBaseInitInfo
 {
 public:
 	PtrSize m_size = 0;
-	BufferUsageBit m_usage = BufferUsageBit::NONE;
-	BufferMapAccessBit m_mapAccess = BufferMapAccessBit::NONE;
+	BufferUsageBit m_usage = BufferUsageBit::kNone;
+	BufferMapAccessBit m_mapAccess = BufferMapAccessBit::kNone;
 
 	BufferInitInfo(CString name = {})
 		: GrBaseInitInfo(name)
@@ -47,7 +47,7 @@ class Buffer : public GrObject
 	ANKI_GR_OBJECT
 
 public:
-	static constexpr GrObjectType CLASS_TYPE = GrObjectType::BUFFER;
+	static constexpr GrObjectType kClassType = GrObjectType::kBuffer;
 
 	/// Return the size of the buffer.
 	PtrSize getSize() const
@@ -71,18 +71,18 @@ public:
 
 	/// Map the buffer.
 	/// @param offset The starting offset.
-	/// @param range The range to map or MAX_PTR_SIZE to map until the end.
+	/// @param range The range to map or kMaxPtrSize to map until the end.
 	/// @param access The access to the buffer.
 	void* map(PtrSize offset, PtrSize range, BufferMapAccessBit access);
 
 	/// Flush the buffer from the CPU caches. Call it to make the buffer memory available to the GPU.
 	/// @param offset The starting offset.
-	/// @param range The range to map or MAX_PTR_SIZE to map until the end.
+	/// @param range The range to map or kMaxPtrSize to map until the end.
 	void flush(PtrSize offset, PtrSize range) const;
 
 	/// Invalidate the buffer from the CPU caches. Call it to ready the buffer to see GPU updates.
 	/// @param offset The starting offset.
-	/// @param range The range to map or MAX_PTR_SIZE to map until the end.
+	/// @param range The range to map or kMaxPtrSize to map until the end.
 	void invalidate(PtrSize offset, PtrSize range) const;
 
 	/// Convenience map method.
@@ -108,13 +108,13 @@ public:
 
 protected:
 	PtrSize m_size = 0;
-	BufferUsageBit m_usage = BufferUsageBit::NONE;
-	BufferMapAccessBit m_access = BufferMapAccessBit::NONE;
+	BufferUsageBit m_usage = BufferUsageBit::kNone;
+	BufferMapAccessBit m_access = BufferMapAccessBit::kNone;
 	U64 m_gpuAddress = 0;
 
 	/// Construct.
 	Buffer(GrManager* manager, CString name)
-		: GrObject(manager, CLASS_TYPE, name)
+		: GrObject(manager, kClassType, name)
 	{
 	}
 

AnKi/Gr/CommandBuffer.h

@@ -19,18 +19,18 @@ namespace anki {
 /// Command buffer initialization flags.
 enum class CommandBufferFlag : U8
 {
-	NONE = 0,
+	kNone = 0,
 
-	SECOND_LEVEL = 1 << 0,
+	kSecondLevel = 1 << 0,
 
 	/// It will contain a handfull of commands.
-	SMALL_BATCH = 1 << 3,
+	kSmallBatch = 1 << 3,
 
 	/// Will contain graphics, compute and transfer work.
-	GENERAL_WORK = 1 << 4,
+	kGeneralWork = 1 << 4,
 
 	/// Will contain only compute work. It binds to async compute queues.
-	COMPUTE_WORK = 1 << 5,
+	kComputeWork = 1 << 5,
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(CommandBufferFlag)
 
@@ -39,10 +39,10 @@ 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;
+	Array<TextureUsageBit, kMaxColorRenderTargets> m_colorAttachmentUsages = {};
+	TextureUsageBit m_depthStencilAttachmentUsage = TextureUsageBit::kNone;
 
-	CommandBufferFlag m_flags = CommandBufferFlag::NONE;
+	CommandBufferFlag m_flags = CommandBufferFlag::kNone;
 
 	CommandBufferInitInfo(CString name = {})
 		: GrBaseInitInfo(name)
@@ -56,7 +56,7 @@ class CommandBuffer : public GrObject
 	ANKI_GR_OBJECT
 
 public:
-	static constexpr GrObjectType CLASS_TYPE = GrObjectType::COMMAND_BUFFER;
+	static constexpr GrObjectType kClassType = GrObjectType::kCommandBuffer;
 
 	/// Finalize and submit if it's primary command buffer and just finalize if it's second level.
 	/// @param[in]  waitFences Optionally wait for some fences.
@@ -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);
@@ -179,7 +179,7 @@ public:
 	/// @param binding The binding to bind to.
 	/// @param[in,out] buff The buffer to bind.
 	/// @param offset The base of the binding.
-	/// @param range The bytes to bind starting from the offset. If it's MAX_PTR_SIZE then map from offset to the end
+	/// @param range The bytes to bind starting from the offset. If it's kMaxPtrSize then map from offset to the end
 	///              of the buffer.
 	/// @param arrayIdx The array index if the binding is an array.
 	void bindUniformBuffer(U32 set, U32 binding, const BufferPtr& buff, PtrSize offset, PtrSize range,
@@ -190,7 +190,7 @@ public:
 	/// @param binding The binding to bind to.
 	/// @param[in,out] buff The buffer to bind.
 	/// @param offset The base of the binding.
-	/// @param range The bytes to bind starting from the offset. If it's MAX_PTR_SIZE then map from offset to the end
+	/// @param range The bytes to bind starting from the offset. If it's kMaxPtrSize then map from offset to the end
 	///              of the buffer.
 	/// @param arrayIdx The array index if the binding is an array.
 	void bindStorageBuffer(U32 set, U32 binding, const BufferPtr& buff, PtrSize offset, PtrSize range,
@@ -208,7 +208,7 @@ public:
 	/// @param binding The binding to bind to.
 	/// @param[in,out] buff The buffer to bind.
 	/// @param offset The base of the binding.
-	/// @param range The bytes to bind starting from the offset. If it's MAX_PTR_SIZE then map from offset to the end
+	/// @param range The bytes to bind starting from the offset. If it's kMaxPtrSize then map from offset to the end
 	///              of the buffer.
 	/// @param fmt The format of the buffer.
 	/// @param arrayIdx The array index if the binding is an array.
@@ -235,9 +235,9 @@ public:
 	/// The minx, miny, width, height control the area that the load and store operations will happen. If the scissor is
 	/// bigger than the render area the results are undefined.
 	void beginRenderPass(const FramebufferPtr& fb,
-						 const Array<TextureUsageBit, MAX_COLOR_ATTACHMENTS>& colorAttachmentUsages,
-						 TextureUsageBit depthStencilAttachmentUsage, U32 minx = 0, U32 miny = 0, U32 width = MAX_U32,
-						 U32 height = MAX_U32);
+						 const Array<TextureUsageBit, kMaxColorRenderTargets>& colorAttachmentUsages,
+						 TextureUsageBit depthStencilAttachmentUsage, U32 minx = 0, U32 miny = 0, U32 width = kMaxU32,
+						 U32 height = kMaxU32);
 
 	/// End renderpass.
 	void endRenderPass();
@@ -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);
@@ -321,7 +321,7 @@ public:
 	/// Fill a buffer with some value.
 	/// @param[in,out] buff The buffer to fill.
 	/// @param offset From where to start filling. Must be multiple of 4.
-	/// @param size The bytes to fill. Must be multiple of 4 or MAX_PTR_SIZE to indicate the whole buffer.
+	/// @param size The bytes to fill. Must be multiple of 4 or kMaxPtrSize to indicate the whole buffer.
 	/// @param value The value to fill the buffer with.
 	void fillBuffer(const BufferPtr& buff, PtrSize offset, PtrSize size, U32 value);
 
@@ -408,7 +408,7 @@ public:
 protected:
 	/// Construct.
 	CommandBuffer(GrManager* manager, CString name)
-		: GrObject(manager, CLASS_TYPE, name)
+		: GrObject(manager, kClassType, name)
 	{
 	}
 

AnKi/Gr/Common.cpp

@@ -9,10 +9,10 @@
 namespace anki {
 
 /// @warning Don't use Array because the compilers can't handle it for some reason.
-inline constexpr ShaderVariableDataTypeInfo SVD_INFOS[] = {
-#define ANKI_SVDT_MACRO(capital, type, baseType, rowCount, columnCount, isIntagralType) \
+inline constexpr ShaderVariableDataTypeInfo kShaderVariableDataTypeInfos[] = {
+#define ANKI_SVDT_MACRO(type, baseType, rowCount, columnCount, isIntagralType) \
 	{ANKI_STRINGIZE(type), sizeof(type), false, isIntagralType},
-#define ANKI_SVDT_MACRO_OPAQUE(capital, type) {ANKI_STRINGIZE(type), MAX_U32, true, false},
+#define ANKI_SVDT_MACRO_OPAQUE(constant, type) {ANKI_STRINGIZE(type), kMaxU32, true, false},
 #include <AnKi/Gr/ShaderVariableDataType.defs.h>
 #undef ANKI_SVDT_MACRO
 #undef ANKI_SVDT_MACRO_OPAQUE
@@ -20,8 +20,8 @@ inline constexpr ShaderVariableDataTypeInfo SVD_INFOS[] = {
 
 const ShaderVariableDataTypeInfo& getShaderVariableDataTypeInfo(ShaderVariableDataType type)
 {
-	ANKI_ASSERT(type > ShaderVariableDataType::NONE && type < ShaderVariableDataType::COUNT);
-	return SVD_INFOS[U32(type) - 1];
+	ANKI_ASSERT(type > ShaderVariableDataType::kNone && type < ShaderVariableDataType::kCount);
+	return kShaderVariableDataTypeInfos[U32(type) - 1];
 }
 
 FormatInfo getFormatInfo(Format fmt)
@@ -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/Fence.h

@@ -18,7 +18,7 @@ class Fence : public GrObject
 	ANKI_GR_OBJECT
 
 public:
-	static constexpr GrObjectType CLASS_TYPE = GrObjectType::FENCE;
+	static constexpr GrObjectType kClassType = GrObjectType::kFence;
 
 	/// Wait for the fence.
 	/// @param seconds The time to wait in seconds. If it's zero then just return the status.
@@ -28,7 +28,7 @@ public:
 protected:
 	/// Construct.
 	Fence(GrManager* manager, CString name)
-		: GrObject(manager, CLASS_TYPE, name)
+		: GrObject(manager, kClassType, name)
 	{
 	}
 

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(R4G4UnormPack8,                      1,  2,  1,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R4G4B4A4UnormPack16,                 2,  4,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B4G4R4A4UnormPack16,                 3,  4,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R5G6B5UnormPack16,                   4,  3,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B5G6R5UnormPack16,                   5,  3,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R5G5B5A1UnormPack16,                 6,  4,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B5G5R5A1UnormPack16,                 7,  4,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(A1R5G5B5UnormPack16,                 8,  4,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8Unorm,                             9,  1,  1,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8Snorm,                            10,  1,  1,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8Uscaled,                          11,  1,  1,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R8Sscaled,                          12,  1,  1,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R8Uint,                             13,  1,  1,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R8Sint,                             14,  1,  1,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R8Srgb,                             15,  1,  1,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8G8Unorm,                          16,  2,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8G8Snorm,                          17,  2,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8G8Uscaled,                        18,  2,  2,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R8G8Sscaled,                        19,  2,  2,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R8G8Uint,                           20,  2,  2,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R8G8Sint,                           21,  2,  2,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R8G8Srgb,                           22,  2,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8G8B8Unorm,                        23,  3,  3,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8G8B8Snorm,                        24,  3,  3,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8G8B8Uscaled,                      25,  3,  3,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R8G8B8Sscaled,                      26,  3,  3,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R8G8B8Uint,                         27,  3,  3,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R8G8B8Sint,                         28,  3,  3,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R8G8B8Srgb,                         29,  3,  3,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B8G8R8Unorm,                        30,  3,  3,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B8G8R8Snorm,                        31,  3,  3,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B8G8R8Uscaled,                      32,  3,  3,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(B8G8R8Sscaled,                      33,  3,  3,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(B8G8R8Uint,                         34,  3,  3,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(B8G8R8Sint,                         35,  3,  3,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(B8G8R8Srgb,                         36,  3,  3,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8G8B8A8Unorm,                      37,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8G8B8A8Snorm,                      38,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8G8B8A8Uscaled,                    39,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R8G8B8A8Sscaled,                    40,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R8G8B8A8Uint,                       41,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R8G8B8A8Sint,                       42,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R8G8B8A8Srgb,                       43,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B8G8R8A8Unorm,                      44,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B8G8R8A8Snorm,                      45,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B8G8R8A8Uscaled,                    46,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(B8G8R8A8Sscaled,                    47,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(B8G8R8A8Uint,                       48,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(B8G8R8A8Sint,                       49,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(B8G8R8A8Srgb,                       50,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(A8B8G8R8UnormPack32,                51,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(A8B8G8R8SnormPack32,                52,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(A8B8G8R8UscaledPack32,              53,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(A8B8G8R8SscaledPack32,              54,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(A8B8G8R8UintPack32,                 55,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(A8B8G8R8SintPack32,                 56,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(A8B8G8R8SrgbPack32,                 57,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(A2R10G10B10UnormPack32,             58,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(A2R10G10B10SnormPack32,             59,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(A2R10G10B10UscaledPack32,           60,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(A2R10G10B10SscaledPack32,           61,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(A2R10G10B10UintPack32,              62,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(A2R10G10B10SintPack32,              63,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(A2B10G10R10UnormPack32,             64,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(A2B10G10R10SnormPack32,             65,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(A2B10G10R10UscaledPack32,           66,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(A2B10G10R10SscaledPack32,           67,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(A2B10G10R10UintPack32,              68,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(A2B10G10R10SintPack32,              69,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R16Unorm,                           70,  1,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16Snorm,                           71,  1,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16Uscaled,                         72,  1,  2,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R16Sscaled,                         73,  1,  2,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R16Uint,                            74,  1,  2,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R16Sint,                            75,  1,  2,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R16Sfloat,                          76,  1,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16G16Unorm,                        77,  2,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16G16Snorm,                        78,  2,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16G16Uscaled,                      79,  2,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R16G16Sscaled,                      80,  2,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R16G16Uint,                         81,  2,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R16G16Sint,                         82,  2,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R16G16Sfloat,                       83,  2,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16G16B16Unorm,                     84,  3,  6,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16G16B16Snorm,                     85,  3,  6,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16G16B16Uscaled,                   86,  3,  6,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R16G16B16Sscaled,                   87,  3,  6,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R16G16B16Uint,                      88,  3,  6,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R16G16B16Sint,                      89,  3,  6,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R16G16B16Sfloat,                    90,  3,  6,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16G16B16A16Unorm,                  91,  4,  8,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16G16B16A16Snorm,                  92,  4,  8,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16G16B16A16Uscaled,                93,  4,  8,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R16G16B16A16Sscaled,                94,  4,  8,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R16G16B16A16Uint,                   95,  4,  8,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R16G16B16A16Sint,                   96,  4,  8,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R16G16B16A16Sfloat,                 97,  4,  8,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R32Uint,                            98,  1,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R32Sint,                            99,  1,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R32Sfloat,                         100,  1,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R32G32Uint,                        101,  2,  8,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R32G32Sint,                        102,  2,  8,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R32G32Sfloat,                      103,  2,  8,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R32G32B32Uint,                     104,  3, 12,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R32G32B32Sint,                     105,  3, 12,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R32G32B32Sfloat,                   106,  3, 12,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R32G32B32A32Uint,                  107,  4, 16,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R32G32B32A32Sint,                  108,  4, 16,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R32G32B32A32Sfloat,                109,  4, 16,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R64Uint,                           110,  1,  8,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R64Sint,                           111,  1,  8,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R64Sfloat,                         112,  1,  8,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R64G64Uint,                        113,  2, 16,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R64G64Sint,                        114,  2, 16,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R64G64Sfloat,                      115,  2, 16,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R64G64B64Uint,                     116,  3, 24,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R64G64B64Sint,                     117,  3, 24,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R64G64B64Sfloat,                   118,  3, 24,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R64G64B64A64Uint,                  119,  4, 32,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R64G64B64A64Sint,                  120,  4, 32,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R64G64B64A64Sfloat,                121,  4, 32,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B10G11R11UfloatPack32,             122,  3,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(E5B9G9R9UfloatPack32,              123,  3,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(D16Unorm,                          124,  0,  2,  0,  0,  0,  0,        Depth)
+ANKI_FORMAT_DEF(X8D24UnormPack32,                  125,  0,  4,  0,  0,  0,  0,        Depth)
+ANKI_FORMAT_DEF(D32Sfloat,                         126,  0,  4,  0,  0,  0,  0,        Depth)
+ANKI_FORMAT_DEF(S8Uint,                            127,  0,  1,  0,  0,  0,  1,      Stencil)
+ANKI_FORMAT_DEF(D16UnormS8Uint,                    128,  0,  3,  0,  0,  0,  0, DepthStencil)
+ANKI_FORMAT_DEF(D24UnormS8Uint,                    129,  0,  4,  0,  0,  0,  0, DepthStencil)
+ANKI_FORMAT_DEF(D32SfloatS8Uint,                   130,  0,  0,  0,  0,  0,  0, DepthStencil)
+ANKI_FORMAT_DEF(Bc1RgbUnormBlock,                  131,  3,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(Bc1RgbSrgbBlock,                   132,  3,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(Bc1RgbaUnormBlock,                 133,  4,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(Bc1RgbaSrgbBlock,                  134,  4,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(Bc2UnormBlock,                     135,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Bc2SrgbBlock,                      136,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Bc3UnormBlock,                     137,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Bc3SrgbBlock,                      138,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Bc4UnormBlock,                     139,  1,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(Bc4SnormBlock,                     140,  1,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(Bc5UnormBlock,                     141,  2,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Bc5SnormBlock,                     142,  2,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Bc6hUfloatBlock,                   143,  3,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Bc6hSfloatBlock,                   144,  3,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Bc7UnormBlock,                     145,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Bc7SrgbBlock,                      146,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Etc2R8G8B8UnormBlock,              147,  3,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(Etc2R8G8B8SrgbBlock,               148,  3,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(Etc2R8G8B8A1UnormBlock,            149,  4,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(Etc2R8G8B8A1SrgbBlock,             150,  4,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(Etc2R8G8B8A8UnormBlock,            151,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Etc2R8G8B8A8SrgbBlock,             152,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(EacR11UnormBlock,                  153,  1,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(EacR11SnormBlock,                  154,  1,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(EacR11G11UnormBlock,               155,  2,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(EacR11G11SnormBlock,               156,  2,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc4x4UnormBlock,                 157,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc4x4SrgbBlock,                  158,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc5x4UnormBlock,                 159,  4,  0,  5,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc5x4SrgbBlock,                  160,  4,  0,  5,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc5x5UnormBlock,                 161,  4,  0,  5,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc5x5SrgbBlock,                  162,  4,  0,  5,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc6x5UnormBlock,                 163,  4,  0,  6,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc6x5SrgbBlock,                  164,  4,  0,  6,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc6x6UnormBlock,                 165,  4,  0,  6,  6, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc6x6SrgbBlock,                  166,  4,  0,  6,  6, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc8x5UnormBlock,                 167,  4,  0,  8,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc8x5SrgbBlock,                  168,  4,  0,  8,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc8x6UnormBlock,                 169,  4,  0,  8,  6, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc8x6SrgbBlock,                  170,  4,  0,  8,  6, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc8x8UnormBlock,                 171,  4,  0,  8,  8, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc8x8SrgbBlock,                  172,  4,  0,  8,  8, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc10x5UnormBlock,                173,  4,  0, 10,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc10x5SrgbBlock,                 174,  4,  0, 10,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc10x6UnormBlock,                175,  4,  0, 10,  6, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc10x6SrgbBlock,                 176,  4,  0, 10,  6, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc10x8UnormBlock,                177,  4,  0, 10,  8, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc10x8SrgbBlock,                 178,  4,  0, 10,  8, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc10x10UnormBlock,               179,  4,  0, 10, 10, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc10x10SrgbBlock,                180,  4,  0, 10, 10, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc12x10UnormBlock,               181,  4,  0, 12, 10, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc12x10SrgbBlock,                182,  4,  0, 12, 10, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc12x12UnormBlock,               183,  4,  0, 12, 12, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc12x12SrgbBlock,                184,  4,  0, 12, 12, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc4x4SfloatBlock,         1000066000,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc5x4SfloatBlock,         1000066001,  4,  0,  5,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc5x5SfloatBlock,         1000066002,  4,  0,  5,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc6x5SfloatBlock,         1000066003,  4,  0,  6,  8, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc6x6SfloatBlock,         1000066004,  4,  0,  6,  6, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc8x5SfloatBlock,         1000066005,  4,  0,  8,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc8x6SfloatBlock,         1000066006,  4,  0,  8,  6, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc8x8SfloatBlock,         1000066007,  4,  0,  8,  8, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc10x5SfloatBlock,        1000066008,  4,  0, 10,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc10x6SfloatBlock,        1000066009,  4,  0, 10,  6, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc10x8SfloatBlock,        1000066010,  4,  0, 10,  8, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc10x10SfloatBlock,       1000066011,  4,  0, 10, 10, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc12x10SfloatBlock,       1000066012,  4,  0, 12, 10, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc12x12SfloatBlock,       1000066013,  4,  0, 12, 12, 16,  0,         None)
 // clang-format on

AnKi/Gr/Framebuffer.h

@@ -19,11 +19,11 @@ class FramebufferAttachmentInfo
 public:
 	TextureViewPtr m_textureView;
 
-	AttachmentLoadOperation m_loadOperation = AttachmentLoadOperation::CLEAR;
-	AttachmentStoreOperation m_storeOperation = AttachmentStoreOperation::STORE;
+	AttachmentLoadOperation m_loadOperation = AttachmentLoadOperation::kClear;
+	AttachmentStoreOperation m_storeOperation = AttachmentStoreOperation::kStore;
 
-	AttachmentLoadOperation m_stencilLoadOperation = AttachmentLoadOperation::CLEAR;
-	AttachmentStoreOperation m_stencilStoreOperation = AttachmentStoreOperation::STORE;
+	AttachmentLoadOperation m_stencilLoadOperation = AttachmentLoadOperation::kClear;
+	AttachmentStoreOperation m_stencilStoreOperation = AttachmentStoreOperation::kStore;
 
 	ClearValue m_clearValue;
 };
@@ -32,7 +32,7 @@ public:
 class FramebufferInitInfo : public GrBaseInitInfo
 {
 public:
-	Array<FramebufferAttachmentInfo, MAX_COLOR_ATTACHMENTS> m_colorAttachments;
+	Array<FramebufferAttachmentInfo, kMaxColorRenderTargets> m_colorAttachments;
 	U32 m_colorAttachmentCount = 0;
 	FramebufferAttachmentInfo m_depthStencilAttachment;
 
@@ -115,12 +115,12 @@ class Framebuffer : public GrObject
 	ANKI_GR_OBJECT
 
 public:
-	static constexpr GrObjectType CLASS_TYPE = GrObjectType::FRAMEBUFFER;
+	static constexpr GrObjectType kClassType = GrObjectType::kFramebuffer;
 
 protected:
 	/// Construct.
 	Framebuffer(GrManager* manager, CString name)
-		: GrObject(manager, CLASS_TYPE, name)
+		: GrObject(manager, kClassType, name)
 	{
 	}
 

AnKi/Gr/Gl/Buffer.cpp

@@ -32,7 +32,7 @@ Buffer* Buffer::newInstance(GrManager* manager, const BufferInitInfo& inf)
 			(void)oldState;
 			ANKI_ASSERT(oldState == GlObject::State::TO_BE_CREATED);
 
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 

AnKi/Gr/Gl/BufferImpl.cpp

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

AnKi/Gr/Gl/BufferImpl.h

@@ -41,7 +41,7 @@ public:
 	{
 		ANKI_ASSERT(isCreated());
 
-		range = (range == MAX_PTR_SIZE) ? (m_size - offset) : range;
+		range = (range == kMaxPtrSize) ? (m_size - offset) : range;
 		ANKI_ASSERT(range > 0);
 		ANKI_ASSERT(offset + range <= m_size);
 
@@ -50,7 +50,7 @@ public:
 
 	void bind(GLenum target, U32 binding, PtrSize offset) const
 	{
-		bind(target, binding, offset, MAX_PTR_SIZE);
+		bind(target, binding, offset, kMaxPtrSize);
 	}
 
 	void write(GLuint pbo, U32 pboOffset, U32 offset, U32 size) const
@@ -67,7 +67,7 @@ public:
 		ANKI_ASSERT(offset < m_size);
 		ANKI_ASSERT((offset % 4) == 0 && "Should be multiple of 4");
 
-		size = (size == MAX_PTR_SIZE) ? (m_realSize - offset) : size;
+		size = (size == kMaxPtrSize) ? (m_realSize - offset) : size;
 		ANKI_ASSERT(offset + size <= m_realSize);
 		ANKI_ASSERT((size % 4) == 0 && "Should be multiple of 4");
 

AnKi/Gr/Gl/CommandBuffer.cpp

@@ -75,7 +75,7 @@ void CommandBuffer::bindVertexBuffer(U32 binding, BufferPtr buff, PtrSize offset
 		{
 			glBindVertexBuffer(m_binding, static_cast<const BufferImpl&>(*m_buff).getGlName(), m_offset, m_stride);
 			glVertexBindingDivisor(m_binding, (m_instanced) ? 1 : 0);
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -115,7 +115,7 @@ void CommandBuffer::setVertexAttribute(U32 location, U32 buffBinding, Format fmt
 		{
 			glVertexAttribFormat(m_location, m_compSize, m_fmt, m_normalized, m_relativeOffset);
 			glVertexAttribBinding(m_location, m_buffBinding);
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -148,7 +148,7 @@ void CommandBuffer::bindIndexBuffer(BufferPtr buff, PtrSize offset, IndexType ty
 		Error operator()(GlState& state)
 		{
 			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, static_cast<const BufferImpl&>(*m_buff).getGlName());
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -184,7 +184,7 @@ void CommandBuffer::setPrimitiveRestart(Bool enable)
 				glDisable(GL_PRIMITIVE_RESTART);
 			}
 
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -210,7 +210,7 @@ void CommandBuffer::setViewport(U32 minx, U32 miny, U32 width, U32 height)
 		Error operator()(GlState& state)
 		{
 			glViewport(m_value[0], m_value[1], m_value[2], m_value[3]);
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -223,7 +223,7 @@ void CommandBuffer::setViewport(U32 minx, U32 miny, U32 width, U32 height)
 
 void CommandBuffer::setScissor(U32 minx, U32 miny, U32 width, U32 height)
 {
-	ANKI_ASSERT(minx < MAX_U32 && miny < MAX_U32);
+	ANKI_ASSERT(minx < kMaxU32 && miny < kMaxU32);
 	ANKI_ASSERT(width > 0 && height > 0);
 
 	class ScissorCommand final : public GlCommand
@@ -244,13 +244,13 @@ void CommandBuffer::setScissor(U32 minx, U32 miny, U32 width, U32 height)
 				state.m_scissor = m_value;
 				glScissor(m_value[0], m_value[1], m_value[2], m_value[3]);
 			}
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
 	// Limit the width and height to GLsizei
-	const GLsizei iwidth = (width == MAX_U32) ? MAX_I32 : width;
-	const GLsizei iheight = (height == MAX_U32) ? MAX_I32 : height;
+	const GLsizei iwidth = (width == kMaxU32) ? kMaxI32 : width;
+	const GLsizei iheight = (height == kMaxU32) ? kMaxI32 : height;
 	const GLsizei iminx = minx;
 	const GLsizei iminy = miny;
 
@@ -276,7 +276,7 @@ void CommandBuffer::setFillMode(FillMode mode)
 		Error operator()(GlState& state)
 		{
 			glPolygonMode(GL_FRONT_AND_BACK, m_fillMode);
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -302,7 +302,7 @@ void CommandBuffer::setCullMode(FaceSelectionBit mode)
 		Error operator()(GlState& state)
 		{
 			glCullFace(m_mode);
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -339,7 +339,7 @@ void CommandBuffer::setPolygonOffset(F32 factor, F32 units)
 				glPolygonOffset(m_factor, m_units);
 			}
 
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -372,7 +372,7 @@ void CommandBuffer::setStencilOperations(FaceSelectionBit face, StencilOperation
 		Error operator()(GlState& state)
 		{
 			glStencilOpSeparate(m_face, m_stencilFail, m_stencilPassDepthFail, m_stencilPassDepthPass);
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -429,7 +429,7 @@ void CommandBuffer::setStencilWriteMask(FaceSelectionBit face, U32 mask)
 				state.m_stencilWriteMask[0] = state.m_stencilWriteMask[1] = m_mask;
 			}
 
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -462,7 +462,7 @@ void CommandBuffer::setDepthWrite(Bool enable)
 		{
 			glDepthMask(m_enable);
 			state.m_depthWriteMask = m_enable;
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -488,7 +488,7 @@ void CommandBuffer::setDepthCompareOperation(CompareOperation op)
 		Error operator()(GlState& state)
 		{
 			glDepthFunc(m_op);
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -529,7 +529,7 @@ void CommandBuffer::setColorChannelWriteMask(U32 attachment, ColorBit mask)
 
 			state.m_colorWriteMasks[m_attachment] = {{r, g, b, a}};
 
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -564,7 +564,7 @@ void CommandBuffer::setBlendFactors(U32 attachment, BlendFactor srcRgb, BlendFac
 		Error operator()(GlState&)
 		{
 			glBlendFuncSeparatei(m_attachment, m_srcRgb, m_dstRgb, m_srcA, m_dstA);
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -595,7 +595,7 @@ void CommandBuffer::setBlendOperation(U32 attachment, BlendOperation funcRgb, Bl
 		Error operator()(GlState&)
 		{
 			glBlendEquationSeparatei(m_attachment, m_funcRgb, m_funcA);
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -627,7 +627,7 @@ void CommandBuffer::bindTextureAndSampler(U32 set, U32 binding, TextureViewPtr t
 		{
 			glBindTextureUnit(m_unit, static_cast<const TextureViewImpl&>(*m_texView).m_view.m_glName);
 			glBindSampler(m_unit, static_cast<const SamplerImpl&>(*m_sampler).getGlName());
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -663,7 +663,7 @@ void CommandBuffer::bindUniformBuffer(U32 set, U32 binding, BufferPtr buff, PtrS
 		Error operator()(GlState&)
 		{
 			static_cast<const BufferImpl&>(*m_buff).bind(GL_UNIFORM_BUFFER, m_binding, m_offset, m_range);
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -699,7 +699,7 @@ void CommandBuffer::bindStorageBuffer(U32 set, U32 binding, BufferPtr buff, PtrS
 		Error operator()(GlState&)
 		{
 			static_cast<const BufferImpl&>(*m_buff).bind(GL_SHADER_STORAGE_BUFFER, m_binding, m_offset, m_range);
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -734,7 +734,7 @@ void CommandBuffer::bindImage(U32 set, U32 binding, TextureViewPtr img)
 
 			glBindImageTexture(m_unit, view.m_view.m_glName, 0, GL_TRUE, 0, GL_READ_WRITE,
 							   static_cast<const TextureImpl&>(*view.m_tex).m_internalFormat);
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -779,7 +779,7 @@ void CommandBuffer::bindTextureBuffer(U32 set, U32 binding, BufferPtr buff, PtrS
 			const GLuint tex = state.m_texBuffTextures[m_set][m_binding];
 			glTextureBufferRange(tex, m_fmt, static_cast<const BufferImpl&>(*m_buff).getGlName(), m_offset, m_range);
 
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -814,7 +814,7 @@ void CommandBuffer::bindShaderProgram(ShaderProgramPtr prog)
 		{
 			state.m_crntProg = m_prog;
 			glUseProgram(static_cast<const ShaderProgramImpl&>(*m_prog).getGlName());
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -832,7 +832,7 @@ void CommandBuffer::bindShaderProgram(ShaderProgramPtr prog)
 }
 
 void CommandBuffer::beginRenderPass(FramebufferPtr fb,
-									const Array<TextureUsageBit, MAX_COLOR_ATTACHMENTS>& colorAttachmentUsages,
+									const Array<TextureUsageBit, kMaxColorRenderTargets>& colorAttachmentUsages,
 									TextureUsageBit depthStencilAttachmentUsage, U32 minx, U32 miny, U32 width,
 									U32 height)
 {
@@ -852,7 +852,7 @@ void CommandBuffer::beginRenderPass(FramebufferPtr fb,
 		{
 			static_cast<const FramebufferImpl&>(*m_fb).bind(state, m_renderArea[0], m_renderArea[1], m_renderArea[2],
 															m_renderArea[3]);
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -879,7 +879,7 @@ void CommandBuffer::endRenderPass()
 		Error operator()(GlState&)
 		{
 			m_fb->endRenderPass();
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -913,7 +913,7 @@ void CommandBuffer::drawElements(PrimitiveTopology topology, U32 count, U32 inst
 
 			ANKI_TRACE_INC_COUNTER(GR_DRAWCALLS, 1);
 			ANKI_TRACE_INC_COUNTER(GR_VERTICES, m_info.m_instanceCount * m_info.m_count);
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -960,7 +960,7 @@ void CommandBuffer::drawArrays(PrimitiveTopology topology, U32 count, U32 instan
 
 			ANKI_TRACE_INC_COUNTER(GR_DRAWCALLS, 1);
 			ANKI_TRACE_INC_COUNTER(GR_VERTICES, m_info.m_instanceCount * m_info.m_count);
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -1008,7 +1008,7 @@ void CommandBuffer::drawElementsIndirect(PrimitiveTopology topology, U32 drawCou
 										sizeof(DrawElementsIndirectInfo));
 
 			glBindBuffer(GL_DRAW_INDIRECT_BUFFER, 0);
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -1053,7 +1053,7 @@ void CommandBuffer::drawArraysIndirect(PrimitiveTopology topology, U32 drawCount
 									  sizeof(DrawArraysIndirectInfo));
 
 			glBindBuffer(GL_DRAW_INDIRECT_BUFFER, 0);
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -1079,13 +1079,13 @@ void CommandBuffer::dispatchCompute(U32 groupCountX, U32 groupCountY, U32 groupC
 		Error operator()(GlState&)
 		{
 			glDispatchCompute(m_size[0], m_size[1], m_size[2]);
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
 	ANKI_GL_SELF(CommandBufferImpl);
 
-	ANKI_ASSERT(!!(self.m_flags & CommandBufferFlag::COMPUTE_WORK));
+	ANKI_ASSERT(!!(self.m_flags & CommandBufferFlag::kComputeWork));
 	self.m_state.checkDispatch();
 	self.pushBackNewCommand<DispatchCommand>(groupCountX, groupCountY, groupCountZ);
 }
@@ -1110,7 +1110,7 @@ void CommandBuffer::beginOcclusionQuery(OcclusionQueryPtr query)
 		Error operator()(GlState&)
 		{
 			static_cast<OcclusionQueryImpl&>(*m_handle).begin();
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -1133,7 +1133,7 @@ void CommandBuffer::endOcclusionQuery(OcclusionQueryPtr query)
 		Error operator()(GlState&)
 		{
 			static_cast<OcclusionQueryImpl&>(*m_handle).end();
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -1166,7 +1166,7 @@ void CommandBuffer::copyBufferToTextureView(BufferPtr buff, PtrSize offset, PtrS
 
 			texImpl.copyFromBuffer(viewImpl.getSubresource(), static_cast<const BufferImpl&>(*m_buff).getGlName(),
 								   m_offset, m_range);
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -1204,7 +1204,7 @@ void CommandBuffer::copyBufferToBuffer(BufferPtr src, PtrSize srcOffset, BufferP
 		{
 			static_cast<BufferImpl&>(*m_dst).write(static_cast<const BufferImpl&>(*m_src).getGlName(), m_srcOffset,
 												   m_dstOffset, m_range);
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -1235,7 +1235,7 @@ void CommandBuffer::generateMipmaps2d(TextureViewPtr texView)
 			const TextureImpl& texImpl = static_cast<TextureImpl&>(*viewImpl.m_tex);
 
 			texImpl.generateMipmaps2d(viewImpl);
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -1300,7 +1300,7 @@ void CommandBuffer::setBufferBarrier(BufferPtr buff, BufferUsageBit prevUsage, B
 		Error operator()(GlState&)
 		{
 			glMemoryBarrier(m_barrier);
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -1317,12 +1317,12 @@ void CommandBuffer::setBufferBarrier(BufferPtr buff, BufferUsageBit prevUsage, B
 		d |= GL_SHADER_STORAGE_BARRIER_BIT;
 	}
 
-	if(!!(all & BufferUsageBit::INDEX))
+	if(!!(all & BufferUsageBit::kIndex))
 	{
 		d |= GL_ELEMENT_ARRAY_BARRIER_BIT;
 	}
 
-	if(!!(all & BufferUsageBit::VERTEX))
+	if(!!(all & BufferUsageBit::kVertex))
 	{
 		d |= GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT;
 	}
@@ -1378,7 +1378,7 @@ void CommandBuffer::setTextureBarrier(TexturePtr tex, TextureUsageBit prevUsage,
 		Error operator()(GlState&)
 		{
 			glMemoryBarrier(m_barrier);
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -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
 	}
@@ -1443,7 +1443,7 @@ void CommandBuffer::clearTextureView(TextureViewPtr texView, const ClearValue& c
 			const TextureImpl& texImpl = static_cast<TextureImpl&>(*viewImpl.m_tex);
 
 			texImpl.clear(viewImpl.getSubresource(), m_val);
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -1473,7 +1473,7 @@ void CommandBuffer::fillBuffer(BufferPtr buff, PtrSize offset, PtrSize size, U32
 		Error operator()(GlState&)
 		{
 			static_cast<BufferImpl&>(*m_buff).fill(m_offset, m_size, m_value);
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -1509,7 +1509,7 @@ void CommandBuffer::writeOcclusionQueryResultToBuffer(OcclusionQueryPtr query, P
 								numberToPtr<GLuint*>(m_offset));
 			glBindBuffer(GL_QUERY_BUFFER, 0);
 
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -1573,7 +1573,7 @@ void CommandBuffer::setPushConstants(const void* data, U32 dataSize)
 				}
 			}
 
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 

AnKi/Gr/Gl/CommandBufferImpl.cpp

@@ -30,10 +30,10 @@ void CommandBufferImpl::init(const CommandBufferInitInfo& init)
 	m_flags = init.m_flags;
 
 #if ANKI_EXTRA_CHECKS
-	m_state.m_secondLevel = !!(init.m_flags & CommandBufferFlag::SECOND_LEVEL);
+	m_state.m_secondLevel = !!(init.m_flags & CommandBufferFlag::kSecondLevel);
 #endif
 
-	if(!!(init.m_flags & CommandBufferFlag::SECOND_LEVEL))
+	if(!!(init.m_flags & CommandBufferFlag::kSecondLevel))
 	{
 		// TODO Need to hold a ref
 		m_state.m_fb = static_cast<const FramebufferImpl*>(init.m_framebuffer.get());
@@ -73,7 +73,7 @@ Error CommandBufferImpl::executeAllCommands()
 	m_executed = true;
 #endif
 
-	Error err = Error::NONE;
+	Error err = Error::kNone;
 	GlState& state = static_cast<GrManagerImpl&>(getManager()).getState();
 
 	GlCommand* command = m_firstCommand;
@@ -136,12 +136,12 @@ void CommandBufferImpl::flushDrawcall(CommandBuffer& cmdb)
 
 			if(m_state.m_stencilCompareMask[i] == StateTracker::DUMMY_STENCIL_MASK)
 			{
-				cmdb.setStencilCompareMask(face, MAX_U32);
+				cmdb.setStencilCompareMask(face, kMaxU32);
 			}
 
 			if(m_state.m_stencilWriteMask[i] == StateTracker::DUMMY_STENCIL_MASK)
 			{
-				cmdb.setStencilWriteMask(face, MAX_U32);
+				cmdb.setStencilWriteMask(face, kMaxU32);
 			}
 
 			if(m_state.m_stencilRef[i] == StateTracker::DUMMY_STENCIL_MASK)
@@ -160,7 +160,7 @@ void CommandBufferImpl::flushDrawcall(CommandBuffer& cmdb)
 			cmdb.setDepthCompareOperation(CompareOperation::LESS);
 		}
 
-		for(U i = 0; i < MAX_COLOR_ATTACHMENTS; ++i)
+		for(U i = 0; i < kMaxColorRenderTargets; ++i)
 		{
 			const auto& att = m_state.m_colorAtt[i];
 			if(att.m_writeMask == StateTracker::INVALID_COLOR_MASK)
@@ -181,7 +181,7 @@ void CommandBufferImpl::flushDrawcall(CommandBuffer& cmdb)
 
 		if(!m_state.m_scissorSet)
 		{
-			cmdb.setScissor(0, 0, MAX_U32, MAX_U32);
+			cmdb.setScissor(0, 0, kMaxU32, kMaxU32);
 		}
 	}
 
@@ -207,7 +207,7 @@ void CommandBufferImpl::flushDrawcall(CommandBuffer& cmdb)
 		Error operator()(GlState&)
 		{
 			glStencilFuncSeparate(m_face, m_func, m_ref, m_compareMask);
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -242,7 +242,7 @@ void CommandBufferImpl::flushDrawcall(CommandBuffer& cmdb)
 			{
 				glDisable(GL_DEPTH_TEST);
 			}
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -271,7 +271,7 @@ void CommandBufferImpl::flushDrawcall(CommandBuffer& cmdb)
 			{
 				glDisable(GL_STENCIL_TEST);
 			}
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
@@ -294,7 +294,7 @@ void CommandBufferImpl::flushDrawcall(CommandBuffer& cmdb)
 
 		Error operator()(GlState&)
 		{
-			for(U i = 0; i < MAX_COLOR_ATTACHMENTS; ++i)
+			for(U i = 0; i < kMaxColorRenderTargets; ++i)
 			{
 				if(m_enableMask & (1 << i))
 				{
@@ -305,13 +305,13 @@ void CommandBufferImpl::flushDrawcall(CommandBuffer& cmdb)
 					glDisablei(GL_BLEND, i);
 				}
 			}
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 
 	U8 blendEnableMask = 0;
 	U8 blendDisableMask = 0;
-	for(U i = 0; i < MAX_COLOR_ATTACHMENTS; ++i)
+	for(U i = 0; i < kMaxColorRenderTargets; ++i)
 	{
 		if(m_state.maybeEnableBlend(i))
 		{

AnKi/Gr/Gl/CommandBufferImpl.h

@@ -99,7 +99,7 @@ public:
 
 	Bool isSecondLevel() const
 	{
-		return !!(m_flags & CommandBufferFlag::SECOND_LEVEL);
+		return !!(m_flags & CommandBufferFlag::kSecondLevel);
 	}
 
 	void flushDrawcall(CommandBuffer& cmdb);

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::kR32Sfloat:
 		compCount = 1;
 		type = GL_FLOAT;
 		normalized = false;
 		break;
-	case Format::R32G32_SFLOAT:
+	case Format::kR32G32Sfloat:
 		compCount = 2;
 		type = GL_FLOAT;
 		normalized = false;
 		break;
-	case Format::R32G32B32_SFLOAT:
+	case Format::kR32G32B32Sfloat:
 		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::kR8G8B8A8Unorm:
 		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::kR8G8B8A8Unorm:
 		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::kR32Sfloat:
 		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::kR32G32Sfloat:
 		format = GL_RG;
 		internalFormat = GL_RG32F;
 		type = GL_FLOAT;
 		break;
-	case Format::R32G32_UINT:
+	case Format::kR32G32Uint:
 		format = GL_RG_INTEGER;
 		internalFormat = GL_RG32UI;
 		type = GL_UNSIGNED_INT;
 		break;
-	case Format::R32G32B32_SFLOAT:
+	case Format::kR32G32B32Sfloat:
 		format = GL_RGB;
 		internalFormat = GL_RGB32F;
 		type = GL_FLOAT;

AnKi/Gr/Gl/Common.h

@@ -30,10 +30,10 @@ class RenderingThread;
 /// @addtogroup opengl
 /// @{
 
-#define ANKI_GL_LOGI(...) ANKI_LOG("GL  ", NORMAL, __VA_ARGS__)
-#define ANKI_GL_LOGE(...) ANKI_LOG("GL  ", ERROR, __VA_ARGS__)
-#define ANKI_GL_LOGW(...) ANKI_LOG("GL  ", WARNING, __VA_ARGS__)
-#define ANKI_GL_LOGF(...) ANKI_LOG("GL  ", FATAL, __VA_ARGS__)
+#define ANKI_GL_LOGI(...) ANKI_LOG("GL  ", kNormal, __VA_ARGS__)
+#define ANKI_GL_LOGE(...) ANKI_LOG("GL  ", kError, __VA_ARGS__)
+#define ANKI_GL_LOGW(...) ANKI_LOG("GL  ", kWarning, __VA_ARGS__)
+#define ANKI_GL_LOGF(...) ANKI_LOG("GL  ", kFatal, __VA_ARGS__)
 
 #define ANKI_GL_SELF(class_) class_& self = *static_cast<class_*>(this)
 #define ANKI_GL_SELF_CONST(class_) const class_& self = *static_cast<const class_*>(this)
@@ -79,10 +79,10 @@ inline GLenum convertIndexType(IndexType ak)
 	GLenum out;
 	switch(ak)
 	{
-	case IndexType::U16:
+	case IndexType::kU16:
 		out = GL_UNSIGNED_SHORT;
 		break;
-	case IndexType::U32:
+	case IndexType::kU32:
 		out = GL_UNSIGNED_INT;
 		break;
 	default:
@@ -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/Fence.cpp

@@ -64,7 +64,7 @@ Bool Fence::clientWait(Second seconds)
 			else
 			{
 				ANKI_ASSERT(out == GL_WAIT_FAILED);
-				return Error::FUNCTION_FAILED;
+				return Error::kFunctionFailed;
 			}
 
 			if(m_barrier)
@@ -72,7 +72,7 @@ Bool Fence::clientWait(Second seconds)
 				m_barrier->wait();
 			}
 
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 

AnKi/Gr/Gl/FenceImpl.cpp

@@ -27,7 +27,7 @@ FenceImpl::~FenceImpl()
 		Error operator()(GlState&)
 		{
 			glDeleteSync(m_fence);
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 

AnKi/Gr/Gl/FramebufferImpl.cpp

@@ -37,7 +37,7 @@ Error FramebufferImpl::init(const FramebufferInitInfo& init)
 
 		m_drawBuffers[i] = binding;
 
-		if(att.m_loadOperation == AttachmentLoadOperation::DONT_CARE)
+		if(att.m_loadOperation == AttachmentLoadOperation::kDontCare)
 		{
 			m_invalidateBuffers[m_invalidateBuffersCount++] = binding;
 		}
@@ -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;
 		}
@@ -78,7 +78,7 @@ Error FramebufferImpl::init(const FramebufferInitInfo& init)
 
 		attachTextureInternal(binding, viewImpl, att);
 
-		if(att.m_loadOperation == AttachmentLoadOperation::DONT_CARE)
+		if(att.m_loadOperation == AttachmentLoadOperation::kDontCare)
 		{
 			m_invalidateBuffers[m_invalidateBuffersCount++] = binding;
 		}
@@ -95,11 +95,11 @@ Error FramebufferImpl::init(const FramebufferInitInfo& init)
 		}
 
 		// Misc
-		m_clearDepth = !!(viewImpl.getSubresource().m_depthStencilAspect & DepthStencilAspectBit::DEPTH)
-					   && att.m_loadOperation == AttachmentLoadOperation::CLEAR;
+		m_clearDepth = !!(viewImpl.getSubresource().m_depthStencilAspect & DepthStencilAspectBit::kDepth)
+					   && att.m_loadOperation == AttachmentLoadOperation::kClear;
 
 		m_clearStencil = !!(viewImpl.getSubresource().m_depthStencilAspect & DepthStencilAspectBit::STENCIL)
-						 && att.m_stencilLoadOperation == AttachmentLoadOperation::CLEAR;
+						 && att.m_stencilLoadOperation == AttachmentLoadOperation::kClear;
 	}
 
 	// Check completeness
@@ -107,11 +107,11 @@ Error FramebufferImpl::init(const FramebufferInitInfo& init)
 	if(status != GL_FRAMEBUFFER_COMPLETE)
 	{
 		ANKI_GL_LOGE("FBO is incomplete. Status: 0x%x", status);
-		return Error::FUNCTION_FAILED;
+		return Error::kFunctionFailed;
 	}
 
 	glBindFramebuffer(GL_FRAMEBUFFER, 0);
-	return Error::NONE;
+	return Error::kNone;
 }
 
 void FramebufferImpl::attachTextureInternal(GLenum attachment, const TextureViewImpl& view,
@@ -187,7 +187,7 @@ void FramebufferImpl::bind(const GlState& state, U32 minx, U32 miny, U32 width,
 	{
 		const FramebufferAttachmentInfo& att = m_in.m_colorAttachments[i];
 
-		if(att.m_loadOperation == AttachmentLoadOperation::CLEAR)
+		if(att.m_loadOperation == AttachmentLoadOperation::kClear)
 		{
 			// Enable write mask in case a pipeline changed it (else no clear will happen) and then restore state
 			Bool restore = false;
@@ -231,15 +231,15 @@ void FramebufferImpl::bind(const GlState& state, U32 minx, U32 miny, U32 width,
 		// Enable write mask in case a pipeline changed it (else no clear will happen) and then restore state
 		// From the spec: The clear operation always uses the front stencil write mask when clearing the stencil
 		// buffer
-		if(state.m_stencilWriteMask[0] != MAX_U32)
+		if(state.m_stencilWriteMask[0] != kMaxU32)
 		{
-			glStencilMaskSeparate(GL_FRONT, MAX_U32);
+			glStencilMaskSeparate(GL_FRONT, kMaxU32);
 		}
 
 		GLint clearVal = m_in.m_depthStencilAttachment.m_clearValue.m_depthStencil.m_stencil;
 		glClearBufferiv(GL_STENCIL, 0, &clearVal);
 
-		if(state.m_stencilWriteMask[0] != MAX_U32)
+		if(state.m_stencilWriteMask[0] != kMaxU32)
 		{
 			glStencilMaskSeparate(GL_FRONT, state.m_stencilWriteMask[0]);
 		}

AnKi/Gr/Gl/FramebufferImpl.h

@@ -45,8 +45,8 @@ private:
 	FramebufferInitInfo m_in;
 
 	Array<U32, 2> m_fbSize = {};
-	Array<GLenum, MAX_COLOR_ATTACHMENTS> m_drawBuffers;
-	Array<GLenum, MAX_COLOR_ATTACHMENTS + 1> m_invalidateBuffers;
+	Array<GLenum, kMaxColorRenderTargets> m_drawBuffers;
+	Array<GLenum, kMaxColorRenderTargets + 1> m_invalidateBuffers;
 	U8 m_invalidateBuffersCount = 0;
 	Bool m_clearDepth = false;
 	Bool m_clearStencil = false;
@@ -56,7 +56,8 @@ private:
 									  const FramebufferAttachmentInfo& info);
 
 	/// Create the FBO
-	ANKI_USE_RESULT Error createFbo(const Array<U, MAX_COLOR_ATTACHMENTS + 1>& layers, GLenum depthStencilBindingPoint);
+	ANKI_USE_RESULT Error createFbo(const Array<U, kMaxColorRenderTargets + 1>& layers,
+									GLenum depthStencilBindingPoint);
 };
 /// @}
 

AnKi/Gr/Gl/GlObject.cpp

@@ -20,7 +20,7 @@ GlObject::GlObject()
 
 Error GlObject::serializeRenderingThread(GrManager& manager)
 {
-	Error err = Error::NONE;
+	Error err = Error::kNone;
 	State state = State(m_state.load());
 	ANKI_ASSERT(state != State::NEW);
 
@@ -33,7 +33,7 @@ Error GlObject::serializeRenderingThread(GrManager& manager)
 
 		if(state == State::ERROR)
 		{
-			err = Error::UNKNOWN;
+			err = Error::kUnknown;
 		}
 	}
 
@@ -59,7 +59,7 @@ void GlObject::destroyDeferred(GrManager& manager, GlDeleteFunction deleteCallba
 		Error operator()(GlState&)
 		{
 			m_callback(1, &m_glName);
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 

AnKi/Gr/Gl/GlState.cpp

@@ -91,24 +91,24 @@ void GlState::initRenderThread()
 	// Vendor
 	CString glstr = reinterpret_cast<const char*>(glGetString(GL_VENDOR));
 
-	if(glstr.find("ARM") != CString::NPOS)
+	if(glstr.find("ARM") != CString::kNpos)
 	{
 		m_gpu = GpuVendor::ARM;
 	}
-	else if(glstr.find("NVIDIA") != CString::NPOS)
+	else if(glstr.find("NVIDIA") != CString::kNpos)
 	{
 		m_gpu = GpuVendor::NVIDIA;
 	}
-	else if(glstr.find("AMD") != CString::NPOS || glstr.find("ATI") != CString::NPOS)
+	else if(glstr.find("AMD") != CString::kNpos || glstr.find("ATI") != CString::kNpos)
 	{
 		m_gpu = GpuVendor::AMD;
 	}
-	else if(glstr.find("Intel") != CString::NPOS)
+	else if(glstr.find("Intel") != CString::kNpos)
 	{
 		m_gpu = GpuVendor::INTEL;
 	}
 
-	ANKI_GL_LOGI("GPU vendor is %s", &GPU_VENDOR_STR[m_gpu][0]);
+	ANKI_GL_LOGI("GPU vendor is %s", &kGPUVendorStrings[m_gpu][0]);
 
 // Enable debug messages
 #if ANKI_GL == ANKI_GL_DESKTOP
@@ -134,7 +134,7 @@ void GlState::initRenderThread()
 	glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
 	glEnable(GL_CULL_FACE);
 	glEnable(GL_SCISSOR_TEST);
-	glScissor(0, 0, MAX_I16, MAX_I16);
+	glScissor(0, 0, kMaxI16, kMaxI16);
 	glClipControl(GL_LOWER_LEFT, GL_ZERO_TO_ONE);
 
 	// Create default VAO
@@ -142,7 +142,7 @@ void GlState::initRenderThread()
 	glBindVertexArray(m_defaultVao);
 
 	// Enable all attributes
-	for(U i = 0; i < MAX_VERTEX_ATTRIBUTES; ++i)
+	for(U i = 0; i < kMaxVertexAttributes; ++i)
 	{
 		glEnableVertexAttribArray(i);
 	}
@@ -163,15 +163,15 @@ void GlState::initRenderThread()
 	glGetInteger64v(GL_MAX_SHADER_STORAGE_BLOCK_SIZE, &val);
 	m_storageBlockMaxSize = val;
 
-	m_tboMaxRange = MAX_U32;
+	m_tboMaxRange = kMaxU32;
 
 	// Texture buffer textures
-	glGenTextures(MAX_DESCRIPTOR_SETS * MAX_TEXTURE_BUFFER_BINDINGS, &m_texBuffTextures[0][0]);
-	for(U i = 0; i < MAX_DESCRIPTOR_SETS; ++i)
+	glGenTextures(kMaxDescriptorSets * MAX_TEXTURE_BUFFER_BINDINGS, &m_texBuffTextures[0][0]);
+	for(U i = 0; i < kMaxDescriptorSets; ++i)
 	{
 		for(U j = 0; j < MAX_TEXTURE_BUFFER_BINDINGS; ++j)
 		{
-			U unit = MAX_TEXTURE_BINDINGS * MAX_DESCRIPTOR_SETS + MAX_TEXTURE_BUFFER_BINDINGS * i + j;
+			U unit = MAX_TEXTURE_BINDINGS * kMaxDescriptorSets + MAX_TEXTURE_BUFFER_BINDINGS * i + j;
 			glActiveTexture(GL_TEXTURE0 + unit);
 
 			glBindTexture(GL_TEXTURE_BUFFER, m_texBuffTextures[i][j]);

AnKi/Gr/Gl/GlState.h

@@ -42,19 +42,19 @@ public:
 
 	/// @name FB
 	/// @{
-	Array2d<Bool, MAX_COLOR_ATTACHMENTS, 4> m_colorWriteMasks = {{{{true, true, true, true}},
-																  {{true, true, true, true}},
-																  {{true, true, true, true}},
-																  {{true, true, true, true}}}};
+	Array2d<Bool, kMaxColorRenderTargets, 4> m_colorWriteMasks = {{{{true, true, true, true}},
+																   {{true, true, true, true}},
+																   {{true, true, true, true}},
+																   {{true, true, true, true}}}};
 
 	Bool m_depthWriteMask = true;
 
-	Array<U32, 2> m_stencilWriteMask = {{MAX_U32, MAX_U32}};
+	Array<U32, 2> m_stencilWriteMask = {{kMaxU32, kMaxU32}};
 	/// @}
 
-	Array2d<GLuint, MAX_DESCRIPTOR_SETS, MAX_TEXTURE_BUFFER_BINDINGS> m_texBuffTextures = {};
+	Array2d<GLuint, kMaxDescriptorSets, MAX_TEXTURE_BUFFER_BINDINGS> m_texBuffTextures = {};
 
-	Array<GLsizei, 4> m_scissor = {{0, 0, MAX_I32, MAX_I32}};
+	Array<GLsizei, 4> m_scissor = {{0, 0, kMaxI32, kMaxI32}};
 
 	GlState(GrManager* manager)
 		: m_manager(manager)

AnKi/Gr/Gl/GrManagerImpl.cpp

@@ -70,7 +70,7 @@ Error GrManagerImpl::init(GrManagerInitInfo& init, GrAllocator<U8> alloc)
 
 	initFakeDefaultFb(init);
 
-	return Error::NONE;
+	return Error::kNone;
 }
 
 void GrManagerImpl::initFakeDefaultFb(GrManagerInitInfo& init)
@@ -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::kR8G8B8A8Unorm;
 	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/GrManagerImplSdl.cpp

@@ -42,7 +42,7 @@ public:
 			if(SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG))
 			{
 				ANKI_GL_LOGE("SDL_GL_SetAttribute() failed");
-				return Error::FUNCTION_FAILED;
+				return Error::kFunctionFailed;
 			}
 		}
 
@@ -51,7 +51,7 @@ public:
 		   || SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE))
 		{
 			ANKI_GL_LOGE("SDL_GL_SetAttribute() failed");
-			return Error::FUNCTION_FAILED;
+			return Error::kFunctionFailed;
 		}
 
 		// Create context
@@ -59,7 +59,7 @@ public:
 		if(m_context == nullptr)
 		{
 			ANKI_GL_LOGE("SDL_GL_CreateContext() failed: %s", SDL_GetError());
-			return Error::FUNCTION_FAILED;
+			return Error::kFunctionFailed;
 		}
 
 		// GLEW
@@ -67,11 +67,11 @@ public:
 		if(glewInit() != GLEW_OK)
 		{
 			ANKI_GL_LOGE("GLEW initialization failed");
-			return Error::FUNCTION_FAILED;
+			return Error::kFunctionFailed;
 		}
 		glGetError();
 
-		return Error::NONE;
+		return Error::kNone;
 	}
 
 	void pinContextToCurrentThread(Bool pin)

AnKi/Gr/Gl/OcclusionQuery.cpp

@@ -33,7 +33,7 @@ OcclusionQuery* OcclusionQuery::newInstance(GrManager* manager)
 			(void)oldState;
 			ANKI_ASSERT(oldState == GlObject::State::TO_BE_CREATED);
 
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 

AnKi/Gr/Gl/OcclusionQueryImpl.cpp

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

AnKi/Gr/Gl/RenderingThread.cpp

@@ -33,7 +33,7 @@ public:
 		glFlush();
 		glFinish();
 		m_renderingThread->m_syncBarrier.wait();
-		return Error::NONE;
+		return Error::kNone;
 	}
 };
 
@@ -60,7 +60,7 @@ public:
 
 		// Swap buffers
 		m_renderingThread->swapBuffersInternal();
-		return Error::NONE;
+		return Error::kNone;
 	}
 };
 
@@ -70,7 +70,7 @@ class EmptyCommand final : public GlCommand
 public:
 	ANKI_USE_RESULT Error operator()(GlState&)
 	{
-		return Error::NONE;
+		return Error::kNone;
 	}
 };
 
@@ -111,7 +111,7 @@ void RenderingThread::flushCommandBuffer(CommandBufferPtr cmdb, FencePtr* fence)
 			Error operator()(GlState&)
 			{
 				static_cast<FenceImpl&>(*m_fence).m_fence = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
-				return Error::NONE;
+				return Error::kNone;
 			}
 		};
 
@@ -222,7 +222,7 @@ Error RenderingThread::threadCallback(ThreadCallbackInfo& info)
 {
 	RenderingThread* thread = static_cast<RenderingThread*>(info.m_userData);
 	thread->threadLoop();
-	return Error::NONE;
+	return Error::kNone;
 }
 
 void RenderingThread::threadLoop()
@@ -256,7 +256,7 @@ void RenderingThread::threadLoop()
 			++m_head;
 		}
 
-		Error err = Error::NONE;
+		Error err = Error::kNone;
 		{
 			ANKI_TRACE_SCOPED_EVENT(GL_THREAD);
 			err = static_cast<CommandBufferImpl&>(*cmd).executeAllCommands();

AnKi/Gr/Gl/Sampler.cpp

@@ -34,7 +34,7 @@ Sampler* Sampler::newInstance(GrManager* manager, const SamplerInitInfo& init)
 			(void)oldState;
 			ANKI_ASSERT(oldState == GlObject::State::TO_BE_CREATED);
 
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 

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/ShaderImpl.cpp

@@ -144,10 +144,10 @@ Error ShaderImpl::init(CString source, ConstWeakArray<ShaderSpecializationConstV
 		ShaderCompiler::logShaderErrorCode(compilerLog.toCString(), source, alloc);
 
 		// Compilation failed, set error anyway
-		return Error::USER_DATA;
+		return Error::kUserData;
 	}
 
-	return Error::NONE;
+	return Error::kNone;
 }
 
 } // end namespace anki

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,14 +60,14 @@ 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);
 }
 
 Error ShaderProgramImpl::link(GLuint vert, GLuint frag)
 {
-	Error err = Error::NONE;
+	Error err = Error::kNone;
 
 	glLinkProgram(m_glName);
 	GLint status = 0;
@@ -87,7 +87,7 @@ Error ShaderProgramImpl::link(GLuint vert, GLuint frag)
 
 		ANKI_GL_LOGE("Link error log follows (vs:%u, fs:%u):\n%s", vert, frag, &infoLogTxt[0]);
 
-		err = Error::USER_DATA;
+		err = Error::kUserData;
 	}
 
 	return err;
@@ -122,7 +122,7 @@ const ShaderProgramImplReflection& ShaderProgramImpl::getReflection()
 			}
 
 			// Set type
-			ShaderVariableDataType akType = ShaderVariableDataType::NONE;
+			ShaderVariableDataType akType = ShaderVariableDataType::kNone;
 			switch(type)
 			{
 			case GL_FLOAT_VEC4:

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

@@ -42,12 +42,12 @@ public:
 	class VertexAttribute
 	{
 	public:
-		U32 m_buffBinding = MAX_U32;
-		Format m_fmt = Format::NONE;
-		PtrSize m_relativeOffset = MAX_PTR_SIZE;
+		U32 m_buffBinding = kMaxU32;
+		Format m_fmt = Format::kNone;
+		PtrSize m_relativeOffset = kMaxPtrSize;
 	};
 
-	Array<VertexAttribute, MAX_VERTEX_ATTRIBUTES> m_attribs;
+	Array<VertexAttribute, kMaxVertexAttributes> m_attribs;
 
 	Bool setVertexAttribute(U32 location, U32 buffBinding, Format fmt, PtrSize relativeOffset)
 	{
@@ -72,7 +72,7 @@ public:
 		VertexStepRate m_stepRate = VertexStepRate::COUNT;
 	};
 
-	Array<VertexBuffer, MAX_VERTEX_ATTRIBUTES> m_vertBuffs;
+	Array<VertexBuffer, kMaxVertexAttributes> m_vertBuffs;
 
 	Bool bindVertexBuffer(U32 binding, BufferPtr buff, PtrSize offset, PtrSize stride, VertexStepRate stepRate)
 	{
@@ -88,7 +88,7 @@ public:
 	{
 	public:
 		BufferImpl* m_buff = nullptr;
-		PtrSize m_offset = MAX_PTR_SIZE;
+		PtrSize m_offset = kMaxPtrSize;
 		GLenum m_indexType = 0;
 	} m_idx;
 
@@ -118,11 +118,11 @@ public:
 
 	/// @name viewport_state
 	/// @{
-	Array<U32, 4> m_viewport = {{MAX_U32, MAX_U32, MAX_U32, MAX_U32}};
+	Array<U32, 4> m_viewport = {{kMaxU32, kMaxU32, kMaxU32, kMaxU32}};
 
 	Bool setViewport(U32 minx, U32 miny, U32 width, U32 height)
 	{
-		ANKI_ASSERT(minx != MAX_U32 && miny != MAX_U32 && width != MAX_U32 && height != MAX_U32);
+		ANKI_ASSERT(minx != kMaxU32 && miny != kMaxU32 && width != kMaxU32 && height != kMaxU32);
 		if(m_viewport[0] != minx || m_viewport[1] != miny || m_viewport[2] != width || m_viewport[3] != height)
 		{
 			m_viewport = {{minx, miny, width, height}};
@@ -134,7 +134,7 @@ public:
 
 	/// @name scissor_state
 	/// @{
-	Array<GLsizei, 4> m_scissor = {{0, 0, MAX_I32, MAX_I32}};
+	Array<GLsizei, 4> m_scissor = {{0, 0, kMaxI32, kMaxI32}};
 	Bool m_scissorSet = false;
 
 	Bool setScissor(GLsizei minx, GLsizei miny, GLsizei width, GLsizei height)
@@ -365,7 +365,7 @@ public:
 
 	/// @name color
 	/// @{
-	static const ColorBit INVALID_COLOR_MASK = static_cast<ColorBit>(MAX_U8);
+	static const ColorBit INVALID_COLOR_MASK = static_cast<ColorBit>(kMaxU8);
 
 	class ColorAttachment
 	{
@@ -380,7 +380,7 @@ public:
 		BlendOperation m_blendOpA = BlendOperation::COUNT;
 	};
 
-	Array<ColorAttachment, MAX_COLOR_ATTACHMENTS> m_colorAtt;
+	Array<ColorAttachment, kMaxColorRenderTargets> m_colorAtt;
 
 	Bool setColorChannelWriteMask(U32 attachment, ColorBit mask)
 	{
@@ -444,7 +444,7 @@ public:
 		U64 m_samplerUuid = 0;
 	};
 
-	Array2d<TextureBinding, MAX_DESCRIPTOR_SETS, MAX_TEXTURE_BINDINGS> m_textures;
+	Array2d<TextureBinding, kMaxDescriptorSets, MAX_TEXTURE_BINDINGS> m_textures;
 
 	Bool bindTextureViewAndSampler(U32 set, U32 binding, const TextureViewPtr& texView, const SamplerPtr& sampler)
 	{
@@ -473,7 +473,7 @@ public:
 		PtrSize m_range;
 	};
 
-	Array2d<ShaderBufferBinding, MAX_DESCRIPTOR_SETS, MAX_UNIFORM_BUFFER_BINDINGS> m_ubos;
+	Array2d<ShaderBufferBinding, kMaxDescriptorSets, MAX_UNIFORM_BUFFER_BINDINGS> m_ubos;
 
 	Bool bindUniformBuffer(U32 set, U32 binding, BufferPtr buff, PtrSize offset, PtrSize range)
 	{
@@ -484,7 +484,7 @@ public:
 		return true;
 	}
 
-	Array2d<ShaderBufferBinding, MAX_DESCRIPTOR_SETS, MAX_STORAGE_BUFFER_BINDINGS> m_ssbos;
+	Array2d<ShaderBufferBinding, kMaxDescriptorSets, MAX_STORAGE_BUFFER_BINDINGS> m_ssbos;
 
 	Bool bindStorageBuffer(U32 set, U32 binding, BufferPtr buff, PtrSize offset, PtrSize range)
 	{
@@ -501,7 +501,7 @@ public:
 		U64 m_texViewUuid = 0;
 	};
 
-	Array2d<ImageBinding, MAX_DESCRIPTOR_SETS, MAX_IMAGE_BINDINGS> m_images;
+	Array2d<ImageBinding, kMaxDescriptorSets, MAX_IMAGE_BINDINGS> m_images;
 
 	Bool bindImage(U32 set, U32 binding, const TextureViewPtr& img)
 	{
@@ -573,7 +573,7 @@ public:
 
 	void checkDrawcall() const
 	{
-		ANKI_ASSERT(m_viewport[1] != MAX_U16 && "Forgot to set the viewport");
+		ANKI_ASSERT(m_viewport[1] != kMaxU16 && "Forgot to set the viewport");
 		ANKI_ASSERT(m_prog && "Forgot to bound a program");
 		ANKI_ASSERT((insideRenderPass() || m_secondLevel) && "Forgot to begin a render pass");
 	}

AnKi/Gr/Gl/Texture.cpp

@@ -34,7 +34,7 @@ Texture* Texture::newInstance(GrManager* manager, const TextureInitInfo& init)
 			ANKI_ASSERT(oldState == GlObject::State::TO_BE_CREATED);
 			(void)oldState;
 
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 

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:
@@ -79,7 +79,7 @@ public:
 			glDeleteTextures(1, &m_tex);
 		}
 
-		return Error::NONE;
+		return Error::kNone;
 	}
 };
 
@@ -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/Gl/TextureView.cpp

@@ -32,7 +32,7 @@ TextureView* TextureView::newInstance(GrManager* manager, const TextureViewInitI
 			ANKI_ASSERT(oldState == GlObject::State::TO_BE_CREATED);
 			(void)oldState;
 
-			return Error::NONE;
+			return Error::kNone;
 		}
 	};
 

AnKi/Gr/GrObject.h

@@ -16,23 +16,23 @@ namespace anki {
 /// Graphics object type.
 enum class GrObjectType : U8
 {
-	BUFFER,
-	COMMAND_BUFFER,
-	FRAMEBUFFER,
-	OCCLUSION_QUERY,
-	TIMESTAMP_QUERY,
-	SAMPLER,
-	SHADER,
-	TEXTURE,
-	TEXTURE_VIEW,
-	SHADER_PROGRAM,
-	FENCE,
-	RENDER_GRAPH,
-	ACCELERATION_STRUCTURE,
-	GR_UPSCALER,
-
-	COUNT,
-	FIRST = 0
+	kBuffer,
+	kCommandBuffer,
+	kFramebuffer,
+	kOcclusionQuery,
+	kTimstampQuery,
+	kSampler,
+	kShader,
+	kTexture,
+	kTextureView,
+	kShaderProgram,
+	kFence,
+	kRenderGraph,
+	kAccelerationStructure,
+	kGrUpscaler,
+
+	kCount,
+	kFirst = 0
 };
 
 /// Base of all graphics objects.

AnKi/Gr/GrUpscaler.h

@@ -18,18 +18,18 @@ namespace anki {
 /// Different upscalers supported internally by GrUpscaler
 enum class GrUpscalerType : U8
 {
-	DLSS_2 = 0,
-	COUNT
+	kDlss2 = 0,
+	kCount
 };
 
 /// Quality preset to be used by the upscaler if available
 enum class GrUpscalerQualityMode : U8
 {
-	PERFORMANCE,
-	BALANCED,
-	QUALITY,
+	kPerformance,
+	kBalanced,
+	kQuality,
 
-	COUNT
+	kCount
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(GrUpscalerQualityMode)
 
@@ -39,8 +39,8 @@ class GrUpscalerInitInfo : public GrBaseInitInfo
 public:
 	UVec2 m_sourceTextureResolution = UVec2(0u);
 	UVec2 m_targetTextureResolution = UVec2(0u);
-	GrUpscalerType m_upscalerType = GrUpscalerType::COUNT;
-	GrUpscalerQualityMode m_qualityMode = GrUpscalerQualityMode::PERFORMANCE;
+	GrUpscalerType m_upscalerType = GrUpscalerType::kCount;
+	GrUpscalerQualityMode m_qualityMode = GrUpscalerQualityMode::kPerformance;
 };
 
 class GrUpscaler : public GrObject
@@ -48,20 +48,20 @@ class GrUpscaler : public GrObject
 	ANKI_GR_OBJECT
 
 public:
-	static constexpr GrObjectType CLASS_TYPE = GrObjectType::GR_UPSCALER;
+	static constexpr GrObjectType kClassType = GrObjectType::kGrUpscaler;
 
 	GrUpscalerType getUpscalerType() const
 	{
-		ANKI_ASSERT(m_upscalerType != GrUpscalerType::COUNT);
+		ANKI_ASSERT(m_upscalerType != GrUpscalerType::kCount);
 		return m_upscalerType;
 	}
 
 protected:
-	GrUpscalerType m_upscalerType = GrUpscalerType::COUNT;
+	GrUpscalerType m_upscalerType = GrUpscalerType::kCount;
 
 	/// Construct.
 	GrUpscaler(GrManager* manager, CString name)
-		: GrObject(manager, CLASS_TYPE, name)
+		: GrObject(manager, kClassType, name)
 	{
 	}
 

AnKi/Gr/OcclusionQuery.h

@@ -18,7 +18,7 @@ class OcclusionQuery : public GrObject
 	ANKI_GR_OBJECT
 
 public:
-	static constexpr GrObjectType CLASS_TYPE = GrObjectType::OCCLUSION_QUERY;
+	static constexpr GrObjectType kClassType = GrObjectType::kOcclusionQuery;
 
 	/// Get the occlusion query result. It won't block.
 	OcclusionQueryResult getResult() const;
@@ -26,7 +26,7 @@ public:
 protected:
 	/// Construct.
 	OcclusionQuery(GrManager* manager, CString name)
-		: GrObject(manager, CLASS_TYPE, name)
+		: GrObject(manager, kClassType, name)
 	{
 	}
 

AnKi/Gr/RenderGraph.cpp

@@ -116,10 +116,10 @@ public:
 	/// Will reuse the m_secondLevelCmdbInitInfo.m_framebuffer to get the framebuffer.
 	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
+	Array<TextureUsageBit, kMaxColorRenderTargets> m_colorUsages = {}; ///< For beginRender pass
+	TextureUsageBit m_dsUsage = TextureUsageBit::kNone; ///< For beginRender pass
 
-	U32 m_batchIdx ANKI_DEBUG_CODE(= MAX_U32);
+	U32 m_batchIdx ANKI_DEBUG_CODE(= kMaxU32);
 	Bool m_drawsToPresentable = false;
 
 	FramebufferPtr& fb()
@@ -151,7 +151,7 @@ class RenderGraph::BakeContext
 public:
 	StackAllocator<U8> m_alloc;
 	DynamicArray<Pass> m_passes;
-	BitSet<MAX_RENDER_GRAPH_PASSES, U64> m_passIsInBatch{false};
+	BitSet<kMaxRenderGraphPasses, U64> m_passIsInBatch{false};
 	DynamicArray<Batch> m_batches;
 	DynamicArray<RT> m_rts;
 	DynamicArray<Buffer> m_buffers;
@@ -186,7 +186,7 @@ void FramebufferDescription::bake()
 		ANKI_END_PACKED_STRUCT
 		static_assert(sizeof(ColorAttachment) == 4 * (4 + 1 + 1 + 4), "Wrong size");
 
-		Array<ColorAttachment, MAX_COLOR_ATTACHMENTS> colorAttachments;
+		Array<ColorAttachment, kMaxColorRenderTargets> colorAttachments;
 		for(U i = 0; i < m_colorAttachmentCount; ++i)
 		{
 			const FramebufferDescriptionAttachment& inAtt = m_colorAttachments[i];
@@ -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;
@@ -258,7 +258,7 @@ void FramebufferDescription::bake()
 }
 
 RenderGraph::RenderGraph(GrManager* manager, CString name)
-	: GrObject(manager, CLASS_TYPE, name)
+	: GrObject(manager, kClassType, name)
 {
 	ANKI_ASSERT(manager);
 }
@@ -299,7 +299,7 @@ void RenderGraph::reset()
 		return;
 	}
 
-	if((m_version % PERIODIC_CLEANUP_EVERY) == 0)
+	if((m_version % kPeriodicCleanupEvery) == 0)
 	{
 		// Do cleanup
 		periodicCleanup();
@@ -425,13 +425,13 @@ FramebufferPtr RenderGraph::getOrCreateFramebuffer(const FramebufferDescription&
 	drawsToPresentable = false;
 
 	// Create a hash that includes the render targets
-	Array<U64, MAX_COLOR_ATTACHMENTS + 2> uuids;
+	Array<U64, kMaxColorRenderTargets + 2> uuids;
 	U count = 0;
 	for(U i = 0; i < fbDescr.m_colorAttachmentCount; ++i)
 	{
 		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;
 		}
@@ -439,12 +439,12 @@ FramebufferPtr RenderGraph::getOrCreateFramebuffer(const FramebufferDescription&
 
 	if(!!fbDescr.m_depthStencilAttachment.m_aspect)
 	{
-		uuids[count++] = m_ctx->m_rts[rtHandles[MAX_COLOR_ATTACHMENTS].m_idx].m_texture->getUuid();
+		uuids[count++] = m_ctx->m_rts[rtHandles[kMaxColorRenderTargets].m_idx].m_texture->getUuid();
 	}
 
 	if(fbDescr.m_shadingRateAttachmentTexelWidth > 0)
 	{
-		uuids[count++] = m_ctx->m_rts[rtHandles[MAX_COLOR_ATTACHMENTS + 1].m_idx].m_texture->getUuid();
+		uuids[count++] = m_ctx->m_rts[rtHandles[kMaxColorRenderTargets + 1].m_idx].m_texture->getUuid();
 	}
 
 	hash = appendHash(&uuids[0], sizeof(U64) * count, hash);
@@ -493,7 +493,7 @@ FramebufferPtr RenderGraph::getOrCreateFramebuffer(const FramebufferDescription&
 			outAtt.m_stencilStoreOperation = inAtt.m_stencilStoreOperation;
 
 			// Create texture view
-			TextureViewInitInfo viewInit(m_ctx->m_rts[rtHandles[MAX_COLOR_ATTACHMENTS].m_idx].m_texture,
+			TextureViewInitInfo viewInit(m_ctx->m_rts[rtHandles[kMaxColorRenderTargets].m_idx].m_texture,
 										 TextureSubresourceInfo(inAtt.m_surface, inAtt.m_aspect), "RenderGraph");
 			TextureViewPtr view = getManager().newTextureView(viewInit);
 
@@ -502,7 +502,7 @@ FramebufferPtr RenderGraph::getOrCreateFramebuffer(const FramebufferDescription&
 
 		if(fbDescr.m_shadingRateAttachmentTexelWidth > 0)
 		{
-			TextureViewInitInfo viewInit(m_ctx->m_rts[rtHandles[MAX_COLOR_ATTACHMENTS + 1].m_idx].m_texture,
+			TextureViewInitInfo viewInit(m_ctx->m_rts[rtHandles[kMaxColorRenderTargets + 1].m_idx].m_texture,
 										 fbDescr.m_shadingRateAttachmentSurface, "RenderGraph SRI");
 			TextureViewPtr view = getManager().newTextureView(viewInit);
 
@@ -540,11 +540,11 @@ Bool RenderGraph::passADependsOnB(const RenderPassDescriptionBase& a, const Rend
 	// Render targets
 	{
 		// Compute the 3 types of dependencies
-		const BitSet<MAX_RENDER_GRAPH_RENDER_TARGETS, U64> aReadBWrite = a.m_readRtMask & b.m_writeRtMask;
-		const BitSet<MAX_RENDER_GRAPH_RENDER_TARGETS, U64> aWriteBRead = a.m_writeRtMask & b.m_readRtMask;
-		const BitSet<MAX_RENDER_GRAPH_RENDER_TARGETS, U64> aWriteBWrite = a.m_writeRtMask & b.m_writeRtMask;
+		const BitSet<kMaxRenderGraphRenderTargets, U64> aReadBWrite = a.m_readRtMask & b.m_writeRtMask;
+		const BitSet<kMaxRenderGraphRenderTargets, U64> aWriteBRead = a.m_writeRtMask & b.m_readRtMask;
+		const BitSet<kMaxRenderGraphRenderTargets, U64> aWriteBWrite = a.m_writeRtMask & b.m_writeRtMask;
 
-		const BitSet<MAX_RENDER_GRAPH_RENDER_TARGETS, U64> fullDep = aReadBWrite | aWriteBRead | aWriteBWrite;
+		const BitSet<kMaxRenderGraphRenderTargets, U64> fullDep = aReadBWrite | aWriteBRead | aWriteBWrite;
 
 		if(fullDep.getAny())
 		{
@@ -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;
@@ -582,11 +582,11 @@ Bool RenderGraph::passADependsOnB(const RenderPassDescriptionBase& a, const Rend
 	// Buffers
 	if(a.m_readBuffMask || a.m_writeBuffMask)
 	{
-		const BitSet<MAX_RENDER_GRAPH_BUFFERS, U64> aReadBWrite = a.m_readBuffMask & b.m_writeBuffMask;
-		const BitSet<MAX_RENDER_GRAPH_BUFFERS, U64> aWriteBRead = a.m_writeBuffMask & b.m_readBuffMask;
-		const BitSet<MAX_RENDER_GRAPH_BUFFERS, U64> aWriteBWrite = a.m_writeBuffMask & b.m_writeBuffMask;
+		const BitSet<kMaxRenderGraphBuffers, U64> aReadBWrite = a.m_readBuffMask & b.m_writeBuffMask;
+		const BitSet<kMaxRenderGraphBuffers, U64> aWriteBRead = a.m_writeBuffMask & b.m_readBuffMask;
+		const BitSet<kMaxRenderGraphBuffers, U64> aWriteBWrite = a.m_writeBuffMask & b.m_writeBuffMask;
 
-		const BitSet<MAX_RENDER_GRAPH_BUFFERS, U64> fullDep = aReadBWrite | aWriteBRead | aWriteBWrite;
+		const BitSet<kMaxRenderGraphBuffers, U64> fullDep = aReadBWrite | aWriteBRead | aWriteBWrite;
 
 		if(fullDep.getAny())
 		{
@@ -606,7 +606,7 @@ Bool RenderGraph::passADependsOnB(const RenderPassDescriptionBase& a, const Rend
 						continue;
 					}
 
-					if(!((aDep.m_buffer.m_usage | bDep.m_buffer.m_usage) & BufferUsageBit::ALL_WRITE))
+					if(!((aDep.m_buffer.m_usage | bDep.m_buffer.m_usage) & BufferUsageBit::kAllWrite))
 					{
 						// Don't care about read to read deps
 						continue;
@@ -622,11 +622,11 @@ Bool RenderGraph::passADependsOnB(const RenderPassDescriptionBase& a, const Rend
 	// AS
 	if(a.m_readAsMask || a.m_writeAsMask)
 	{
-		const BitSet<MAX_RENDER_GRAPH_ACCELERATION_STRUCTURES, U32> aReadBWrite = a.m_readAsMask & b.m_writeAsMask;
-		const BitSet<MAX_RENDER_GRAPH_ACCELERATION_STRUCTURES, U32> aWriteBRead = a.m_writeAsMask & b.m_readAsMask;
-		const BitSet<MAX_RENDER_GRAPH_ACCELERATION_STRUCTURES, U32> aWriteBWrite = a.m_writeAsMask & b.m_writeAsMask;
+		const BitSet<kMaxRenderGraphAccelerationStructures, U32> aReadBWrite = a.m_readAsMask & b.m_writeAsMask;
+		const BitSet<kMaxRenderGraphAccelerationStructures, U32> aWriteBRead = a.m_writeAsMask & b.m_readAsMask;
+		const BitSet<kMaxRenderGraphAccelerationStructures, U32> aWriteBWrite = a.m_writeAsMask & b.m_writeAsMask;
 
-		const BitSet<MAX_RENDER_GRAPH_ACCELERATION_STRUCTURES, U32> fullDep = aReadBWrite | aWriteBRead | aWriteBWrite;
+		const BitSet<kMaxRenderGraphAccelerationStructures, U32> fullDep = aReadBWrite | aWriteBRead | aWriteBWrite;
 
 		if(fullDep)
 		{
@@ -644,7 +644,7 @@ Bool RenderGraph::passADependsOnB(const RenderPassDescriptionBase& a, const Rend
 						continue;
 					}
 
-					if(!((aDep.m_as.m_usage | bDep.m_as.m_usage) & AccelerationStructureUsageBit::ALL_WRITE))
+					if(!((aDep.m_as.m_usage | bDep.m_as.m_usage) & AccelerationStructureUsageBit::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
@@ -750,7 +750,7 @@ RenderGraph::BakeContext* RenderGraph::newContext(const RenderGraphDescription&
 			}
 		}
 
-		outRt.m_lastBatchThatTransitionedIt.create(alloc, surfOrVolumeCount, MAX_U16);
+		outRt.m_lastBatchThatTransitionedIt.create(alloc, surfOrVolumeCount, kMaxU16);
 		outRt.m_imported = imported;
 	}
 
@@ -798,7 +798,7 @@ void RenderGraph::initRenderPassesAndSetDeps(const RenderGraphDescription& descr
 		for(U32 depIdx = 0; depIdx < inPass.m_rtDeps.getSize(); ++depIdx)
 		{
 			const RenderPassDependency& inDep = inPass.m_rtDeps[depIdx];
-			ANKI_ASSERT(inDep.m_type == RenderPassDependency::Type::TEXTURE);
+			ANKI_ASSERT(inDep.m_type == RenderPassDependency::Type::kTexture);
 
 			RenderPassDependency::TextureInfo& inf = outPass.m_consumedTextures[depIdx];
 
@@ -807,7 +807,7 @@ void RenderGraph::initRenderPassesAndSetDeps(const RenderGraphDescription& descr
 		}
 
 		// Create command buffers and framebuffer
-		if(inPass.m_type == RenderPassDescriptionBase::Type::GRAPHICS)
+		if(inPass.m_type == RenderPassDescriptionBase::Type::kGraphics)
 		{
 			const GraphicsRenderPassDescription& graphicsPass =
 				static_cast<const GraphicsRenderPassDescription&>(inPass);
@@ -878,7 +878,7 @@ void RenderGraph::initBatches()
 		if(m_ctx->m_graphicsCmdbs.isEmpty() || drawsToPresentable)
 		{
 			CommandBufferInitInfo cmdbInit;
-			cmdbInit.m_flags = CommandBufferFlag::GENERAL_WORK;
+			cmdbInit.m_flags = CommandBufferFlag::kGeneralWork;
 			CommandBufferPtr cmdb = getManager().newCommandBuffer(cmdbInit);
 
 			m_ctx->m_graphicsCmdbs.emplaceBack(m_ctx->m_alloc, cmdb);
@@ -893,7 +893,7 @@ void RenderGraph::initBatches()
 				cmdb->resetTimestampQuery(query);
 				cmdb->writeTimestamp(query);
 
-				m_statistics.m_nextTimestamp = (m_statistics.m_nextTimestamp + 1) % MAX_TIMESTAMPS_BUFFERED;
+				m_statistics.m_nextTimestamp = (m_statistics.m_nextTimestamp + 1) % kMaxBufferedTimestamps;
 				m_statistics.m_timestamps[m_statistics.m_nextTimestamp * 2] = query;
 			}
 		}
@@ -923,7 +923,7 @@ void RenderGraph::initGraphicsPasses(const RenderGraphDescription& descr, StackA
 		Pass& outPass = ctx.m_passes[passIdx];
 
 		// Create command buffers and framebuffer
-		if(inPass.m_type == RenderPassDescriptionBase::Type::GRAPHICS)
+		if(inPass.m_type == RenderPassDescriptionBase::Type::kGraphics)
 		{
 			const GraphicsRenderPassDescription& graphicsPass =
 				static_cast<const GraphicsRenderPassDescription&>(inPass);
@@ -946,7 +946,7 @@ void RenderGraph::initGraphicsPasses(const RenderGraphDescription& descr, StackA
 						TextureSubresourceInfo(graphicsPass.m_fbDescr.m_depthStencilAttachment.m_surface,
 											   graphicsPass.m_fbDescr.m_depthStencilAttachment.m_aspect);
 
-					getCrntUsage(graphicsPass.m_rtHandles[MAX_COLOR_ATTACHMENTS], outPass.m_batchIdx, subresource,
+					getCrntUsage(graphicsPass.m_rtHandles[kMaxColorRenderTargets], outPass.m_batchIdx, subresource,
 								 usage);
 
 					outPass.m_dsUsage = usage;
@@ -957,7 +957,7 @@ void RenderGraph::initGraphicsPasses(const RenderGraphDescription& descr, StackA
 				{
 					outPass.m_secondLevelCmdbs.create(alloc, inPass.m_secondLevelCmdbsCount);
 					CommandBufferInitInfo& cmdbInit = outPass.m_secondLevelCmdbInitInfo;
-					cmdbInit.m_flags = CommandBufferFlag::GENERAL_WORK | CommandBufferFlag::SECOND_LEVEL;
+					cmdbInit.m_flags = CommandBufferFlag::kGeneralWork | CommandBufferFlag::kSecondLevel;
 					ANKI_ASSERT(cmdbInit.m_framebuffer.isCreated());
 					cmdbInit.m_colorAttachmentUsages = outPass.m_colorUsages;
 					cmdbInit.m_depthStencilAttachmentUsage = outPass.m_dsUsage;
@@ -1001,7 +1001,7 @@ void RenderGraph::iterateSurfsOrVolumes(const TexturePtr& tex, const TextureSubr
 
 void RenderGraph::setTextureBarrier(Batch& batch, const RenderPassDependency& dep)
 {
-	ANKI_ASSERT(dep.m_type == RenderPassDependency::Type::TEXTURE);
+	ANKI_ASSERT(dep.m_type == RenderPassDependency::Type::kTexture);
 
 	BakeContext& ctx = *m_ctx;
 	const U32 batchIdx = U32(&batch - &ctx.m_batches[0]);
@@ -1057,8 +1057,8 @@ void RenderGraph::setBatchBarriers(const RenderGraphDescription& descr)
 	// For all batches
 	for(Batch& batch : ctx.m_batches)
 	{
-		BitSet<MAX_RENDER_GRAPH_BUFFERS, U64> buffHasBarrierMask(false);
-		BitSet<MAX_RENDER_GRAPH_ACCELERATION_STRUCTURES, U32> asHasBarrierMask(false);
+		BitSet<kMaxRenderGraphBuffers, U64> buffHasBarrierMask(false);
+		BitSet<kMaxRenderGraphAccelerationStructures, U32> asHasBarrierMask(false);
 
 		// For all passes of that batch
 		for(U32 passIdx : batch.m_passIndices)
@@ -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)
@@ -1433,16 +1433,16 @@ void RenderGraph::periodicCleanup()
 
 void RenderGraph::getStatistics(RenderGraphStatistics& statistics) const
 {
-	const U32 oldFrame = (m_statistics.m_nextTimestamp + 1) % MAX_TIMESTAMPS_BUFFERED;
+	const U32 oldFrame = (m_statistics.m_nextTimestamp + 1) % kMaxBufferedTimestamps;
 
 	if(m_statistics.m_timestamps[oldFrame * 2] && m_statistics.m_timestamps[oldFrame * 2 + 1])
 	{
 		Second start, end;
 		[[maybe_unused]] TimestampQueryResult res = m_statistics.m_timestamps[oldFrame * 2]->getResult(start);
-		ANKI_ASSERT(res == TimestampQueryResult::AVAILABLE);
+		ANKI_ASSERT(res == TimestampQueryResult::kAvailable);
 
 		res = m_statistics.m_timestamps[oldFrame * 2 + 1]->getResult(end);
-		ANKI_ASSERT(res == TimestampQueryResult::AVAILABLE);
+		ANKI_ASSERT(res == TimestampQueryResult::kAvailable);
 
 		const Second diff = end - start;
 		statistics.m_gpuTime = diff;
@@ -1513,26 +1513,26 @@ StringAuto RenderGraph::bufferUsageToStr(StackAllocator<U8>& alloc, BufferUsageB
 			slist.pushBackSprintf("%s", #u); \
 		}
 
-	ANKI_BUFF_USAGE(UNIFORM_GEOMETRY);
-	ANKI_BUFF_USAGE(UNIFORM_FRAGMENT);
-	ANKI_BUFF_USAGE(UNIFORM_COMPUTE);
-	ANKI_BUFF_USAGE(UNIFORM_TRACE_RAYS);
-	ANKI_BUFF_USAGE(STORAGE_GEOMETRY_READ);
-	ANKI_BUFF_USAGE(STORAGE_GEOMETRY_WRITE);
-	ANKI_BUFF_USAGE(STORAGE_FRAGMENT_READ);
-	ANKI_BUFF_USAGE(STORAGE_FRAGMENT_WRITE);
-	ANKI_BUFF_USAGE(STORAGE_COMPUTE_READ);
-	ANKI_BUFF_USAGE(STORAGE_COMPUTE_WRITE);
-	ANKI_BUFF_USAGE(STORAGE_TRACE_RAYS_READ);
-	ANKI_BUFF_USAGE(STORAGE_TRACE_RAYS_WRITE);
-	ANKI_BUFF_USAGE(TEXTURE_GEOMETRY_READ);
-	ANKI_BUFF_USAGE(TEXTURE_GEOMETRY_WRITE);
-	ANKI_BUFF_USAGE(TEXTURE_FRAGMENT_READ);
-	ANKI_BUFF_USAGE(TEXTURE_FRAGMENT_WRITE);
-	ANKI_BUFF_USAGE(TEXTURE_COMPUTE_READ);
-	ANKI_BUFF_USAGE(TEXTURE_COMPUTE_WRITE);
-	ANKI_BUFF_USAGE(TEXTURE_TRACE_RAYS_READ);
-	ANKI_BUFF_USAGE(TEXTURE_TRACE_RAYS_WRITE);
+	ANKI_BUFF_USAGE(kUniformGeometry);
+	ANKI_BUFF_USAGE(kUniformFragment);
+	ANKI_BUFF_USAGE(kUniformCompute);
+	ANKI_BUFF_USAGE(kUniformTraceRays);
+	ANKI_BUFF_USAGE(kStorageGeometryRead);
+	ANKI_BUFF_USAGE(kStorageGeometryWrite);
+	ANKI_BUFF_USAGE(kStorageFragmentRead);
+	ANKI_BUFF_USAGE(kStorageFragmentWrite);
+	ANKI_BUFF_USAGE(kStorageComputeRead);
+	ANKI_BUFF_USAGE(kStorageComputeWrite);
+	ANKI_BUFF_USAGE(kStorageTraceRaysRead);
+	ANKI_BUFF_USAGE(kStorageTraceRaysWrite);
+	ANKI_BUFF_USAGE(kTextureGeometryRead);
+	ANKI_BUFF_USAGE(kTextureGeometryWrite);
+	ANKI_BUFF_USAGE(kTextureFragmentRead);
+	ANKI_BUFF_USAGE(kTextureFragmentWrite);
+	ANKI_BUFF_USAGE(kTextureComputeRead);
+	ANKI_BUFF_USAGE(kTextureComputeWrite);
+	ANKI_BUFF_USAGE(kTextureTraceRaysRead);
+	ANKI_BUFF_USAGE(kTextureTraceRaysWrite);
 	ANKI_BUFF_USAGE(INDEX);
 	ANKI_BUFF_USAGE(VERTEX);
 	ANKI_BUFF_USAGE(INDIRECT_COMPUTE);
@@ -1733,7 +1733,7 @@ Error RenderGraph::dumpDependencyDotFile(const RenderGraphDescription& descr, co
 		ANKI_CHECK(file.writeText("%s", &s[0]));
 	}
 
-	return Error::NONE;
+	return Error::kNone;
 }
 #endif
 

AnKi/Gr/RenderGraph.h

@@ -29,10 +29,10 @@ class RenderGraphDescription;
 
 /// @name RenderGraph constants
 /// @{
-constexpr U32 MAX_RENDER_GRAPH_PASSES = 128;
-constexpr U32 MAX_RENDER_GRAPH_RENDER_TARGETS = 64; ///< Max imported or not render targets in RenderGraph.
-constexpr U32 MAX_RENDER_GRAPH_BUFFERS = 64;
-constexpr U32 MAX_RENDER_GRAPH_ACCELERATION_STRUCTURES = 32;
+constexpr U32 kMaxRenderGraphPasses = 128;
+constexpr U32 kMaxRenderGraphRenderTargets = 64; ///< Max imported or not render targets in RenderGraph.
+constexpr U32 kMaxRenderGraphBuffers = 64;
+constexpr U32 kMaxRenderGraphAccelerationStructures = 32;
 /// @}
 
 /// Render target handle used in the RenderGraph.
@@ -57,11 +57,11 @@ public:
 
 	Bool isValid() const
 	{
-		return m_idx != MAX_U32;
+		return m_idx != kMaxU32;
 	}
 
 private:
-	U32 m_idx = MAX_U32;
+	U32 m_idx = kMaxU32;
 };
 
 /// Render target (TexturePtr) handle.
@@ -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);
@@ -208,7 +208,7 @@ public:
 	{
 		BufferPtr buff;
 		getBufferState(handle, buff);
-		m_commandBuffer->bindStorageBuffer(set, binding, buff, 0, MAX_PTR_SIZE);
+		m_commandBuffer->bindStorageBuffer(set, binding, buff, 0, kMaxPtrSize);
 	}
 
 	/// Convenience method.
@@ -216,7 +216,7 @@ public:
 	{
 		BufferPtr buff;
 		getBufferState(handle, buff);
-		m_commandBuffer->bindUniformBuffer(set, binding, buff, 0, MAX_PTR_SIZE);
+		m_commandBuffer->bindUniformBuffer(set, binding, buff, 0, kMaxPtrSize);
 	}
 
 	/// Convenience method.
@@ -224,8 +224,8 @@ public:
 
 private:
 	const RenderGraph* m_rgraph ANKI_DEBUG_CODE(= nullptr);
-	U32 m_passIdx ANKI_DEBUG_CODE(= MAX_U32);
-	U32 m_batchIdx ANKI_DEBUG_CODE(= MAX_U32);
+	U32 m_passIdx ANKI_DEBUG_CODE(= kMaxU32);
+	U32 m_batchIdx ANKI_DEBUG_CODE(= kMaxU32);
 
 	TexturePtr getTexture(RenderTargetHandle handle) const;
 };
@@ -241,32 +241,32 @@ public:
 	/// Dependency to a texture subresource.
 	RenderPassDependency(RenderTargetHandle handle, TextureUsageBit usage, const TextureSubresourceInfo& subresource)
 		: m_texture({handle, usage, subresource})
-		, m_type(Type::TEXTURE)
+		, m_type(Type::kTexture)
 	{
 		ANKI_ASSERT(handle.isValid());
 	}
 
 	/// 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)
+		, m_type(Type::kTexture)
 	{
 		ANKI_ASSERT(handle.isValid());
-		m_texture.m_subresource.m_mipmapCount = MAX_U32; // Mark it as "whole texture"
+		m_texture.m_subresource.m_mipmapCount = kMaxU32; // Mark it as "whole texture"
 		m_texture.m_subresource.m_depthStencilAspect = aspect;
 	}
 
 	RenderPassDependency(BufferHandle handle, BufferUsageBit usage)
 		: m_buffer({handle, usage})
-		, m_type(Type::BUFFER)
+		, m_type(Type::kBuffer)
 	{
 		ANKI_ASSERT(handle.isValid());
 	}
 
 	RenderPassDependency(AccelerationStructureHandle handle, AccelerationStructureUsageBit usage)
 		: m_as({handle, usage})
-		, m_type(Type::ACCELERATION_STRUCTURE)
+		, m_type(Type::kAccelerationStructure)
 	{
 		ANKI_ASSERT(handle.isValid());
 	}
@@ -303,9 +303,9 @@ private:
 
 	enum class Type : U8
 	{
-		BUFFER,
-		TEXTURE,
-		ACCELERATION_STRUCTURE
+		kBuffer,
+		kTexture,
+		kAccelerationStructure
 	};
 
 	Type m_type;
@@ -331,7 +331,7 @@ public:
 	template<typename TFunc>
 	void setWork(U32 secondLeveCmdbCount, TFunc func)
 	{
-		ANKI_ASSERT(m_type == Type::GRAPHICS || secondLeveCmdbCount == 0);
+		ANKI_ASSERT(m_type == Type::kGraphics || secondLeveCmdbCount == 0);
 		m_callback.init(m_alloc, func);
 		m_secondLevelCmdbsCount = secondLeveCmdbCount;
 	}
@@ -348,8 +348,8 @@ public:
 protected:
 	enum class Type : U8
 	{
-		GRAPHICS,
-		NO_GRAPHICS
+		kGraphics,
+		kNoGraphics
 	};
 
 	Type m_type;
@@ -364,12 +364,12 @@ protected:
 	DynamicArray<RenderPassDependency> m_buffDeps;
 	DynamicArray<RenderPassDependency> m_asDeps;
 
-	BitSet<MAX_RENDER_GRAPH_RENDER_TARGETS, U64> m_readRtMask{false};
-	BitSet<MAX_RENDER_GRAPH_RENDER_TARGETS, U64> m_writeRtMask{false};
-	BitSet<MAX_RENDER_GRAPH_BUFFERS, U64> m_readBuffMask{false};
-	BitSet<MAX_RENDER_GRAPH_BUFFERS, U64> m_writeBuffMask{false};
-	BitSet<MAX_RENDER_GRAPH_ACCELERATION_STRUCTURES, U32> m_readAsMask{false};
-	BitSet<MAX_RENDER_GRAPH_ACCELERATION_STRUCTURES, U32> m_writeAsMask{false};
+	BitSet<kMaxRenderGraphRenderTargets, U64> m_readRtMask{false};
+	BitSet<kMaxRenderGraphRenderTargets, U64> m_writeRtMask{false};
+	BitSet<kMaxRenderGraphBuffers, U64> m_readBuffMask{false};
+	BitSet<kMaxRenderGraphBuffers, U64> m_writeBuffMask{false};
+	BitSet<kMaxRenderGraphAccelerationStructures, U32> m_readAsMask{false};
+	BitSet<kMaxRenderGraphAccelerationStructures, U32> m_writeAsMask{false};
 
 	String m_name;
 
@@ -395,14 +395,14 @@ class FramebufferDescriptionAttachment
 {
 public:
 	TextureSurfaceInfo m_surface;
-	AttachmentLoadOperation m_loadOperation = AttachmentLoadOperation::DONT_CARE;
-	AttachmentStoreOperation m_storeOperation = AttachmentStoreOperation::STORE;
+	AttachmentLoadOperation m_loadOperation = AttachmentLoadOperation::kDontCare;
+	AttachmentStoreOperation m_storeOperation = AttachmentStoreOperation::kStore;
 	ClearValue m_clearValue;
 
-	AttachmentLoadOperation m_stencilLoadOperation = AttachmentLoadOperation::DONT_CARE;
-	AttachmentStoreOperation m_stencilStoreOperation = AttachmentStoreOperation::STORE;
+	AttachmentLoadOperation m_stencilLoadOperation = AttachmentLoadOperation::kDontCare;
+	AttachmentStoreOperation m_stencilStoreOperation = AttachmentStoreOperation::kStore;
 
-	DepthStencilAspectBit m_aspect = DepthStencilAspectBit::NONE; ///< Relevant only for depth stencil textures.
+	DepthStencilAspectBit m_aspect = DepthStencilAspectBit::kNone; ///< Relevant only for depth stencil textures.
 };
 
 /// Describes a framebuffer.
@@ -413,7 +413,7 @@ class FramebufferDescription
 	friend class RenderGraph;
 
 public:
-	Array<FramebufferDescriptionAttachment, MAX_COLOR_ATTACHMENTS> m_colorAttachments;
+	Array<FramebufferDescriptionAttachment, kMaxColorRenderTargets> m_colorAttachments;
 	U32 m_colorAttachmentCount = 0;
 	FramebufferDescriptionAttachment m_depthStencilAttachment;
 	U32 m_shadingRateAttachmentTexelWidth = 0;
@@ -446,21 +446,21 @@ public:
 							ConstWeakArray<RenderTargetHandle> colorRenderTargetHandles,
 							RenderTargetHandle depthStencilRenderTargetHandle = {},
 							RenderTargetHandle shadingRateRenderTargetHandle = {}, U32 minx = 0, U32 miny = 0,
-							U32 maxx = MAX_U32, U32 maxy = MAX_U32);
+							U32 maxx = kMaxU32, U32 maxy = kMaxU32);
 
 	void setFramebufferInfo(const FramebufferDescription& fbInfo,
 							std::initializer_list<RenderTargetHandle> colorRenderTargetHandles,
 							RenderTargetHandle depthStencilRenderTargetHandle = {},
 							RenderTargetHandle shadingRateRenderTargetHandle = {}, U32 minx = 0, U32 miny = 0,
-							U32 maxx = MAX_U32, U32 maxy = MAX_U32);
+							U32 maxx = kMaxU32, U32 maxy = kMaxU32);
 
 private:
-	Array<RenderTargetHandle, MAX_COLOR_ATTACHMENTS + 2> m_rtHandles;
+	Array<RenderTargetHandle, kMaxColorRenderTargets + 2> m_rtHandles;
 	FramebufferDescription m_fbDescr;
 	Array<U32, 4> m_fbRenderArea = {};
 
 	GraphicsRenderPassDescription(RenderGraphDescription* descr)
-		: RenderPassDescriptionBase(Type::GRAPHICS, descr)
+		: RenderPassDescriptionBase(Type::kGraphics, descr)
 	{
 		memset(&m_rtHandles[0], 0xFF, sizeof(m_rtHandles));
 	}
@@ -481,7 +481,7 @@ class ComputeRenderPassDescription : public RenderPassDescriptionBase
 
 private:
 	ComputeRenderPassDescription(RenderGraphDescription* descr)
-		: RenderPassDescriptionBase(Type::NO_GRAPHICS, descr)
+		: RenderPassDescriptionBase(Type::kNoGraphics, descr)
 	{
 	}
 };
@@ -518,7 +518,7 @@ public:
 	RenderTargetHandle newRenderTarget(const RenderTargetDescription& initInf);
 
 	/// Import a buffer.
-	BufferHandle importBuffer(BufferPtr buff, BufferUsageBit usage, PtrSize offset = 0, PtrSize range = MAX_PTR_SIZE);
+	BufferHandle importBuffer(BufferPtr buff, BufferUsageBit usage, PtrSize offset = 0, PtrSize range = kMaxPtrSize);
 
 	/// Import an AS.
 	AccelerationStructureHandle importAccelerationStructure(AccelerationStructurePtr as,
@@ -534,12 +534,12 @@ private:
 	class Resource
 	{
 	public:
-		Array<char, MAX_GR_OBJECT_NAME_LENGTH + 1> m_name;
+		Array<char, kMaxGrObjectNameLength + 1> m_name;
 
 		void setName(CString name)
 		{
 			const U len = name.getLength();
-			ANKI_ASSERT(len <= MAX_GR_OBJECT_NAME_LENGTH);
+			ANKI_ASSERT(len <= kMaxGrObjectNameLength);
 			strcpy(&m_name[0], (len) ? &name[0] : "unnamed");
 		}
 	};
@@ -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;
 	};
 
@@ -583,7 +583,7 @@ private:
 	static Bool bufferRangeOverlaps(PtrSize offsetA, PtrSize rangeA, PtrSize offsetB, PtrSize rangeB)
 	{
 		ANKI_ASSERT(rangeA > 0 && rangeB > 0);
-		if(rangeA == MAX_PTR_SIZE || rangeB == MAX_PTR_SIZE)
+		if(rangeA == kMaxPtrSize || rangeB == kMaxPtrSize)
 		{
 			return true;
 		}
@@ -624,7 +624,7 @@ class RenderGraph final : public GrObject
 	friend class RenderPassWorkContext;
 
 public:
-	static constexpr GrObjectType CLASS_TYPE = GrObjectType::RENDER_GRAPH;
+	static constexpr GrObjectType kClassType = GrObjectType::kRenderGraph;
 
 	/// @name 1st step methods
 	/// @{
@@ -665,7 +665,7 @@ public:
 	/// @}
 
 private:
-	static constexpr U PERIODIC_CLEANUP_EVERY = 60; ///< How many frames between cleanups.
+	static constexpr U kPeriodicCleanupEvery = 60; ///< How many frames between cleanups.
 
 	// Forward declarations of internal classes.
 	class BakeContext;
@@ -700,12 +700,12 @@ private:
 	BakeContext* m_ctx = nullptr;
 	U64 m_version = 0;
 
-	static constexpr U MAX_TIMESTAMPS_BUFFERED = MAX_FRAMES_IN_FLIGHT + 1;
+	static constexpr U kMaxBufferedTimestamps = kMaxFramesInFlight + 1;
 	class
 	{
 	public:
-		Array<TimestampQueryPtr, MAX_TIMESTAMPS_BUFFERED * 2> m_timestamps;
-		Array<Second, MAX_TIMESTAMPS_BUFFERED> m_cpuStartTimes;
+		Array<TimestampQueryPtr, kMaxBufferedTimestamps * 2> m_timestamps;
+		Array<Second, kMaxBufferedTimestamps> m_cpuStartTimes;
 		U8 m_nextTimestamp = 0;
 	} m_statistics;
 

AnKi/Gr/RenderGraph.inl.h

@@ -33,10 +33,10 @@ inline TexturePtr RenderPassWorkContext::getTexture(RenderTargetHandle handle) c
 
 inline void RenderPassDescriptionBase::fixSubresource(RenderPassDependency& dep) const
 {
-	ANKI_ASSERT(dep.m_type == RenderPassDependency::Type::TEXTURE);
+	ANKI_ASSERT(dep.m_type == RenderPassDependency::Type::kTexture);
 
 	TextureSubresourceInfo& subresource = dep.m_texture.m_subresource;
-	const Bool wholeTexture = subresource.m_mipmapCount == MAX_U32;
+	const Bool wholeTexture = subresource.m_mipmapCount == kMaxU32;
 	const RenderGraphDescription::RT& rt = m_descr->m_renderTargets[dep.m_texture.m_handle.m_idx];
 	if(wholeTexture)
 	{
@@ -65,44 +65,44 @@ inline void RenderPassDescriptionBase::fixSubresource(RenderPassDependency& dep)
 inline void RenderPassDescriptionBase::validateDep(const RenderPassDependency& dep)
 {
 	// Validate dep
-	if(dep.m_type == RenderPassDependency::Type::TEXTURE)
+	if(dep.m_type == RenderPassDependency::Type::kTexture)
 	{
 		[[maybe_unused]] const TextureUsageBit usage = dep.m_texture.m_usage;
-		if(m_type == Type::GRAPHICS)
+		if(m_type == Type::kGraphics)
 		{
-			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)
+	else if(dep.m_type == RenderPassDependency::Type::kBuffer)
 	{
 		[[maybe_unused]] const BufferUsageBit usage = dep.m_buffer.m_usage;
-		if(m_type == Type::GRAPHICS)
+		if(m_type == Type::kGraphics)
 		{
-			ANKI_ASSERT(!(usage & BufferUsageBit::ALL_COMPUTE));
+			ANKI_ASSERT(!(usage & BufferUsageBit::kAllCompute));
 		}
 		else
 		{
-			ANKI_ASSERT(!(usage & BufferUsageBit::ALL_GRAPHICS));
+			ANKI_ASSERT(!(usage & BufferUsageBit::kAllGraphics));
 		}
 
-		ANKI_ASSERT(!!(usage & BufferUsageBit::ALL_READ) || !!(usage & BufferUsageBit::ALL_WRITE));
+		ANKI_ASSERT(!!(usage & BufferUsageBit::kAllRead) || !!(usage & BufferUsageBit::kAllWrite));
 	}
 	else
 	{
-		ANKI_ASSERT(dep.m_type == RenderPassDependency::Type::ACCELERATION_STRUCTURE);
-		if(m_type == Type::GRAPHICS)
+		ANKI_ASSERT(dep.m_type == RenderPassDependency::Type::kAccelerationStructure);
+		if(m_type == Type::kGraphics)
 		{
-			ANKI_ASSERT(!(dep.m_as.m_usage & ~AccelerationStructureUsageBit::ALL_GRAPHICS));
+			ANKI_ASSERT(!(dep.m_as.m_usage & ~AccelerationStructureUsageBit::kAllGraphics));
 		}
 		else
 		{
-			ANKI_ASSERT(!(dep.m_as.m_usage & AccelerationStructureUsageBit::ALL_GRAPHICS));
+			ANKI_ASSERT(!(dep.m_as.m_usage & AccelerationStructureUsageBit::kAllGraphics));
 		}
 	}
 }
@@ -111,17 +111,17 @@ inline void RenderPassDescriptionBase::newDependency(const RenderPassDependency&
 {
 	validateDep(dep);
 
-	if(dep.m_type == RenderPassDependency::Type::TEXTURE)
+	if(dep.m_type == RenderPassDependency::Type::kTexture)
 	{
 		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);
 		}
@@ -129,31 +129,31 @@ inline void RenderPassDescriptionBase::newDependency(const RenderPassDependency&
 		// Try to derive the usage by that dep
 		m_descr->m_renderTargets[dep.m_texture.m_handle.m_idx].m_usageDerivedByDeps |= dep.m_texture.m_usage;
 	}
-	else if(dep.m_type == RenderPassDependency::Type::BUFFER)
+	else if(dep.m_type == RenderPassDependency::Type::kBuffer)
 	{
 		m_buffDeps.emplaceBack(m_alloc, dep);
 
-		if(!!(dep.m_buffer.m_usage & BufferUsageBit::ALL_READ))
+		if(!!(dep.m_buffer.m_usage & BufferUsageBit::kAllRead))
 		{
 			m_readBuffMask.set(dep.m_buffer.m_handle.m_idx);
 		}
 
-		if(!!(dep.m_buffer.m_usage & BufferUsageBit::ALL_WRITE))
+		if(!!(dep.m_buffer.m_usage & BufferUsageBit::kAllWrite))
 		{
 			m_writeBuffMask.set(dep.m_buffer.m_handle.m_idx);
 		}
 	}
 	else
 	{
-		ANKI_ASSERT(dep.m_type == RenderPassDependency::Type::ACCELERATION_STRUCTURE);
+		ANKI_ASSERT(dep.m_type == RenderPassDependency::Type::kAccelerationStructure);
 		m_asDeps.emplaceBack(m_alloc, dep);
 
-		if(!!(dep.m_as.m_usage & AccelerationStructureUsageBit::ALL_READ))
+		if(!!(dep.m_as.m_usage & AccelerationStructureUsageBit::kAllRead))
 		{
 			m_readAsMask.set(dep.m_as.m_handle.m_idx);
 		}
 
-		if(!!(dep.m_as.m_usage & AccelerationStructureUsageBit::ALL_WRITE))
+		if(!!(dep.m_as.m_usage & AccelerationStructureUsageBit::kAllWrite))
 		{
 			m_writeAsMask.set(dep.m_as.m_handle.m_idx);
 		}
@@ -165,7 +165,7 @@ inline void GraphicsRenderPassDescription::setFramebufferInfo(
 	RenderTargetHandle depthStencilRenderTargetHandle, RenderTargetHandle shadingRateRenderTargetHandle, U32 minx,
 	U32 miny, U32 maxx, U32 maxy)
 {
-	Array<RenderTargetHandle, MAX_COLOR_ATTACHMENTS> rts;
+	Array<RenderTargetHandle, kMaxColorRenderTargets> rts;
 	U32 count = 0;
 	for(const RenderTargetHandle& h : colorRenderTargetHandles)
 	{
@@ -215,8 +215,8 @@ inline void GraphicsRenderPassDescription::setFramebufferInfo(
 
 	m_fbDescr = fbInfo;
 	memcpy(m_rtHandles.getBegin(), colorRenderTargetHandles.getBegin(), colorRenderTargetHandles.getSizeInBytes());
-	m_rtHandles[MAX_COLOR_ATTACHMENTS] = depthStencilRenderTargetHandle;
-	m_rtHandles[MAX_COLOR_ATTACHMENTS + 1] = shadingRateRenderTargetHandle;
+	m_rtHandles[kMaxColorRenderTargets] = depthStencilRenderTargetHandle;
+	m_rtHandles[kMaxColorRenderTargets + 1] = shadingRateRenderTargetHandle;
 	m_fbRenderArea = {minx, miny, maxx, maxy};
 }
 
@@ -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;
@@ -295,7 +296,7 @@ inline BufferHandle RenderGraphDescription::importBuffer(BufferPtr buff, BufferU
 														 PtrSize range)
 {
 	// Checks
-	if(range == MAX_PTR_SIZE)
+	if(range == kMaxPtrSize)
 	{
 		ANKI_ASSERT(offset < buff->getSize());
 	}

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;
@@ -51,12 +51,12 @@ class Sampler : public GrObject
 	ANKI_GR_OBJECT
 
 public:
-	static constexpr GrObjectType CLASS_TYPE = GrObjectType::SAMPLER;
+	static constexpr GrObjectType kClassType = GrObjectType::kSampler;
 
 protected:
 	/// Construct.
 	Sampler(GrManager* manager, CString name)
-		: GrObject(manager, CLASS_TYPE, name)
+		: GrObject(manager, kClassType, name)
 	{
 	}
 

AnKi/Gr/Shader.h

@@ -24,30 +24,30 @@ public:
 		U32 m_uint;
 	};
 
-	U32 m_constantId = MAX_U32;
+	U32 m_constantId = kMaxU32;
 	ShaderVariableDataType m_dataType;
 
 	ShaderSpecializationConstValue()
 		: m_int(0)
-		, m_dataType(ShaderVariableDataType::NONE)
+		, m_dataType(ShaderVariableDataType::kNone)
 	{
 	}
 
 	explicit ShaderSpecializationConstValue(F32 f)
 		: m_float(f)
-		, m_dataType(ShaderVariableDataType::F32)
+		, m_dataType(ShaderVariableDataType::kF32)
 	{
 	}
 
 	explicit ShaderSpecializationConstValue(I32 i)
 		: m_int(i)
-		, m_dataType(ShaderVariableDataType::I32)
+		, m_dataType(ShaderVariableDataType::kI32)
 	{
 	}
 
 	explicit ShaderSpecializationConstValue(U32 i)
 		: m_int(i)
-		, m_dataType(ShaderVariableDataType::U32)
+		, m_dataType(ShaderVariableDataType::kU32)
 	{
 	}
 
@@ -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.
@@ -89,20 +89,20 @@ class Shader : public GrObject
 	ANKI_GR_OBJECT
 
 public:
-	static constexpr GrObjectType CLASS_TYPE = GrObjectType::SHADER;
+	static constexpr GrObjectType kClassType = GrObjectType::kShader;
 
 	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)
-		: GrObject(manager, CLASS_TYPE, name)
+		: GrObject(manager, kClassType, 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;
@@ -58,7 +58,7 @@ class ShaderProgram : public GrObject
 	ANKI_GR_OBJECT
 
 public:
-	static constexpr GrObjectType CLASS_TYPE = GrObjectType::SHADER_PROGRAM;
+	static constexpr GrObjectType kClassType = GrObjectType::kShaderProgram;
 
 	/// Get the shader group handles that will be used in the SBTs. The size of each handle is
 	/// GpuDeviceCapabilities::m_shaderGroupHandleSize. To access a handle use:
@@ -74,7 +74,7 @@ public:
 protected:
 	/// Construct.
 	ShaderProgram(GrManager* manager, CString name)
-		: GrObject(manager, CLASS_TYPE, name)
+		: GrObject(manager, kClassType, name)
 	{
 	}
 

AnKi/Gr/ShaderVariableDataType.defs.h

@@ -5,68 +5,68 @@
 
 // ShaderVariableDataType defines
 
-// ANKI_SVDT_MACRO(capital, varType, baseType, rowCount, columnCount, isIntegralType)
+// ANKI_SVDT_MACRO(const, varType, baseType, rowCount, columnCount, isIntegralType)
 #if defined(ANKI_SVDT_MACRO)
-ANKI_SVDT_MACRO(I8, I8, I8, 1, 1, true)
-ANKI_SVDT_MACRO(U8, U8, U8, 1, 1, true)
-ANKI_SVDT_MACRO(I16, I16, I16, 1, 1, true)
-ANKI_SVDT_MACRO(U16, U16, U16, 1, 1, true)
-ANKI_SVDT_MACRO(I32, I32, I32, 1, 1, true)
-ANKI_SVDT_MACRO(U32, U32, U32, 1, 1, true)
-ANKI_SVDT_MACRO(I64, I64, I64, 1, 1, true)
-ANKI_SVDT_MACRO(U64, U64, U64, 1, 1, true)
-ANKI_SVDT_MACRO(F16, F16, F16, 1, 1, false)
-ANKI_SVDT_MACRO(F32, F32, F32, 1, 1, false)
+ANKI_SVDT_MACRO(I8, I8, 1, 1, true)
+ANKI_SVDT_MACRO(U8, U8, 1, 1, true)
+ANKI_SVDT_MACRO(I16, I16, 1, 1, true)
+ANKI_SVDT_MACRO(U16, U16, 1, 1, true)
+ANKI_SVDT_MACRO(I32, I32, 1, 1, true)
+ANKI_SVDT_MACRO(U32, U32, 1, 1, true)
+ANKI_SVDT_MACRO(I64, I64, 1, 1, true)
+ANKI_SVDT_MACRO(U64, U64, 1, 1, true)
+ANKI_SVDT_MACRO(F16, F16, 1, 1, false)
+ANKI_SVDT_MACRO(F32, F32, 1, 1, false)
 
-ANKI_SVDT_MACRO(I8VEC2, I8Vec2, I8, 2, 1, true)
-ANKI_SVDT_MACRO(U8VEC2, U8Vec2, U8, 2, 1, true)
-ANKI_SVDT_MACRO(I16VEC2, I16Vec2, I16, 2, 1, true)
-ANKI_SVDT_MACRO(U16VEC2, U16Vec2, U16, 2, 1, true)
-ANKI_SVDT_MACRO(IVEC2, IVec2, I32, 2, 1, true)
-ANKI_SVDT_MACRO(UVEC2, UVec2, U32, 2, 1, true)
-ANKI_SVDT_MACRO(HVEC2, HVec2, F16, 2, 1, false)
-ANKI_SVDT_MACRO(VEC2, Vec2, F32, 2, 1, false)
+ANKI_SVDT_MACRO(I8Vec2, I8, 2, 1, true)
+ANKI_SVDT_MACRO(U8Vec2, U8, 2, 1, true)
+ANKI_SVDT_MACRO(I16Vec2, I16, 2, 1, true)
+ANKI_SVDT_MACRO(U16Vec2, U16, 2, 1, true)
+ANKI_SVDT_MACRO(IVec2, I32, 2, 1, true)
+ANKI_SVDT_MACRO(UVec2, U32, 2, 1, true)
+ANKI_SVDT_MACRO(HVec2, F16, 2, 1, false)
+ANKI_SVDT_MACRO(Vec2, F32, 2, 1, false)
 
-ANKI_SVDT_MACRO(I8VEC3, I8Vec3, I8, 3, 1, true)
-ANKI_SVDT_MACRO(U8VEC3, U8Vec3, U8, 3, 1, true)
-ANKI_SVDT_MACRO(I16VEC3, I16Vec3, I16, 3, 1, true)
-ANKI_SVDT_MACRO(U16VEC3, U16Vec3, U16, 3, 1, true)
-ANKI_SVDT_MACRO(IVEC3, IVec3, I32, 3, 1, true)
-ANKI_SVDT_MACRO(UVEC3, UVec3, U32, 3, 1, true)
-ANKI_SVDT_MACRO(HVEC3, HVec3, F16, 3, 1, false)
-ANKI_SVDT_MACRO(VEC3, Vec3, F32, 3, 1, false)
+ANKI_SVDT_MACRO(I8Vec3, I8, 3, 1, true)
+ANKI_SVDT_MACRO(U8Vec3, U8, 3, 1, true)
+ANKI_SVDT_MACRO(I16Vec3, I16, 3, 1, true)
+ANKI_SVDT_MACRO(U16Vec3, U16, 3, 1, true)
+ANKI_SVDT_MACRO(IVec3, I32, 3, 1, true)
+ANKI_SVDT_MACRO(UVec3, U32, 3, 1, true)
+ANKI_SVDT_MACRO(HVec3, F16, 3, 1, false)
+ANKI_SVDT_MACRO(Vec3, F32, 3, 1, false)
 
-ANKI_SVDT_MACRO(I8VEC4, I8Vec4, I8, 4, 1, true)
-ANKI_SVDT_MACRO(U8VEC4, U8Vec4, U8, 4, 1, true)
-ANKI_SVDT_MACRO(I16VEC4, I16Vec4, I16, 4, 1, true)
-ANKI_SVDT_MACRO(U16VEC4, U16Vec4, U16, 4, 1, true)
-ANKI_SVDT_MACRO(IVEC4, IVec4, I32, 4, 1, true)
-ANKI_SVDT_MACRO(UVEC4, UVec4, U32, 4, 1, true)
-ANKI_SVDT_MACRO(HVEC4, HVec4, F16, 4, 1, false)
-ANKI_SVDT_MACRO(VEC4, Vec4, F32, 4, 1, false)
+ANKI_SVDT_MACRO(I8Vec4, I8, 4, 1, true)
+ANKI_SVDT_MACRO(U8Vec4, U8, 4, 1, true)
+ANKI_SVDT_MACRO(I16Vec4, I16, 4, 1, true)
+ANKI_SVDT_MACRO(U16Vec4, U16, 4, 1, true)
+ANKI_SVDT_MACRO(IVec4, I32, 4, 1, true)
+ANKI_SVDT_MACRO(UVec4, U32, 4, 1, true)
+ANKI_SVDT_MACRO(HVec4, F16, 4, 1, false)
+ANKI_SVDT_MACRO(Vec4, F32, 4, 1, false)
 
-ANKI_SVDT_MACRO(MAT3, Mat3, F32, 3, 3, false)
-ANKI_SVDT_MACRO(MAT3X4, Mat3x4, F32, 3, 4, false)
-ANKI_SVDT_MACRO(MAT4, Mat4, F32, 4, 4, false)
+ANKI_SVDT_MACRO(Mat3, F32, 3, 3, false)
+ANKI_SVDT_MACRO(Mat3x4, F32, 3, 4, false)
+ANKI_SVDT_MACRO(Mat4, F32, 4, 4, false)
 #endif
 
-// ANKI_SVDT_MACRO_OPAQUE(capital, varType)
+// ANKI_SVDT_MACRO_OPAQUE(const, varType)
 #if defined(ANKI_SVDT_MACRO_OPAQUE)
-ANKI_SVDT_MACRO_OPAQUE(TEXTURE_1D, texture1D)
-ANKI_SVDT_MACRO_OPAQUE(TEXTURE_1D_ARRAY, texture1DArray)
-ANKI_SVDT_MACRO_OPAQUE(TEXTURE_2D, texture2D)
-ANKI_SVDT_MACRO_OPAQUE(TEXTURE_2D_ARRAY, texture2DArray)
-ANKI_SVDT_MACRO_OPAQUE(TEXTURE_3D, texture3D)
-ANKI_SVDT_MACRO_OPAQUE(TEXTURE_CUBE, textureCube)
-ANKI_SVDT_MACRO_OPAQUE(TEXTURE_CUBE_ARRAY, textureCubeArray)
+ANKI_SVDT_MACRO_OPAQUE(Texture1D, texture1D)
+ANKI_SVDT_MACRO_OPAQUE(Texture1DArray, texture1DArray)
+ANKI_SVDT_MACRO_OPAQUE(Texture2D, texture2D)
+ANKI_SVDT_MACRO_OPAQUE(Texture2DArray, texture2DArray)
+ANKI_SVDT_MACRO_OPAQUE(Texture3D, texture3D)
+ANKI_SVDT_MACRO_OPAQUE(TextureCube, textureCube)
+ANKI_SVDT_MACRO_OPAQUE(TextureCubeArray, textureCubeArray)
 
-ANKI_SVDT_MACRO_OPAQUE(IMAGE_1D, image1D)
-ANKI_SVDT_MACRO_OPAQUE(IMAGE_1D_ARRAY, image1DArray)
-ANKI_SVDT_MACRO_OPAQUE(IMAGE_2D, image2D)
-ANKI_SVDT_MACRO_OPAQUE(IMAGE_2D_ARRAY, image2DArray)
-ANKI_SVDT_MACRO_OPAQUE(IMAGE_3D, image3D)
-ANKI_SVDT_MACRO_OPAQUE(IMAGE_CUBE, imageCube)
-ANKI_SVDT_MACRO_OPAQUE(IMAGE_CUBE_ARRAY, imageCubeArray)
+ANKI_SVDT_MACRO_OPAQUE(Image1D, image1D)
+ANKI_SVDT_MACRO_OPAQUE(Image1DArray, image1DArray)
+ANKI_SVDT_MACRO_OPAQUE(Image2D, image2D)
+ANKI_SVDT_MACRO_OPAQUE(Image2DArray, image2DArray)
+ANKI_SVDT_MACRO_OPAQUE(Image3D, image3D)
+ANKI_SVDT_MACRO_OPAQUE(ImageCube, imageCube)
+ANKI_SVDT_MACRO_OPAQUE(ImageCubeArray, imageCubeArray)
 
-ANKI_SVDT_MACRO_OPAQUE(SAMPLER, sampler)
+ANKI_SVDT_MACRO_OPAQUE(Sampler, sampler)
 #endif

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;
@@ -100,7 +100,7 @@ class Texture : public GrObject
 	ANKI_GR_OBJECT
 
 public:
-	static constexpr GrObjectType CLASS_TYPE = GrObjectType::TEXTURE;
+	static constexpr GrObjectType kClassType = GrObjectType::kTexture;
 
 	U32 getWidth() const
 	{
@@ -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,14 +248,14 @@ 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)
-		: GrObject(manager, CLASS_TYPE, name)
+		: GrObject(manager, kClassType, 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)
 	{
@@ -74,7 +74,7 @@ class TextureView : public GrObject
 	ANKI_GR_OBJECT
 
 public:
-	static constexpr GrObjectType CLASS_TYPE = GrObjectType::TEXTURE_VIEW;
+	static constexpr GrObjectType kClassType = GrObjectType::kTextureView;
 
 	TextureType getTextureType() const
 	{
@@ -93,23 +93,23 @@ 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)
+		: GrObject(manager, kClassType, 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;
+		m_subresource.m_firstMipmap = kMaxU32;
+		m_subresource.m_mipmapCount = kMaxU32;
 
-		m_subresource.m_firstLayer = MAX_U32;
-		m_subresource.m_layerCount = MAX_U32;
+		m_subresource.m_firstLayer = kMaxU32;
+		m_subresource.m_layerCount = kMaxU32;
 
-		m_subresource.m_firstFace = MAX_U8;
-		m_subresource.m_faceCount = MAX_U8;
+		m_subresource.m_firstFace = kMaxU8;
+		m_subresource.m_faceCount = kMaxU8;
 	}
 
 	/// Destroy.
@@ -119,10 +119,10 @@ protected:
 
 	Bool initialized() const
 	{
-		return m_texType != TextureType::COUNT && 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;
+		return m_texType != TextureType::kCount && m_subresource.m_firstMipmap < kMaxU32
+			   && m_subresource.m_mipmapCount < kMaxU32 && m_subresource.m_firstLayer < kMaxU32
+			   && m_subresource.m_layerCount < kMaxU32 && m_subresource.m_firstFace < kMaxU8
+			   && m_subresource.m_faceCount < kMaxU8;
 	}
 
 private:

AnKi/Gr/TimestampQuery.h

@@ -18,7 +18,7 @@ class TimestampQuery : public GrObject
 	ANKI_GR_OBJECT
 
 public:
-	static constexpr GrObjectType CLASS_TYPE = GrObjectType::TIMESTAMP_QUERY;
+	static constexpr GrObjectType kClassType = GrObjectType::kTimstampQuery;
 
 	/// Get the result if it's available. It won't block.
 	TimestampQueryResult getResult(Second& timestamp) const;
@@ -26,7 +26,7 @@ public:
 protected:
 	/// Construct.
 	TimestampQuery(GrManager* manager, CString name)
-		: GrObject(manager, CLASS_TYPE, name)
+		: GrObject(manager, kClassType, name)
 	{
 	}
 

AnKi/Gr/Utils/FrameGpuAllocator.cpp

@@ -12,9 +12,9 @@ void FrameGpuAllocator::init(PtrSize size, U32 alignment, PtrSize maxAllocationS
 	ANKI_ASSERT(!isCreated());
 	ANKI_ASSERT(size > 0 && alignment > 0 && maxAllocationSize > 0);
 
-	PtrSize perFrameSize = size / MAX_FRAMES_IN_FLIGHT;
+	PtrSize perFrameSize = size / kMaxFramesInFlight;
 	alignRoundDown(alignment, perFrameSize);
-	m_size = perFrameSize * MAX_FRAMES_IN_FLIGHT;
+	m_size = perFrameSize * kMaxFramesInFlight;
 
 	m_alignment = alignment;
 	m_maxAllocationSize = maxAllocationSize;
@@ -24,11 +24,11 @@ PtrSize FrameGpuAllocator::endFrame()
 {
 	ANKI_ASSERT(isCreated());
 
-	PtrSize perFrameSize = m_size / MAX_FRAMES_IN_FLIGHT;
+	PtrSize perFrameSize = m_size / kMaxFramesInFlight;
 
-	PtrSize crntFrameStartOffset = perFrameSize * (m_frame % MAX_FRAMES_IN_FLIGHT);
+	PtrSize crntFrameStartOffset = perFrameSize * (m_frame % kMaxFramesInFlight);
 
-	PtrSize nextFrameStartOffset = perFrameSize * ((m_frame + 1) % MAX_FRAMES_IN_FLIGHT);
+	PtrSize nextFrameStartOffset = perFrameSize * ((m_frame + 1) % kMaxFramesInFlight);
 
 	PtrSize crntOffset = m_offset.exchange(nextFrameStartOffset);
 	ANKI_ASSERT(crntOffset >= crntFrameStartOffset);
@@ -44,15 +44,15 @@ Error FrameGpuAllocator::allocate(PtrSize originalSize, PtrSize& outOffset)
 {
 	ANKI_ASSERT(isCreated());
 	ANKI_ASSERT(originalSize > 0);
-	Error err = Error::NONE;
+	Error err = Error::kNone;
 
 	// Align size
 	PtrSize size = getAlignedRoundUp(m_alignment, originalSize);
 	ANKI_ASSERT(size <= m_maxAllocationSize && "Too high!");
 
 	const PtrSize offset = m_offset.fetchAdd(size);
-	const PtrSize perFrameSize = m_size / MAX_FRAMES_IN_FLIGHT;
-	const PtrSize crntFrameStartOffset = perFrameSize * (m_frame % MAX_FRAMES_IN_FLIGHT);
+	const PtrSize perFrameSize = m_size / kMaxFramesInFlight;
+	const PtrSize crntFrameStartOffset = perFrameSize * (m_frame % kMaxFramesInFlight);
 
 	if(offset - crntFrameStartOffset + size <= perFrameSize)
 	{
@@ -70,8 +70,8 @@ Error FrameGpuAllocator::allocate(PtrSize originalSize, PtrSize& outOffset)
 	}
 	else
 	{
-		outOffset = MAX_PTR_SIZE;
-		err = Error::OUT_OF_MEMORY;
+		outOffset = kMaxPtrSize;
+		err = Error::kOutOfMemory;
 	}
 
 	return err;
@@ -80,8 +80,8 @@ Error FrameGpuAllocator::allocate(PtrSize originalSize, PtrSize& outOffset)
 #if ANKI_ENABLE_TRACE
 PtrSize FrameGpuAllocator::getUnallocatedMemorySize() const
 {
-	PtrSize perFrameSize = m_size / MAX_FRAMES_IN_FLIGHT;
-	PtrSize crntFrameStartOffset = perFrameSize * (m_frame % MAX_FRAMES_IN_FLIGHT);
+	PtrSize perFrameSize = m_size / kMaxFramesInFlight;
+	PtrSize crntFrameStartOffset = perFrameSize * (m_frame % kMaxFramesInFlight);
 	PtrSize usedSize = m_offset.getNonAtomically() - crntFrameStartOffset + m_lastAllocatedSize.getNonAtomically();
 
 	PtrSize remaining = (perFrameSize >= usedSize) ? (perFrameSize - usedSize) : 0;

AnKi/Gr/Utils/FrameGpuAllocator.h

@@ -34,7 +34,7 @@ public:
 	/// @param size The size of the GPU buffer.
 	/// @param alignment The working alignment.
 	/// @param maxAllocationSize The size in @a allocate cannot exceed maxAllocationSize.
-	void init(PtrSize size, U32 alignment, PtrSize maxAllocationSize = MAX_PTR_SIZE);
+	void init(PtrSize size, U32 alignment, PtrSize maxAllocationSize = kMaxPtrSize);
 
 	/// Allocate memory for a dynamic buffer.
 	Error allocate(PtrSize size, PtrSize& outOffset);

AnKi/Gr/Utils/Functions.cpp

@@ -85,20 +85,20 @@ template<typename T>
 class IsShaderVarDataTypeAMatrix
 {
 public:
-	static constexpr Bool VALUE = false;
+	static constexpr Bool kValue = false;
 };
 
-#define ANKI_SVDT_MACRO(capital, type, baseType, rowCount, columnCount, isIntagralType) \
+#define ANKI_SVDT_MACRO(type, baseType, rowCount, columnCount, isIntagralType) \
 	template<> \
 	class IsShaderVarDataTypeAMatrix<type> \
 	{ \
 	public: \
-		static constexpr Bool VALUE = rowCount * columnCount > 4; \
+		static constexpr Bool kValue = rowCount * columnCount > 4; \
 	};
 #include <AnKi/Gr/ShaderVariableDataType.defs.h>
 #undef ANKI_SVDT_MACRO
 
-template<typename T, Bool isMatrix = IsShaderVarDataTypeAMatrix<T>::VALUE>
+template<typename T, Bool isMatrix = IsShaderVarDataTypeAMatrix<T>::kValue>
 class WriteShaderBlockMemory
 {
 public:
@@ -128,8 +128,8 @@ void writeShaderBlockMemory(ShaderVariableDataType type, const ShaderVariableBlo
 {
 	switch(type)
 	{
-#define ANKI_SVDT_MACRO(capital, type, baseType, rowCount, columnCount, isIntagralType) \
-	case ShaderVariableDataType::capital: \
+#define ANKI_SVDT_MACRO(type, baseType, rowCount, columnCount, isIntagralType) \
+	case ShaderVariableDataType::k##type: \
 		WriteShaderBlockMemory<type>()(varBlkInfo, elements, elementsCount, buffBegin, buffEnd); \
 		break;
 #include <AnKi/Gr/ShaderVariableDataType.defs.h>

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;
 }
 
@@ -31,11 +31,11 @@ inline Bool blendingDisabled(BlendFactor srcFactorRgb, BlendFactor dstFactorRgb,
 template<typename T>
 ShaderVariableDataType getShaderVariableTypeFromTypename();
 
-#define ANKI_SVDT_MACRO(capital, type, baseType, rowCount, columnCount, isIntagralType) \
+#define ANKI_SVDT_MACRO(type, baseType, rowCount, columnCount, isIntagralType) \
 	template<> \
 	inline ShaderVariableDataType getShaderVariableTypeFromTypename<type>() \
 	{ \
-		return ShaderVariableDataType::capital; \
+		return ShaderVariableDataType::k##type; \
 	}
 
 #include <AnKi/Gr/ShaderVariableDataType.defs.h>

AnKi/Gr/Vulkan/AccelerationStructureImpl.cpp

@@ -25,7 +25,7 @@ Error AccelerationStructureImpl::init(const AccelerationStructureInitInfo& inf)
 	ANKI_ASSERT(inf.isValid());
 	m_type = inf.m_type;
 
-	if(m_type == AccelerationStructureType::BOTTOM_LEVEL)
+	if(m_type == AccelerationStructureType::kBottomLevel)
 	{
 		// Geom
 		VkAccelerationStructureGeometryKHR& geom = m_geometry;
@@ -61,7 +61,7 @@ Error AccelerationStructureImpl::init(const AccelerationStructureInitInfo& inf)
 
 		// Create the buffer that holds the AS memory
 		BufferInitInfo bufferInit(inf.getName());
-		bufferInit.m_usage = PrivateBufferUsageBit::ACCELERATION_STRUCTURE;
+		bufferInit.m_usage = PrivateBufferUsageBit::kAccelerationStructure;
 		bufferInit.m_size = buildSizes.accelerationStructureSize;
 		m_asBuffer = getManager().newBuffer(bufferInit);
 
@@ -94,12 +94,12 @@ Error AccelerationStructureImpl::init(const AccelerationStructureInitInfo& inf)
 
 		BufferInitInfo buffInit("AS instances");
 		buffInit.m_size = sizeof(VkAccelerationStructureInstanceKHR) * inf.m_topLevel.m_instances.getSize();
-		buffInit.m_usage = PrivateBufferUsageBit::ACCELERATION_STRUCTURE;
-		buffInit.m_mapAccess = BufferMapAccessBit::WRITE;
+		buffInit.m_usage = PrivateBufferUsageBit::kAccelerationStructure;
+		buffInit.m_mapAccess = BufferMapAccessBit::kWrite;
 		m_topLevelInfo.m_instancesBuffer = getManager().newBuffer(buffInit);
 
 		VkAccelerationStructureInstanceKHR* instances = static_cast<VkAccelerationStructureInstanceKHR*>(
-			m_topLevelInfo.m_instancesBuffer->map(0, MAX_PTR_SIZE, BufferMapAccessBit::WRITE));
+			m_topLevelInfo.m_instancesBuffer->map(0, kMaxPtrSize, BufferMapAccessBit::kWrite));
 		for(U32 i = 0; i < inf.m_topLevel.m_instances.getSize(); ++i)
 		{
 			VkAccelerationStructureInstanceKHR& outInst = instances[i];
@@ -119,7 +119,7 @@ Error AccelerationStructureImpl::init(const AccelerationStructureInitInfo& inf)
 			m_topLevelInfo.m_blas.emplaceBack(getAllocator(), inf.m_topLevel.m_instances[i].m_bottomLevel);
 		}
 
-		m_topLevelInfo.m_instancesBuffer->flush(0, MAX_PTR_SIZE);
+		m_topLevelInfo.m_instancesBuffer->flush(0, kMaxPtrSize);
 		m_topLevelInfo.m_instancesBuffer->unmap();
 
 		// Geom
@@ -150,7 +150,7 @@ Error AccelerationStructureImpl::init(const AccelerationStructureInitInfo& inf)
 
 		// Create the buffer that holds the AS memory
 		BufferInitInfo bufferInit(inf.getName());
-		bufferInit.m_usage = PrivateBufferUsageBit::ACCELERATION_STRUCTURE;
+		bufferInit.m_usage = PrivateBufferUsageBit::kAccelerationStructure;
 		bufferInit.m_size = buildSizes.accelerationStructureSize;
 		m_asBuffer = getManager().newBuffer(bufferInit);
 
@@ -171,7 +171,7 @@ Error AccelerationStructureImpl::init(const AccelerationStructureInitInfo& inf)
 		m_rangeInfo.primitiveCount = inf.m_topLevel.m_instances.getSize();
 	}
 
-	return Error::NONE;
+	return Error::kNone;
 }
 
 void AccelerationStructureImpl::computeBarrierInfo(AccelerationStructureUsageBit before,
@@ -183,44 +183,44 @@ void AccelerationStructureImpl::computeBarrierInfo(AccelerationStructureUsageBit
 	srcStages = 0;
 	srcAccesses = 0;
 
-	if(before == AccelerationStructureUsageBit::NONE)
+	if(before == AccelerationStructureUsageBit::kNone)
 	{
 		srcStages |= VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
 		srcAccesses |= 0;
 	}
 
-	if(!!(before & AccelerationStructureUsageBit::BUILD))
+	if(!!(before & AccelerationStructureUsageBit::kBuild))
 	{
 		srcStages |= VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR;
 		srcAccesses |= VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR;
 	}
 
-	if(!!(before & AccelerationStructureUsageBit::ATTACH))
+	if(!!(before & AccelerationStructureUsageBit::kAttach))
 	{
 		srcStages |= VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR;
 		srcAccesses |= VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR;
 	}
 
-	if(!!(before & AccelerationStructureUsageBit::GEOMETRY_READ))
+	if(!!(before & AccelerationStructureUsageBit::kGeometryRead))
 	{
 		srcStages |= 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;
 		srcAccesses |= VK_ACCESS_MEMORY_READ_BIT; // READ_BIT is the only viable solution by elimination
 	}
 
-	if(!!(before & AccelerationStructureUsageBit::FRAGMENT_READ))
+	if(!!(before & AccelerationStructureUsageBit::kFragmentRead))
 	{
 		srcStages |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
 		srcAccesses |= VK_ACCESS_MEMORY_READ_BIT;
 	}
 
-	if(!!(before & AccelerationStructureUsageBit::COMPUTE_READ))
+	if(!!(before & AccelerationStructureUsageBit::kComputeRead))
 	{
 		srcStages |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
 		srcAccesses |= VK_ACCESS_MEMORY_READ_BIT;
 	}
 
-	if(!!(before & AccelerationStructureUsageBit::TRACE_RAYS_READ))
+	if(!!(before & AccelerationStructureUsageBit::kTraceRaysRead))
 	{
 		srcStages |= VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
 		srcAccesses |= VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR;
@@ -230,38 +230,38 @@ void AccelerationStructureImpl::computeBarrierInfo(AccelerationStructureUsageBit
 	dstStages = 0;
 	dstAccesses = 0;
 
-	if(!!(after & AccelerationStructureUsageBit::BUILD))
+	if(!!(after & AccelerationStructureUsageBit::kBuild))
 	{
 		dstStages |= VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR;
 		dstAccesses |= VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR;
 	}
 
-	if(!!(after & AccelerationStructureUsageBit::ATTACH))
+	if(!!(after & AccelerationStructureUsageBit::kAttach))
 	{
 		dstStages |= VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR;
 		dstAccesses |= VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR;
 	}
 
-	if(!!(after & AccelerationStructureUsageBit::GEOMETRY_READ))
+	if(!!(after & AccelerationStructureUsageBit::kGeometryRead))
 	{
 		dstStages |= 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;
 		dstAccesses |= VK_ACCESS_MEMORY_READ_BIT; // READ_BIT is the only viable solution by elimination
 	}
 
-	if(!!(after & AccelerationStructureUsageBit::FRAGMENT_READ))
+	if(!!(after & AccelerationStructureUsageBit::kFragmentRead))
 	{
 		dstStages |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
 		dstAccesses |= VK_ACCESS_MEMORY_READ_BIT;
 	}
 
-	if(!!(after & AccelerationStructureUsageBit::COMPUTE_READ))
+	if(!!(after & AccelerationStructureUsageBit::kComputeRead))
 	{
 		dstStages |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
 		dstAccesses |= VK_ACCESS_MEMORY_READ_BIT;
 	}
 
-	if(!!(after & AccelerationStructureUsageBit::TRACE_RAYS_READ))
+	if(!!(after & AccelerationStructureUsageBit::kTraceRaysRead))
 	{
 		dstStages |= VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
 		dstAccesses |= VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR;

AnKi/Gr/Vulkan/BufferImpl.cpp

@@ -48,15 +48,15 @@ BufferImpl::~BufferImpl()
 Error BufferImpl::init(const BufferInitInfo& inf)
 {
 	ANKI_ASSERT(!isCreated());
-	const Bool exposeGpuAddress = !!(getGrManagerImpl().getExtensions() & VulkanExtensions::KHR_BUFFER_DEVICE_ADDRESS)
-								  && !!(inf.m_usage & ~BufferUsageBit::ALL_TRANSFER);
+	const Bool exposeGpuAddress = !!(getGrManagerImpl().getExtensions() & VulkanExtensions::kKHR_buffer_device_address)
+								  && !!(inf.m_usage & ~BufferUsageBit::kAllTransfer);
 
 	PtrSize size = inf.m_size;
 	BufferMapAccessBit access = inf.m_mapAccess;
 	BufferUsageBit usage = inf.m_usage;
 
 	ANKI_ASSERT(size > 0);
-	ANKI_ASSERT(usage != BufferUsageBit::NONE);
+	ANKI_ASSERT(usage != BufferUsageBit::kNone);
 
 	m_mappedMemoryRangeAlignment = getGrManagerImpl().getPhysicalDeviceProperties().limits.nonCoherentAtomSize;
 
@@ -84,10 +84,10 @@ Error BufferImpl::init(const BufferInitInfo& inf)
 	// Get mem requirements
 	VkMemoryRequirements req;
 	vkGetBufferMemoryRequirements(getDevice(), m_handle, &req);
-	U32 memIdx = MAX_U32;
+	U32 memIdx = kMaxU32;
 	const Bool isDiscreteGpu = getGrManagerImpl().getDeviceCapabilities().m_discreteGpu;
 
-	if(access == BufferMapAccessBit::WRITE)
+	if(access == BufferMapAccessBit::kWrite)
 	{
 		// Only write, probably for uploads
 
@@ -97,7 +97,7 @@ Error BufferImpl::init(const BufferInitInfo& inf)
 
 		if(isDiscreteGpu)
 		{
-			if((usage & (~BufferUsageBit::ALL_TRANSFER)) != BufferUsageBit::NONE)
+			if((usage & (~BufferUsageBit::kAllTransfer)) != BufferUsageBit::kNone)
 			{
 				// Will be used for something other than transfer, try to put it in the device
 				prefer |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
@@ -112,7 +112,7 @@ Error BufferImpl::init(const BufferInitInfo& inf)
 		memIdx = getGrManagerImpl().getGpuMemoryManager().findMemoryType(req.memoryTypeBits, prefer, avoid);
 
 		// 2nd try: host & coherent
-		if(memIdx == MAX_U32)
+		if(memIdx == kMaxU32)
 		{
 			prefer = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
 			avoid = 0;
@@ -121,7 +121,7 @@ Error BufferImpl::init(const BufferInitInfo& inf)
 			{
 				ANKI_VK_LOGW("Using a fallback mode for write-only buffer");
 
-				if((usage & (~BufferUsageBit::ALL_TRANSFER)) == BufferUsageBit::NONE)
+				if((usage & (~BufferUsageBit::kAllTransfer)) == BufferUsageBit::kNone)
 				{
 					// Will be used only for transfers, don't want it in the device
 					avoid |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
@@ -131,7 +131,7 @@ Error BufferImpl::init(const BufferInitInfo& inf)
 			memIdx = getGrManagerImpl().getGpuMemoryManager().findMemoryType(req.memoryTypeBits, prefer, avoid);
 		}
 	}
-	else if(!!(access & BufferMapAccessBit::READ))
+	else if(!!(access & BufferMapAccessBit::kRead))
 	{
 		// Read or read/write
 
@@ -143,7 +143,7 @@ Error BufferImpl::init(const BufferInitInfo& inf)
 																		 0);
 
 		// Fallback: Just cached
-		if(memIdx == MAX_U32)
+		if(memIdx == kMaxU32)
 		{
 			if(isDiscreteGpu)
 			{
@@ -158,35 +158,35 @@ Error BufferImpl::init(const BufferInitInfo& inf)
 	{
 		// Not mapped
 
-		ANKI_ASSERT(access == BufferMapAccessBit::NONE);
+		ANKI_ASSERT(access == BufferMapAccessBit::kNone);
 
 		// Device only
 		memIdx = getGrManagerImpl().getGpuMemoryManager().findMemoryType(
 			req.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
 
 		// Fallback: Device with anything else
-		if(memIdx == MAX_U32)
+		if(memIdx == kMaxU32)
 		{
 			memIdx = getGrManagerImpl().getGpuMemoryManager().findMemoryType(req.memoryTypeBits,
 																			 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, 0);
 		}
 	}
 
-	if(memIdx == MAX_U32)
+	if(memIdx == kMaxU32)
 	{
 		ANKI_VK_LOGE("Failed to find appropriate memory type for buffer: %s", getName().cstr());
-		return Error::FUNCTION_FAILED;
+		return Error::kFunctionFailed;
 	}
 
 	const VkPhysicalDeviceMemoryProperties& props = getGrManagerImpl().getMemoryProperties();
 	m_memoryFlags = props.memoryTypes[memIdx].propertyFlags;
 
-	if(!!(access & BufferMapAccessBit::READ) && !(m_memoryFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT))
+	if(!!(access & BufferMapAccessBit::kRead) && !(m_memoryFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT))
 	{
 		m_needsInvalidate = true;
 	}
 
-	if(!!(access & BufferMapAccessBit::WRITE) && !(m_memoryFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT))
+	if(!!(access & BufferMapAccessBit::kWrite) && !(m_memoryFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT))
 	{
 		m_needsFlush = true;
 	}
@@ -212,7 +212,7 @@ Error BufferImpl::init(const BufferInitInfo& inf)
 		if(m_gpuAddress == 0)
 		{
 			ANKI_VK_LOGE("vkGetBufferDeviceAddressKHR() failed");
-			return Error::FUNCTION_FAILED;
+			return Error::kFunctionFailed;
 		}
 	}
 
@@ -220,17 +220,17 @@ Error BufferImpl::init(const BufferInitInfo& inf)
 	m_size = inf.m_size;
 	m_actualSize = size;
 	m_usage = usage;
-	return Error::NONE;
+	return Error::kNone;
 }
 
 void* BufferImpl::map(PtrSize offset, PtrSize range, [[maybe_unused]] BufferMapAccessBit access)
 {
 	ANKI_ASSERT(isCreated());
-	ANKI_ASSERT(access != BufferMapAccessBit::NONE);
-	ANKI_ASSERT((access & m_access) != BufferMapAccessBit::NONE);
+	ANKI_ASSERT(access != BufferMapAccessBit::kNone);
+	ANKI_ASSERT((access & m_access) != BufferMapAccessBit::kNone);
 	ANKI_ASSERT(!m_mapped);
 	ANKI_ASSERT(offset < m_size);
-	if(range == MAX_PTR_SIZE)
+	if(range == kMaxPtrSize)
 	{
 		range = m_size - offset;
 	}
@@ -250,43 +250,43 @@ VkPipelineStageFlags BufferImpl::computePplineStage(BufferUsageBit usage)
 {
 	VkPipelineStageFlags stageMask = 0;
 
-	if(!!(usage & BufferUsageBit::ALL_INDIRECT))
+	if(!!(usage & BufferUsageBit::kAllIndirect))
 	{
 		stageMask |= VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT;
 	}
 
-	if(!!(usage & (BufferUsageBit::INDEX | BufferUsageBit::VERTEX)))
+	if(!!(usage & (BufferUsageBit::kIndex | BufferUsageBit::kVertex)))
 	{
 		stageMask |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
 	}
 
-	if(!!(usage & BufferUsageBit::ALL_GEOMETRY))
+	if(!!(usage & BufferUsageBit::kAllGeometry))
 	{
 		stageMask |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT
 					 | VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT | VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
 	}
 
-	if(!!(usage & BufferUsageBit::ALL_FRAGMENT))
+	if(!!(usage & BufferUsageBit::kAllFragment))
 	{
 		stageMask |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
 	}
 
-	if(!!(usage & (BufferUsageBit::ALL_COMPUTE & ~BufferUsageBit::INDIRECT_COMPUTE)))
+	if(!!(usage & (BufferUsageBit::kAllCompute & ~BufferUsageBit::kIndirectCompute)))
 	{
 		stageMask |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
 	}
 
-	if(!!(usage & BufferUsageBit::ACCELERATION_STRUCTURE_BUILD))
+	if(!!(usage & BufferUsageBit::kAccelerationStructureBuild))
 	{
 		stageMask |= VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR;
 	}
 
-	if(!!(usage & (BufferUsageBit::ALL_TRACE_RAYS & ~BufferUsageBit::INDIRECT_TRACE_RAYS)))
+	if(!!(usage & (BufferUsageBit::kAllTraceRays & ~BufferUsageBit::kIndirectTraceRays)))
 	{
 		stageMask |= VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
 	}
 
-	if(!!(usage & BufferUsageBit::ALL_TRANSFER))
+	if(!!(usage & BufferUsageBit::kAllTransfer))
 	{
 		stageMask |= VK_PIPELINE_STAGE_TRANSFER_BIT;
 	}
@@ -304,59 +304,59 @@ VkAccessFlags BufferImpl::computeAccessMask(BufferUsageBit usage)
 {
 	VkAccessFlags mask = 0;
 
-	constexpr BufferUsageBit SHADER_READ =
-		BufferUsageBit::STORAGE_GEOMETRY_READ | BufferUsageBit::STORAGE_FRAGMENT_READ
-		| BufferUsageBit::STORAGE_COMPUTE_READ | BufferUsageBit::STORAGE_TRACE_RAYS_READ
-		| BufferUsageBit::TEXTURE_GEOMETRY_READ | BufferUsageBit::TEXTURE_FRAGMENT_READ
-		| BufferUsageBit::TEXTURE_COMPUTE_READ | BufferUsageBit::TEXTURE_TRACE_RAYS_READ;
+	constexpr BufferUsageBit kShaderRead = BufferUsageBit::kStorageGeometryRead | BufferUsageBit::kStorageFragmentRead
+										   | BufferUsageBit::kStorageComputeRead | BufferUsageBit::kStorageTraceRaysRead
+										   | BufferUsageBit::kTextureGeometryRead | BufferUsageBit::kTextureFragmentRead
+										   | BufferUsageBit::kTextureComputeRead
+										   | BufferUsageBit::kTextureTraceRaysRead;
 
-	constexpr BufferUsageBit SHADER_WRITE =
-		BufferUsageBit::STORAGE_GEOMETRY_WRITE | BufferUsageBit::STORAGE_FRAGMENT_WRITE
-		| BufferUsageBit::STORAGE_COMPUTE_WRITE | BufferUsageBit::STORAGE_TRACE_RAYS_WRITE
-		| BufferUsageBit::TEXTURE_GEOMETRY_WRITE | BufferUsageBit::TEXTURE_FRAGMENT_WRITE
-		| BufferUsageBit::TEXTURE_COMPUTE_WRITE | BufferUsageBit::TEXTURE_TRACE_RAYS_WRITE;
+	constexpr BufferUsageBit kShaderWrite =
+		BufferUsageBit::kStorageGeometryWrite | BufferUsageBit::kStorageFragmentWrite
+		| BufferUsageBit::kStorageComputeWrite | BufferUsageBit::kStorageTraceRaysWrite
+		| BufferUsageBit::kTextureGeometryWrite | BufferUsageBit::kTextureFragmentWrite
+		| BufferUsageBit::kTextureComputeWrite | BufferUsageBit::kTextureTraceRaysWrite;
 
-	if(!!(usage & BufferUsageBit::ALL_UNIFORM))
+	if(!!(usage & BufferUsageBit::kAllUniform))
 	{
 		mask |= VK_ACCESS_UNIFORM_READ_BIT;
 	}
 
-	if(!!(usage & SHADER_READ))
+	if(!!(usage & kShaderRead))
 	{
 		mask |= VK_ACCESS_SHADER_READ_BIT;
 	}
 
-	if(!!(usage & SHADER_WRITE))
+	if(!!(usage & kShaderWrite))
 	{
 		mask |= VK_ACCESS_SHADER_WRITE_BIT;
 	}
 
-	if(!!(usage & BufferUsageBit::INDEX))
+	if(!!(usage & BufferUsageBit::kIndex))
 	{
 		mask |= VK_ACCESS_INDEX_READ_BIT;
 	}
 
-	if(!!(usage & BufferUsageBit::VERTEX))
+	if(!!(usage & BufferUsageBit::kVertex))
 	{
 		mask |= VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
 	}
 
-	if(!!(usage & BufferUsageBit::ALL_INDIRECT))
+	if(!!(usage & BufferUsageBit::kAllIndirect))
 	{
 		mask |= VK_ACCESS_INDIRECT_COMMAND_READ_BIT;
 	}
 
-	if(!!(usage & BufferUsageBit::TRANSFER_DESTINATION))
+	if(!!(usage & BufferUsageBit::kTransferDestination))
 	{
 		mask |= VK_ACCESS_TRANSFER_WRITE_BIT;
 	}
 
-	if(!!(usage & BufferUsageBit::TRANSFER_SOURCE))
+	if(!!(usage & BufferUsageBit::kTransferSource))
 	{
 		mask |= VK_ACCESS_TRANSFER_READ_BIT;
 	}
 
-	if(!!(usage & BufferUsageBit::ACCELERATION_STRUCTURE_BUILD))
+	if(!!(usage & BufferUsageBit::kAccelerationStructureBuild))
 	{
 		mask |= VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR;
 	}
@@ -379,14 +379,14 @@ void BufferImpl::computeBarrierInfo(BufferUsageBit before, BufferUsageBit after,
 
 VkBufferView BufferImpl::getOrCreateBufferView(Format fmt, PtrSize offset, PtrSize range) const
 {
-	if(range == MAX_PTR_SIZE)
+	if(range == kMaxPtrSize)
 	{
 		ANKI_ASSERT(m_size >= offset);
 		range = m_size - offset;
 	}
 
 	// Checks
-	ANKI_ASSERT(!!(m_usage & BufferUsageBit::ALL_TEXTURE));
+	ANKI_ASSERT(!!(m_usage & BufferUsageBit::kAllTexture));
 	ANKI_ASSERT(offset + range <= m_size);
 
 	ANKI_ASSERT(isAligned(getGrManagerImpl().getDeviceCapabilities().m_textureBufferBindOffsetAlignment,

AnKi/Gr/Vulkan/BufferImpl.h

@@ -65,7 +65,7 @@ public:
 
 	ANKI_FORCE_INLINE void flush(PtrSize offset, PtrSize range) const
 	{
-		ANKI_ASSERT(!!(m_access & BufferMapAccessBit::WRITE) && "No need to flush when the CPU doesn't write");
+		ANKI_ASSERT(!!(m_access & BufferMapAccessBit::kWrite) && "No need to flush when the CPU doesn't write");
 		if(m_needsFlush)
 		{
 			VkMappedMemoryRange vkrange = setVkMappedMemoryRange(offset, range);
@@ -78,7 +78,7 @@ public:
 
 	ANKI_FORCE_INLINE void invalidate(PtrSize offset, PtrSize range) const
 	{
-		ANKI_ASSERT(!!(m_access & BufferMapAccessBit::READ) && "No need to invalidate when the CPU doesn't read");
+		ANKI_ASSERT(!!(m_access & BufferMapAccessBit::kRead) && "No need to invalidate when the CPU doesn't read");
 		if(m_needsInvalidate)
 		{
 			VkMappedMemoryRange vkrange = setVkMappedMemoryRange(offset, range);
@@ -126,7 +126,7 @@ private:
 		alignRoundDown(m_mappedMemoryRangeAlignment, offset);
 
 		// And the range
-		range = (range == MAX_PTR_SIZE) ? m_actualSize : range;
+		range = (range == kMaxPtrSize) ? m_actualSize : range;
 		alignRoundUp(m_mappedMemoryRangeAlignment, range);
 		ANKI_ASSERT(offset + range <= m_memHandle.m_offset + m_actualSize);
 

AnKi/Gr/Vulkan/CommandBuffer.cpp

@@ -246,7 +246,7 @@ void CommandBuffer::bindShaderProgram(const ShaderProgramPtr& prog)
 }
 
 void CommandBuffer::beginRenderPass(const FramebufferPtr& fb,
-									const Array<TextureUsageBit, MAX_COLOR_ATTACHMENTS>& colorAttachmentUsages,
+									const Array<TextureUsageBit, kMaxColorRenderTargets>& colorAttachmentUsages,
 									TextureUsageBit depthStencilAttachmentUsage, U32 minx, U32 miny, U32 width,
 									U32 height)
 {

AnKi/Gr/Vulkan/CommandBufferFactory.cpp

@@ -11,15 +11,15 @@ namespace anki {
 static VulkanQueueType getQueueTypeFromCommandBufferFlags(CommandBufferFlag flags,
 														  const VulkanQueueFamilies& queueFamilies)
 {
-	ANKI_ASSERT(!!(flags & CommandBufferFlag::GENERAL_WORK) ^ !!(flags & CommandBufferFlag::COMPUTE_WORK));
-	if(!(flags & CommandBufferFlag::GENERAL_WORK) && queueFamilies[VulkanQueueType::COMPUTE] != MAX_U32)
+	ANKI_ASSERT(!!(flags & CommandBufferFlag::kGeneralWork) ^ !!(flags & CommandBufferFlag::kComputeWork));
+	if(!(flags & CommandBufferFlag::kGeneralWork) && queueFamilies[VulkanQueueType::kCompute] != kMaxU32)
 	{
-		return VulkanQueueType::COMPUTE;
+		return VulkanQueueType::kCompute;
 	}
 	else
 	{
-		ANKI_ASSERT(queueFamilies[VulkanQueueType::GENERAL] != MAX_U32);
-		return VulkanQueueType::GENERAL;
+		ANKI_ASSERT(queueFamilies[VulkanQueueType::kGeneral] != kMaxU32);
+		return VulkanQueueType::kGeneral;
 	}
 }
 
@@ -56,7 +56,7 @@ Error CommandBufferThreadAllocator::init()
 {
 	for(VulkanQueueType qtype : EnumIterable<VulkanQueueType>())
 	{
-		if(m_factory->m_queueFamilies[qtype] == MAX_U32)
+		if(m_factory->m_queueFamilies[qtype] == kMaxU32)
 		{
 			continue;
 		}
@@ -82,7 +82,7 @@ Error CommandBufferThreadAllocator::init()
 		}
 	}
 
-	return Error::NONE;
+	return Error::kNone;
 }
 
 void CommandBufferThreadAllocator::destroy()
@@ -110,10 +110,10 @@ void CommandBufferThreadAllocator::destroy()
 
 Error CommandBufferThreadAllocator::newCommandBuffer(CommandBufferFlag cmdbFlags, MicroCommandBufferPtr& outPtr)
 {
-	ANKI_ASSERT(!!(cmdbFlags & CommandBufferFlag::COMPUTE_WORK) ^ !!(cmdbFlags & CommandBufferFlag::GENERAL_WORK));
+	ANKI_ASSERT(!!(cmdbFlags & CommandBufferFlag::kComputeWork) ^ !!(cmdbFlags & CommandBufferFlag::kGeneralWork));
 
-	const Bool secondLevel = !!(cmdbFlags & CommandBufferFlag::SECOND_LEVEL);
-	const Bool smallBatch = !!(cmdbFlags & CommandBufferFlag::SMALL_BATCH);
+	const Bool secondLevel = !!(cmdbFlags & CommandBufferFlag::kSecondLevel);
+	const Bool smallBatch = !!(cmdbFlags & CommandBufferFlag::kSmallBatch);
 	const VulkanQueueType queue = getQueueTypeFromCommandBufferFlags(cmdbFlags, m_factory->m_queueFamilies);
 
 	MicroObjectRecycler<MicroCommandBuffer>& recycler = m_recyclers[secondLevel][smallBatch][queue];
@@ -159,15 +159,15 @@ Error CommandBufferThreadAllocator::newCommandBuffer(CommandBufferFlag cmdbFlags
 	ANKI_ASSERT(out && out->m_refcount.load() == 0);
 	ANKI_ASSERT(out->m_flags == cmdbFlags);
 	outPtr.reset(out);
-	return Error::NONE;
+	return Error::kNone;
 }
 
 void CommandBufferThreadAllocator::deleteCommandBuffer(MicroCommandBuffer* ptr)
 {
 	ANKI_ASSERT(ptr);
 
-	const Bool secondLevel = !!(ptr->m_flags & CommandBufferFlag::SECOND_LEVEL);
-	const Bool smallBatch = !!(ptr->m_flags & CommandBufferFlag::SMALL_BATCH);
+	const Bool secondLevel = !!(ptr->m_flags & CommandBufferFlag::kSecondLevel);
+	const Bool smallBatch = !!(ptr->m_flags & CommandBufferFlag::kSmallBatch);
 
 	m_recyclers[secondLevel][smallBatch][ptr->m_queue].recycle(ptr);
 }
@@ -179,7 +179,7 @@ Error CommandBufferFactory::init(GrAllocator<U8> alloc, VkDevice dev, const Vulk
 	m_alloc = alloc;
 	m_dev = dev;
 	m_queueFamilies = queueFamilies;
-	return Error::NONE;
+	return Error::kNone;
 }
 
 void CommandBufferFactory::destroy()
@@ -266,7 +266,7 @@ Error CommandBufferFactory::newCommandBuffer(ThreadId tid, CommandBufferFlag cmd
 	ANKI_ASSERT(alloc->m_tid == tid);
 	ANKI_CHECK(alloc->newCommandBuffer(cmdbFlags, ptr));
 
-	return Error::NONE;
+	return Error::kNone;
 }
 
 } // end namespace anki

AnKi/Gr/Vulkan/CommandBufferFactory.h

@@ -50,7 +50,7 @@ public:
 
 	void setFence(MicroFencePtr& fence)
 	{
-		ANKI_ASSERT(!(m_flags & CommandBufferFlag::SECOND_LEVEL));
+		ANKI_ASSERT(!(m_flags & CommandBufferFlag::kSecondLevel));
 		ANKI_ASSERT(!m_fence.isCreated());
 		m_fence = fence;
 	}
@@ -82,13 +82,13 @@ public:
 	template<typename T>
 	void pushObjectRef(const GrObjectPtrT<T>& x)
 	{
-		pushToArray(m_objectRefs[T::CLASS_TYPE], x.get());
+		pushToArray(m_objectRefs[T::kClassType], x.get());
 	}
 
 	template<typename T>
 	void pushObjectRef(T* x)
 	{
-		pushToArray(m_objectRefs[T::CLASS_TYPE], x);
+		pushToArray(m_objectRefs[T::kClassType], x);
 	}
 
 	CommandBufferFlag getFlags() const
@@ -98,25 +98,25 @@ public:
 
 	VulkanQueueType getVulkanQueueType() const
 	{
-		ANKI_ASSERT(m_queue != VulkanQueueType::COUNT);
+		ANKI_ASSERT(m_queue != VulkanQueueType::kCount);
 		return m_queue;
 	}
 
 private:
-	static constexpr U32 MAX_REF_OBJECT_SEARCH = 16;
+	static constexpr U32 kMaxRefObjectSearch = 16;
 
 	StackAllocator<U8> m_fastAlloc;
 	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;
+	CommandBufferFlag m_flags = CommandBufferFlag::kNone;
+	VulkanQueueType m_queue = VulkanQueueType::kCount;
 
 	void reset();
 
@@ -125,9 +125,9 @@ private:
 		ANKI_ASSERT(grobj);
 
 		// Search the temp cache to avoid setting the ref again
-		if(arr.getSize() >= MAX_REF_OBJECT_SEARCH)
+		if(arr.getSize() >= kMaxRefObjectSearch)
 		{
-			for(U32 i = arr.getSize() - MAX_REF_OBJECT_SEARCH; i < arr.getSize(); ++i)
+			for(U32 i = arr.getSize() - kMaxRefObjectSearch; i < arr.getSize(); ++i)
 			{
 				if(arr[i].get() == grobj)
 				{
@@ -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.