Update clang-format and change the formatting a bit

.clang-format

@@ -5,8 +5,8 @@ AccessModifierOffset: -4
 AlignAfterOpenBracket: DontAlign
 AlignConsecutiveAssignments: false
 AlignConsecutiveDeclarations: false
-AlignEscapedNewlinesLeft: true
-AlignOperands:   false
+AlignEscapedNewlines: DontAlign
+AlignOperands:   true
 AlignTrailingComments: false
 AllowAllParametersOfDeclarationOnNextLine: true
 AllowShortBlocksOnASingleLine: false
@@ -29,16 +29,24 @@ BraceWrapping:
   AfterObjCDeclaration: true
   AfterStruct:     true
   AfterUnion:      true
+  AfterExternBlock: true
   BeforeCatch:     true
   BeforeElse:      true
   IndentBraces:    false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
 BreakBeforeBinaryOperators: NonAssignment
 BreakBeforeBraces: Custom
+BreakBeforeInheritanceComma: false
 BreakBeforeTernaryOperators: true
 BreakConstructorInitializersBeforeComma: true
+BreakConstructorInitializers: BeforeColon
+BreakAfterJavaFieldAnnotations: false
 BreakStringLiterals: true
 ColumnLimit:     120
 CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces: false
 ConstructorInitializerAllOnOneLineOrOnePerLine: false
 ConstructorInitializerIndentWidth: 4
 ContinuationIndentWidth: 4
@@ -46,16 +54,22 @@ Cpp11BracedListStyle: true
 DerivePointerAlignment: false
 DisableFormat:   false
 ExperimentalAutoDetectBinPacking: false
-ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
-IncludeCategories:
+FixNamespaceComments: false
+ForEachMacros:   
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IncludeBlocks:   Preserve
+IncludeCategories: 
   - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
     Priority:        2
-  - Regex:           '^(<|"(gtest|isl|json)/)'
+  - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
     Priority:        3
-  - Regex:           '.\*'
+  - Regex:           '.*'
     Priority:        1
-IncludeIsMainRegex: '$'
+IncludeIsMainRegex: '(Test)?$'
 IndentCaseLabels: false
+IndentPPDirectives: AfterHash
 IndentWidth:     4
 IndentWrappedFunctionNames: false
 JavaScriptQuotes: Leave
@@ -65,9 +79,11 @@ MacroBlockBegin: ''
 MacroBlockEnd:   ''
 MaxEmptyLinesToKeep: 1
 NamespaceIndentation: None
+ObjCBinPackProtocolList: Auto
 ObjCBlockIndentWidth: 2
 ObjCSpaceAfterProperty: false
 ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 2
 PenaltyBreakBeforeFirstCallParameter: 19
 PenaltyBreakComment: 300
 PenaltyBreakFirstLessLess: 120
@@ -77,6 +93,7 @@ PenaltyReturnTypeOnItsOwnLine: 60
 PointerAlignment: Left
 ReflowComments:  true
 SortIncludes:    true
+SortUsingDeclarations: false
 SpaceAfterCStyleCast: false
 SpaceAfterTemplateKeyword: false
 SpaceBeforeAssignmentOperators: true
@@ -93,3 +110,4 @@ TabWidth:        4
 UseTab:          Always
 ...
 
+

sandbox/Main.cpp

@@ -65,8 +65,8 @@ Error MyApp::init(int argc, char* argv[])
 	ANKI_CHECK(resources.loadResource(argv[2], script));
 	ANKI_CHECK(getScriptManager().evalString(script->getSource()));
 
-// ANKI_CHECK(renderer.getOffscreenRenderer().getFinalComposite().loadColorGradingTexture(
-//	"textures/color_gradient_luts/forge_lut.ankitex"));
+	// ANKI_CHECK(renderer.getOffscreenRenderer().getFinalComposite().loadColorGradingTexture(
+	//	"textures/color_gradient_luts/forge_lut.ankitex"));
 
 #if PLAYER
 	SceneGraph& scene = getSceneGraph();

shaders/ClusterLightCommon.glsl

@@ -74,19 +74,19 @@ layout(ANKI_UBO_BINDING(LIGHT_SET, LIGHT_UBO_BINDING), std140, row_major) unifor
 	LightingUniforms u_lightingUniforms;
 };
 
-#define u_near readFirstInvocationARB(u_lightingUniforms.rendererSizeTimeNear.w)
-#define u_far readFirstInvocationARB(u_lightingUniforms.cameraPosFar.w)
-#define u_clusterCountX readFirstInvocationARB(u_lightingUniforms.tileCount.x)
-#define u_clusterCountY readFirstInvocationARB(u_lightingUniforms.tileCount.y)
-#define u_clustererMagic u_lightingUniforms.clustererMagicValues
-#define u_time readFirstInvocationARB(u_lightingUniforms.rendererSizeTimeNear.z)
-#define u_unprojectionParams readFirstInvocationARB(u_lightingUniforms.projectionParams)
-#define u_invViewMat u_lightingUniforms.invViewMat
-#define u_invProjMat u_lightingUniforms.invProjMat
-#define u_invViewProjMat u_lightingUniforms.invViewProjMat
-#define u_prevViewProjMat u_lightingUniforms.prevViewProjMat
-#define u_cameraPos u_lightingUniforms.cameraPosFar.xyz
-#define u_rendererSize u_lightingUniforms.rendererSizeTimeNear.xy
+#	define u_near readFirstInvocationARB(u_lightingUniforms.rendererSizeTimeNear.w)
+#	define u_far readFirstInvocationARB(u_lightingUniforms.cameraPosFar.w)
+#	define u_clusterCountX readFirstInvocationARB(u_lightingUniforms.tileCount.x)
+#	define u_clusterCountY readFirstInvocationARB(u_lightingUniforms.tileCount.y)
+#	define u_clustererMagic u_lightingUniforms.clustererMagicValues
+#	define u_time readFirstInvocationARB(u_lightingUniforms.rendererSizeTimeNear.z)
+#	define u_unprojectionParams readFirstInvocationARB(u_lightingUniforms.projectionParams)
+#	define u_invViewMat u_lightingUniforms.invViewMat
+#	define u_invProjMat u_lightingUniforms.invProjMat
+#	define u_invViewProjMat u_lightingUniforms.invViewProjMat
+#	define u_prevViewProjMat u_lightingUniforms.prevViewProjMat
+#	define u_cameraPos u_lightingUniforms.cameraPosFar.xyz
+#	define u_rendererSize u_lightingUniforms.rendererSizeTimeNear.xy
 
 #else
 const uint _NEXT_UBO_BINDING = LIGHT_UBO_BINDING;

shaders/Common.glsl

@@ -10,18 +10,18 @@
 
 // WORKAROUND
 #if defined(ANKI_VENDOR_NVIDIA)
-#define NVIDIA_LINK_ERROR_WORKAROUND 1
+#	define NVIDIA_LINK_ERROR_WORKAROUND 1
 #else
-#define NVIDIA_LINK_ERROR_WORKAROUND 0
+#	define NVIDIA_LINK_ERROR_WORKAROUND 0
 #endif
 
 // Default precision
 #ifndef DEFAULT_FLOAT_PRECISION
-#define DEFAULT_FLOAT_PRECISION highp
+#	define DEFAULT_FLOAT_PRECISION highp
 #endif
 
 #ifndef DEFAULT_INT_PRECISION
-#define DEFAULT_INT_PRECISION highp
+#	define DEFAULT_INT_PRECISION highp
 #endif
 
 // Constants
@@ -58,7 +58,7 @@ const uint UBO_MAX_SIZE = 16384u;
 
 // Other
 #if !defined(ANKI_ARB_SHADER_BALLOT)
-#define readFirstInvocationARB(x_) (x_)
+#	define readFirstInvocationARB(x_) (x_)
 #endif
 
 #define CALC_BITANGENT_IN_VERT 1

shaders/Functions.glsl

@@ -70,7 +70,7 @@ vec4 textureCatmullRom4Samples(sampler2D tex, vec2 uv, vec2 texSize)
 	w.xz *= halff.x * halff.y > 0.0 ? 1.0 : -1.0;
 
 	return (texture(tex, pos.xy) * w.x + texture(tex, pos.zy) * w.z) * w.y
-		+ (texture(tex, pos.xw) * w.x + texture(tex, pos.zw) * w.z) * w.w;
+		   + (texture(tex, pos.xw) * w.x + texture(tex, pos.zw) * w.z) * w.w;
 }
 
 float rand(vec2 n)
@@ -290,7 +290,7 @@ vec3 readErosion(sampler2D tex, vec2 uv)
 {
 	vec3 minValue = textureLod(tex, uv, 0.0).rgb;
 
-#define ANKI_EROSION(x, y)                                  \
+#define ANKI_EROSION(x, y) \
 	col2 = textureLodOffset(tex, uv, 0.0, ivec2(x, y)).rgb; \
 	minValue = min(col2, minValue);
 

shaders/GBufferCommonFrag.glsl

@@ -16,9 +16,9 @@
 layout(location = 0) in highp vec2 in_uv;
 layout(location = 1) in mediump vec3 in_normal;
 layout(location = 2) in mediump vec4 in_tangent;
-#if CALC_BITANGENT_IN_VERT
+#	if CALC_BITANGENT_IN_VERT
 layout(location = 3) in mediump vec3 in_bitangent;
-#endif
+#	endif
 layout(location = 4) in mediump float in_distFromTheCamera; // Parallax
 layout(location = 5) in mediump vec3 in_eyeTangentSpace; // Parallax
 layout(location = 6) in mediump vec3 in_normalTangentSpace; // Parallax
@@ -45,11 +45,11 @@ vec3 readNormalFromTexture(sampler2D map, highp vec2 texCoords)
 
 	vec3 n = normalize(in_normal);
 	vec3 t = normalize(in_tangent.xyz);
-#if CALC_BITANGENT_IN_VERT
+#	if CALC_BITANGENT_IN_VERT
 	vec3 b = normalize(in_bitangent.xyz);
-#else
+#	else
 	vec3 b = cross(n, t) * in_tangent.w;
-#endif
+#	endif
 
 	mat3 tbnMat = mat3(t, b, n);
 

shaders/GBufferCommonTesse.glsl

@@ -98,8 +98,8 @@ void tessellatePNPositionNormalTangentTexCoord(in mat4 mvp, in mat3 normalMat)
 	vec3 pos300 = IN_POS3(2);
 
 	vec3 pos = pos300 * wPow3 + pos030 * uPow3 + pos003 * vPow3 + pnPatch.pos210 * 3.0 * wPow2 * u
-		+ pnPatch.pos120 * 3.0 * w * uPow2 + pnPatch.pos201 * 3.0 * wPow2 * v + pnPatch.pos021 * 3.0 * uPow2 * v
-		+ pnPatch.pos102 * 3.0 * w * vPow2 + pnPatch.pos012 * 3.0 * u * vPow2 + pnPatch.pos111 * 6.0 * w * u * v;
+			   + pnPatch.pos120 * 3.0 * w * uPow2 + pnPatch.pos201 * 3.0 * wPow2 * v + pnPatch.pos021 * 3.0 * uPow2 * v
+			   + pnPatch.pos102 * 3.0 * w * vPow2 + pnPatch.pos012 * 3.0 * u * vPow2 + pnPatch.pos111 * 6.0 * w * u * v;
 
 	gl_Position = mvp * vec4(pos, 1.0);
 }
@@ -128,8 +128,8 @@ void tessellatePhongPositionNormalTangentTexCoord(in mat4 mvp, in mat3 normalMat
 
 	// phong tesselated pos
 	vec3 phongPos = tc2[0] * inpos[0] + tc2[1] * inpos[1] + tc2[2] * inpos[2]
-		+ gl_TessCoord[0] * gl_TessCoord[1] * termIJ + gl_TessCoord[1] * gl_TessCoord[2] * termJK
-		+ gl_TessCoord[2] * gl_TessCoord[0] * termIK;
+					+ gl_TessCoord[0] * gl_TessCoord[1] * termIJ + gl_TessCoord[1] * gl_TessCoord[2] * termJK
+					+ gl_TessCoord[2] * gl_TessCoord[0] * termIK;
 
 	float tessAlpha = 1.0;
 	vec3 finalPos = (1.0 - tessAlpha) * barPos + tessAlpha * phongPos;

shaders/GBufferCommonVert.glsl

@@ -45,9 +45,9 @@ out gl_PerVertex
 layout(location = 0) out highp vec2 out_uv;
 layout(location = 1) out mediump vec3 out_normal;
 layout(location = 2) out mediump vec4 out_tangent;
-#if CALC_BITANGENT_IN_VERT
+#	if CALC_BITANGENT_IN_VERT
 layout(location = 3) out mediump vec3 out_bitangent;
-#endif
+#	endif
 layout(location = 4) out mediump float out_distFromTheCamera; // Parallax
 layout(location = 5) out mediump vec3 out_eyeTangentSpace; // Parallax
 layout(location = 6) out mediump vec3 out_normalTangentSpace; // Parallax
@@ -78,9 +78,9 @@ void positionUvNormalTangent(mat4 mvp, mat3 rotationMat)
 	out_tangent.xyz = rotationMat * g_tangent.xyz;
 	out_tangent.w = g_tangent.w;
 
-#if CALC_BITANGENT_IN_VERT
+#	if CALC_BITANGENT_IN_VERT
 	out_bitangent = cross(out_normal, out_tangent.xyz) * out_tangent.w;
-#endif
+#	endif
 }
 #endif // PASS == PASS_GB_FS
 
@@ -118,18 +118,18 @@ void skinning()
 			float boneWeight = in_boneWeights[i];
 
 			position += (u_boneTransforms[boneIdx] * vec4(g_position * boneWeight, 1.0)).xyz;
-#if PASS == PASS_GB_FS
+#	if PASS == PASS_GB_FS
 			normal += (u_boneTransforms[boneIdx] * vec4(g_normal * boneWeight, 0.0)).xyz;
 			tangent += (u_boneTransforms[boneIdx] * vec4(g_tangent.xyz * boneWeight, 0.0)).xyz;
-#endif
+#	endif
 		}
 	}
 
 	g_position = position;
-#if PASS == PASS_GB_FS
+#	if PASS == PASS_GB_FS
 	g_tangent.xyz = tangent;
 	g_normal = normal;
-#endif
+#	endif
 }
 #endif
 

shaders/TonemappingResources.glsl

@@ -11,15 +11,15 @@
 #include "shaders/Common.glsl"
 
 #ifndef TONEMAPPING_SET
-#define TONEMAPPING_SET 0
+#	define TONEMAPPING_SET 0
 #endif
 
 #ifndef TONEMAPPING_BINDING
-#define TONEMAPPING_BINDING 0
+#	define TONEMAPPING_BINDING 0
 #endif
 
 #ifndef TONEMAPPING_RESOURCE_AS_BUFFER
-#define TONEMAPPING_RESOURCE_AS_BUFFER 0
+#	define TONEMAPPING_RESOURCE_AS_BUFFER 0
 #endif
 
 #if TONEMAPPING_RESOURCE_AS_BUFFER

src/anki/core/App.cpp

@@ -26,7 +26,7 @@
 #include <anki/ui/UiManager.h>
 
 #if ANKI_OS == ANKI_OS_ANDROID
-#include <android_native_app_glue.h>
+#	include <android_native_app_glue.h>
 #endif
 
 namespace anki
@@ -678,8 +678,9 @@ void App::injectStatsUiElement(DynamicArrayAuto<UiQueueElement>& newUiElementArr
 		}
 
 		newUiElementArr[count].m_userData = m_statsUi.get();
-		newUiElementArr[count].m_drawCallback = [](
-			CanvasPtr& canvas, void* userData) -> void { static_cast<StatsUi*>(userData)->build(canvas); };
+		newUiElementArr[count].m_drawCallback = [](CanvasPtr& canvas, void* userData) -> void {
+			static_cast<StatsUi*>(userData)->build(canvas);
+		};
 
 		rqueue.m_uis = newUiElementArr;
 	}

src/anki/core/App.h

@@ -11,7 +11,7 @@
 #include <anki/util/Ptr.h>
 #include <anki/ui/UiImmediateModeBuilder.h>
 #if ANKI_OS == ANKI_OS_ANDROID
-#include <android_native_app_glue.h>
+#	include <android_native_app_glue.h>
 #endif
 
 namespace anki

src/anki/core/NativeWindowSdl.cpp

@@ -6,7 +6,7 @@
 #include <anki/core/NativeWindowSdl.h>
 #include <anki/util/Logger.h>
 #if ANKI_GR_BACKEND == ANKI_GR_BACKEND_VULKAN
-#include <SDL_vulkan.h>
+#	include <SDL_vulkan.h>
 #endif
 
 namespace anki

src/anki/core/Trace.cpp

@@ -72,11 +72,11 @@ static Array<const char*, U(TraceCounterType::COUNT)> counterNames = {{"GR_DRAWC
 	"STAGING_UNIFORMS_SIZE",
 	"STAGING_STORAGE_SIZE"}};
 
-#define ANKI_TRACE_FILE_ERROR()                         \
-	if(err)                                             \
-	{                                                   \
-		ANKI_CORE_LOGE("Error writing the trace file"); \
-	}
+#	define ANKI_TRACE_FILE_ERROR() \
+		if(err) \
+		{ \
+			ANKI_CORE_LOGE("Error writing the trace file"); \
+		}
 
 const U MAX_EVENTS_DEPTH = 20;
 thread_local Second g_traceEventStartTime[MAX_EVENTS_DEPTH];

src/anki/core/Trace.h

@@ -172,20 +172,20 @@ using TraceManagerSingleton = Singleton<TraceManager>;
 /// @name Trace macros.
 /// @{
 #if ANKI_ENABLE_TRACE
-#define ANKI_TRACE_START_EVENT(name_) TraceManagerSingleton::get().startEvent()
-#define ANKI_TRACE_STOP_EVENT(name_) TraceManagerSingleton::get().stopEvent(TraceEventType::name_)
-#define ANKI_TRACE_SCOPED_EVENT(name_) \
-	ScopedTraceManagerEvent _tse##name_(&TraceManagerSingleton::get(), TraceEventType::name_)
-#define ANKI_TRACE_INC_COUNTER(name_, val_) TraceManagerSingleton::get().incCounter(TraceCounterType::name_, val_)
-#define ANKI_TRACE_START_FRAME() TraceManagerSingleton::get().startFrame()
-#define ANKI_TRACE_STOP_FRAME() TraceManagerSingleton::get().stopFrame()
+#	define ANKI_TRACE_START_EVENT(name_) TraceManagerSingleton::get().startEvent()
+#	define ANKI_TRACE_STOP_EVENT(name_) TraceManagerSingleton::get().stopEvent(TraceEventType::name_)
+#	define ANKI_TRACE_SCOPED_EVENT(name_) \
+		ScopedTraceManagerEvent _tse##name_(&TraceManagerSingleton::get(), TraceEventType::name_)
+#	define ANKI_TRACE_INC_COUNTER(name_, val_) TraceManagerSingleton::get().incCounter(TraceCounterType::name_, val_)
+#	define ANKI_TRACE_START_FRAME() TraceManagerSingleton::get().startFrame()
+#	define ANKI_TRACE_STOP_FRAME() TraceManagerSingleton::get().stopFrame()
 #else
-#define ANKI_TRACE_START_EVENT(name_) ((void)0)
-#define ANKI_TRACE_STOP_EVENT(name_) ((void)0)
-#define ANKI_TRACE_SCOPED_EVENT(name_) ((void)0)
-#define ANKI_TRACE_INC_COUNTER(name_, val_) ((void)0)
-#define ANKI_TRACE_START_FRAME() ((void)0)
-#define ANKI_TRACE_STOP_FRAME() ((void)0)
+#	define ANKI_TRACE_START_EVENT(name_) ((void)0)
+#	define ANKI_TRACE_STOP_EVENT(name_) ((void)0)
+#	define ANKI_TRACE_SCOPED_EVENT(name_) ((void)0)
+#	define ANKI_TRACE_INC_COUNTER(name_, val_) ((void)0)
+#	define ANKI_TRACE_START_FRAME() ((void)0)
+#	define ANKI_TRACE_STOP_FRAME() ((void)0)
 #endif
 /// @}
 

src/anki/gr/CommandBuffer.h

@@ -41,7 +41,7 @@ public:
 	Bool operator==(const DrawElementsIndirectInfo& b) const
 	{
 		return m_count == b.m_count && m_instanceCount == b.m_instanceCount && m_firstIndex == b.m_firstIndex
-			&& m_baseVertex == b.m_baseVertex && m_baseInstance == b.m_baseInstance;
+			   && m_baseVertex == b.m_baseVertex && m_baseInstance == b.m_baseInstance;
 	}
 
 	Bool operator!=(const DrawElementsIndirectInfo& b) const
@@ -74,7 +74,7 @@ public:
 	Bool operator==(const DrawArraysIndirectInfo& b) const
 	{
 		return m_count == b.m_count && m_instanceCount == b.m_instanceCount && m_first == b.m_first
-			&& m_baseInstance == b.m_baseInstance;
+			   && m_baseInstance == b.m_baseInstance;
 	}
 
 	Bool operator!=(const DrawArraysIndirectInfo& b) const

src/anki/gr/Common.h

@@ -50,7 +50,8 @@ const U MAX_IMAGE_BINDINGS = 4;
 const U MAX_TEXTURE_BUFFER_BINDINGS = 4;
 
 const U MAX_BINDINGS_PER_DESCRIPTOR_SET = MAX_TEXTURE_BINDINGS + MAX_UNIFORM_BUFFER_BINDINGS
-	+ MAX_STORAGE_BUFFER_BINDINGS + MAX_IMAGE_BINDINGS + MAX_TEXTURE_BUFFER_BINDINGS;
+										  + MAX_STORAGE_BUFFER_BINDINGS + MAX_IMAGE_BINDINGS
+										  + MAX_TEXTURE_BUFFER_BINDINGS;
 
 const U MAX_FRAMES_IN_FLIGHT = 3; ///< Triple buffering.
 const U MAX_DESCRIPTOR_SETS = 2; ///< Groups that can be bound at the same time.
@@ -65,8 +66,8 @@ template<typename T>
 using GrObjectPtr = IntrusivePtr<T, DefaultPtrDeleter<T>>;
 
 #define ANKI_GR_CLASS(x_) \
-	class x_##Impl;       \
-	class x_;             \
+	class x_##Impl; \
+	class x_; \
 	using x_##Ptr = GrObjectPtr<x_>;
 
 ANKI_GR_CLASS(Buffer)
@@ -83,10 +84,10 @@ ANKI_GR_CLASS(RenderGraph)
 
 #undef ANKI_GR_CLASS
 
-#define ANKI_GR_OBJECT           \
-	friend class GrManager;      \
+#define ANKI_GR_OBJECT \
+	friend class GrManager; \
 	template<typename, typename> \
-	friend class IntrusivePtr;   \
+	friend class IntrusivePtr; \
 	template<typename, typename> \
 	friend class GenericPoolAllocator;
 

src/anki/gr/Enums.h

@@ -219,8 +219,7 @@ enum class TextureUsageBit : U16
 	SAMPLED_FRAGMENT = 1 << 4,
 	SAMPLED_COMPUTE = 1 << 5,
 	SAMPLED_ALL_GRAPHICS = SAMPLED_VERTEX | SAMPLED_TESSELLATION_CONTROL | SAMPLED_TESSELLATION_EVALUATION
-		| SAMPLED_GEOMETRY
-		| SAMPLED_FRAGMENT,
+						   | SAMPLED_GEOMETRY | SAMPLED_FRAGMENT,
 	SAMPLED_ALL = SAMPLED_ALL_GRAPHICS | SAMPLED_COMPUTE,
 	/// @}
 
@@ -402,8 +401,7 @@ enum class BufferUsageBit : U64
 	UNIFORM_FRAGMENT = 1 << 4,
 	UNIFORM_COMPUTE = 1 << 5,
 	UNIFORM_ALL_GRAPHICS = UNIFORM_VERTEX | UNIFORM_TESSELLATION_EVALUATION | UNIFORM_TESSELLATION_CONTROL
-		| UNIFORM_GEOMETRY
-		| UNIFORM_FRAGMENT,
+						   | UNIFORM_GEOMETRY | UNIFORM_FRAGMENT,
 	UNIFORM_ALL = UNIFORM_ALL_GRAPHICS | UNIFORM_COMPUTE,
 
 	STORAGE_VERTEX_READ = 1 << 6,
@@ -426,13 +424,9 @@ enum class BufferUsageBit : U64
 	STORAGE_COMPUTE_WRITE = 1 << 17,
 	STORAGE_COMPUTE_READ_WRITE = STORAGE_COMPUTE_READ | STORAGE_COMPUTE_WRITE,
 	STORAGE_ALL_GRAPHICS = STORAGE_VERTEX_READ | STORAGE_VERTEX_WRITE | STORAGE_TESSELLATION_EVALUATION_READ
-		| STORAGE_TESSELLATION_EVALUATION_WRITE
-		| STORAGE_TESSELLATION_CONTROL_READ
-		| STORAGE_TESSELLATION_CONTROL_WRITE
-		| STORAGE_GEOMETRY_READ
-		| STORAGE_GEOMETRY_WRITE
-		| STORAGE_FRAGMENT_READ
-		| STORAGE_FRAGMENT_WRITE,
+						   | STORAGE_TESSELLATION_EVALUATION_WRITE | STORAGE_TESSELLATION_CONTROL_READ
+						   | STORAGE_TESSELLATION_CONTROL_WRITE | STORAGE_GEOMETRY_READ | STORAGE_GEOMETRY_WRITE
+						   | STORAGE_FRAGMENT_READ | STORAGE_FRAGMENT_WRITE,
 	STORAGE_ALL = STORAGE_ALL_GRAPHICS | STORAGE_COMPUTE_READ_WRITE,
 
 	TEXTURE_VERTEX_READ = 1 << 18,
@@ -442,9 +436,7 @@ enum class BufferUsageBit : U64
 	TEXTURE_FRAGMENT_READ = 1 << 22,
 	TEXTURE_COMPUTE_READ = 1 << 23,
 	TEXTURE_ALL = TEXTURE_VERTEX_READ | TEXTURE_TESSELLATION_EVALUATION_READ | TEXTURE_TESSELLATION_CONTROL_READ
-		| TEXTURE_GEOMETRY_READ
-		| TEXTURE_FRAGMENT_READ
-		| TEXTURE_COMPUTE_READ,
+				  | TEXTURE_GEOMETRY_READ | TEXTURE_FRAGMENT_READ | TEXTURE_COMPUTE_READ,
 
 	INDEX = 1 << 24,
 	VERTEX = 1 << 25,

src/anki/gr/RenderGraph.cpp

@@ -435,7 +435,7 @@ Bool RenderGraph::overlappingDependency(const RenderPassDependency& a, const Ren
 	if(isTexture)
 	{
 		return a.m_texture.m_handle == b.m_texture.m_handle
-			&& overlappingTextureSubresource(a.m_texture.m_subresource, b.m_texture.m_subresource);
+			   && overlappingTextureSubresource(a.m_texture.m_subresource, b.m_texture.m_subresource);
 	}
 	else
 	{
@@ -1059,11 +1059,11 @@ StringAuto RenderGraph::textureUsageToStr(StackAllocator<U8>& alloc, TextureUsag
 {
 	StringListAuto slist(alloc);
 
-#define ANKI_TEX_USAGE(u)                \
-	if(!!(usage & TextureUsageBit::u))   \
-	{                                    \
-		slist.pushBackSprintf("%s", #u); \
-	}
+#	define ANKI_TEX_USAGE(u) \
+		if(!!(usage & TextureUsageBit::u)) \
+		{ \
+			slist.pushBackSprintf("%s", #u); \
+		}
 
 	ANKI_TEX_USAGE(SAMPLED_VERTEX);
 	ANKI_TEX_USAGE(SAMPLED_TESSELLATION_CONTROL);
@@ -1084,7 +1084,7 @@ StringAuto RenderGraph::textureUsageToStr(StackAllocator<U8>& alloc, TextureUsag
 		slist.pushBackSprintf("NONE");
 	}
 
-#undef ANKI_TEX_USAGE
+#	undef ANKI_TEX_USAGE
 
 	ANKI_ASSERT(!slist.isEmpty());
 	StringAuto str(alloc);
@@ -1096,11 +1096,11 @@ StringAuto RenderGraph::bufferUsageToStr(StackAllocator<U8>& alloc, BufferUsageB
 {
 	StringListAuto slist(alloc);
 
-#define ANKI_BUFF_USAGE(u)               \
-	if(!!(usage & BufferUsageBit::u))    \
-	{                                    \
-		slist.pushBackSprintf("%s", #u); \
-	}
+#	define ANKI_BUFF_USAGE(u) \
+		if(!!(usage & BufferUsageBit::u)) \
+		{ \
+			slist.pushBackSprintf("%s", #u); \
+		}
 
 	ANKI_BUFF_USAGE(UNIFORM_VERTEX);
 	ANKI_BUFF_USAGE(UNIFORM_TESSELLATION_EVALUATION);
@@ -1140,7 +1140,7 @@ StringAuto RenderGraph::bufferUsageToStr(StackAllocator<U8>& alloc, BufferUsageB
 		slist.pushBackSprintf("NONE");
 	}
 
-#undef ANKI_BUFF_USAGE
+#	undef ANKI_BUFF_USAGE
 
 	ANKI_ASSERT(!slist.isEmpty());
 	StringAuto str(alloc);
@@ -1190,7 +1190,7 @@ Error RenderGraph::dumpDependencyDotFile(
 		}
 	}
 
-#if 0
+#	if 0
 	// Color the resources
 	slist.pushBackSprintf("subgraph cluster_0 {\n");
 	for(U rtIdx = 0; rtIdx < descr.m_renderTargets.getSize(); ++rtIdx)
@@ -1198,7 +1198,7 @@ Error RenderGraph::dumpDependencyDotFile(
 		slist.pushBackSprintf("\t\"%s\"[color=%s];\n", &descr.m_renderTargets[rtIdx].m_name[0], COLORS[rtIdx % 6]);
 	}
 	slist.pushBackSprintf("}\n");
-#endif
+#	endif
 
 	// Barriers
 	// slist.pushBackSprintf("subgraph cluster_1 {\n");

src/anki/gr/Sampler.h

@@ -38,7 +38,8 @@ public:
 		const U8* const first = reinterpret_cast<const U8* const>(&m_minLod);
 		const U8* const last = reinterpret_cast<const U8* const>(&m_repeat) + sizeof(m_repeat);
 		const U size = last - first;
-		ANKI_ASSERT(size
+		ANKI_ASSERT(
+			size
 			== sizeof(F32) * 2 + sizeof(SamplingFilter) * 2 + sizeof(CompareOperation) + sizeof(I8) + sizeof(Bool8));
 		return anki::computeHash(first, size);
 	}

src/anki/gr/Shader.h

@@ -19,11 +19,11 @@ namespace anki
 template<typename T>
 ShaderVariableDataType getShaderVariableTypeFromTypename();
 
-#define ANKI_SPECIALIZE_SHADER_VAR_TYPE_GET(typename_, type_)                    \
-	template<>                                                                   \
+#define ANKI_SPECIALIZE_SHADER_VAR_TYPE_GET(typename_, type_) \
+	template<> \
 	inline ShaderVariableDataType getShaderVariableTypeFromTypename<typename_>() \
-	{                                                                            \
-		return ShaderVariableDataType::type_;                                    \
+	{ \
+		return ShaderVariableDataType::type_; \
 	}
 
 ANKI_SPECIALIZE_SHADER_VAR_TYPE_GET(I32, INT)

src/anki/gr/ShaderProgram.h

@@ -45,8 +45,8 @@ public:
 		if(m_shaders[ShaderType::COMPUTE])
 		{
 			invalid |= m_shaders[ShaderType::VERTEX] || m_shaders[ShaderType::TESSELLATION_CONTROL]
-				|| m_shaders[ShaderType::TESSELLATION_EVALUATION] || m_shaders[ShaderType::GEOMETRY]
-				|| m_shaders[ShaderType::FRAGMENT];
+					   || m_shaders[ShaderType::TESSELLATION_EVALUATION] || m_shaders[ShaderType::GEOMETRY]
+					   || m_shaders[ShaderType::FRAGMENT];
 		}
 		else
 		{

src/anki/gr/Texture.h

@@ -46,20 +46,20 @@ public:
 		const U8* const last = reinterpret_cast<const U8* const>(&m_samples) + sizeof(m_samples);
 		const U size = last - first;
 		ANKI_ASSERT(size
-			== sizeof(U32) * 4 + sizeof(TextureUsageBit) * 2 + sizeof(TextureType) + sizeof(U8) + sizeof(PixelFormat)
-				+ sizeof(U8));
+					== sizeof(U32) * 4 + sizeof(TextureUsageBit) * 2 + sizeof(TextureType) + sizeof(U8)
+						   + sizeof(PixelFormat) + sizeof(U8));
 		return anki::computeHash(first, size);
 	}
 
 	Bool isValid() const
 	{
 #define ANKI_CHECK_VAL_VALIDITY(x) \
-	do                             \
-	{                              \
-		if(!(x))                   \
-		{                          \
-			return false;          \
-		}                          \
+	do \
+	{ \
+		if(!(x)) \
+		{ \
+			return false; \
+		} \
 	} while(0)
 
 		ANKI_CHECK_VAL_VALIDITY(m_usage != TextureUsageBit::NONE);
@@ -159,9 +159,9 @@ public:
 	Bool isSubresourceValid(const TextureSubresourceInfo& subresource) const
 	{
 #define ANKI_TEX_SUBRESOURCE_ASSERT(x_) \
-	if(!(x_))                           \
-	{                                   \
-		return false;                   \
+	if(!(x_)) \
+	{ \
+		return false; \
 	}
 		const TextureType type = m_texType;
 		const Bool cube = textureTypeIsCube(type);
@@ -200,8 +200,8 @@ public:
 		if(m_texType != TextureType::_3D)
 		{
 			return subresource.m_firstMipmap == 0 && subresource.m_mipmapCount == m_mipCount
-				&& subresource.m_faceCount == 1 && subresource.m_layerCount == 1
-				&& subresource.m_depthStencilAspect == m_aspect;
+				   && subresource.m_faceCount == 1 && subresource.m_layerCount == 1
+				   && subresource.m_depthStencilAspect == m_aspect;
 		}
 		else
 		{
@@ -224,8 +224,8 @@ 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;
+			   || subresource.m_depthStencilAspect == DepthStencilAspectBit::STENCIL
+			   || subresource.m_depthStencilAspect == DepthStencilAspectBit::NONE;
 	}
 
 	/// Return true if the subresource can be used in CommandBuffer::copyBufferToTextureView.
@@ -233,7 +233,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::NONE;
 	}
 
 	/// Return true if the subresource can be used as Framebuffer attachment.

src/anki/gr/TextureView.h

@@ -123,9 +123,9 @@ 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;
+			   && 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;
 	}
 
 private:

src/anki/gr/common/Misc.h

@@ -16,7 +16,7 @@ inline Bool stencilTestDisabled(StencilOperation stencilFail,
 	CompareOperation compare)
 {
 	return stencilFail == StencilOperation::KEEP && stencilPassDepthFail == StencilOperation::KEEP
-		&& stencilPassDepthPass == StencilOperation::KEEP && compare == CompareOperation::ALWAYS;
+		   && stencilPassDepthPass == StencilOperation::KEEP && compare == CompareOperation::ALWAYS;
 }
 
 inline Bool blendingDisabled(BlendFactor srcFactorRgb,
@@ -27,9 +27,9 @@ inline Bool blendingDisabled(BlendFactor srcFactorRgb,
 	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);
+						 && srcFactorA == BlendFactor::ONE && dstFactorA == BlendFactor::ZERO
+						 && (opRgb == BlendOperation::ADD || opRgb == BlendOperation::SUBTRACT)
+						 && (opA == BlendOperation::ADD || opA == BlendOperation::SUBTRACT);
 	return dontWantBlend;
 }
 

src/anki/gr/gl/CommandBufferImpl.cpp

@@ -61,7 +61,7 @@ void CommandBufferImpl::destroy()
 	}
 
 	ANKI_ASSERT(m_alloc.getMemoryPool().getUsersCount() == 1
-		&& "Someone is holding a reference to the command buffer's allocator");
+				&& "Someone is holding a reference to the command buffer's allocator");
 
 	m_alloc = CommandBufferAllocator<U8>();
 

src/anki/gr/gl/Common.h

@@ -8,17 +8,17 @@
 #include <anki/gr/Common.h>
 
 #if ANKI_GL == ANKI_GL_DESKTOP
-#if ANKI_OS == ANKI_OS_WINDOWS && !defined(GLEW_STATIC)
-#define GLEW_STATIC
-#endif
-#include <GL/glew.h>
-#if !defined(ANKI_GLEW_H)
-#error "Wrong GLEW included"
-#endif
+#	if ANKI_OS == ANKI_OS_WINDOWS && !defined(GLEW_STATIC)
+#		define GLEW_STATIC
+#	endif
+#	include <GL/glew.h>
+#	if !defined(ANKI_GLEW_H)
+#		error "Wrong GLEW included"
+#	endif
 #elif ANKI_GL == ANKI_GL_ES
-#include <GLES3/gl3.h>
+#	include <GLES3/gl3.h>
 #else
-#error "See file"
+#	error "See file"
 #endif
 
 namespace anki

src/anki/gr/gl/Error.h

@@ -21,9 +21,9 @@ namespace anki
 /// ANKI_CHECK_GL_ERROR macro
 void glConditionalCheckError(const char* file, int line, const char* func);
 
-#define ANKI_CHECK_GL_ERROR() glConditionalCheckError(ANKI_FILE, __LINE__, ANKI_FUNC)
+#	define ANKI_CHECK_GL_ERROR() glConditionalCheckError(ANKI_FILE, __LINE__, ANKI_FUNC)
 #else
-#define ANKI_CHECK_GL_ERROR() ((void)0)
+#	define ANKI_CHECK_GL_ERROR() ((void)0)
 #endif
 /// @}
 

src/anki/gr/gl/FramebufferImpl.cpp

@@ -106,10 +106,10 @@ Error FramebufferImpl::init(const FramebufferInitInfo& init)
 
 		// Misc
 		m_clearDepth = !!(viewImpl.getSubresource().m_depthStencilAspect & DepthStencilAspectBit::DEPTH)
-			&& att.m_loadOperation == AttachmentLoadOperation::CLEAR;
+					   && att.m_loadOperation == AttachmentLoadOperation::CLEAR;
 
 		m_clearStencil = !!(viewImpl.getSubresource().m_depthStencilAspect & DepthStencilAspectBit::STENCIL)
-			&& att.m_stencilLoadOperation == AttachmentLoadOperation::CLEAR;
+						 && att.m_stencilLoadOperation == AttachmentLoadOperation::CLEAR;
 	}
 
 	// Check completeness
@@ -231,8 +231,7 @@ 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
 				Bool restore = false;
 				if(state.m_colorWriteMasks[i][0] != true || state.m_colorWriteMasks[i][1] != true
-					|| state.m_colorWriteMasks[i][2] != true
-					|| state.m_colorWriteMasks[i][3] != true)
+					|| state.m_colorWriteMasks[i][2] != true || state.m_colorWriteMasks[i][3] != true)
 				{
 					glColorMaski(i, true, true, true, true);
 					restore = true;

src/anki/gr/gl/GlState.cpp

@@ -40,9 +40,9 @@ static const GlDbg gldbgseverity[] = {{GL_DEBUG_SEVERITY_LOW, "GL_DEBUG_SEVERITY
 	{GL_DEBUG_SEVERITY_MEDIUM, "GL_DEBUG_SEVERITY_MEDIUM"},
 	{GL_DEBUG_SEVERITY_HIGH, "GL_DEBUG_SEVERITY_HIGH"}};
 
-#if ANKI_OS == ANKI_OS_WINDOWS && ANKI_COMPILER != ANKI_COMPILER_MSVC
+#	if ANKI_OS == ANKI_OS_WINDOWS && ANKI_COMPILER != ANKI_COMPILER_MSVC
 __stdcall
-#endif
+#	endif
 	void
 	oglMessagesCallback(GLenum source,
 		GLenum type,

src/anki/gr/gl/GrManager.cpp

@@ -80,10 +80,10 @@ void GrManager::finish()
 	self.getRenderingThread().syncClientServer();
 }
 
-#define ANKI_SAFE_CONSTRUCT(class_)                \
+#define ANKI_SAFE_CONSTRUCT(class_) \
 	class_* out = class_::newInstance(this, init); \
-	class_##Ptr ptr(out);                          \
-	out->getRefcount().fetchSub(1);                \
+	class_##Ptr ptr(out); \
+	out->getRefcount().fetchSub(1); \
 	return ptr
 
 BufferPtr GrManager::newBuffer(const BufferInitInfo& init)

src/anki/gr/gl/GrManagerImpl.cpp

@@ -53,8 +53,8 @@ Error GrManagerImpl::init(GrManagerInitInfo& init, GrAllocator<U8> alloc)
 	// Misc
 	m_gpuVendor = m_state->m_gpu;
 	m_capabilities = !!(m_state->m_extensions & GlExtensions::ARB_SHADER_BALLOT)
-		? GpuDeviceCapabilitiesBit::SHADER_BALLOT
-		: GpuDeviceCapabilitiesBit::NONE;
+						 ? GpuDeviceCapabilitiesBit::SHADER_BALLOT
+						 : GpuDeviceCapabilitiesBit::NONE;
 
 	return Error::NONE;
 }

src/anki/gr/gl/ShaderImpl.cpp

@@ -14,7 +14,7 @@
 #define ANKI_DUMP_SHADERS ANKI_EXTRA_CHECKS
 
 #if ANKI_DUMP_SHADERS
-#include <anki/util/File.h>
+#	include <anki/util/File.h>
 #endif
 
 namespace anki

src/anki/gr/gl/StateTracker.h

@@ -201,8 +201,8 @@ public:
 		Bool enable = !stencilTestDisabled(
 			m_stencilFail[0], m_stencilPassDepthFail[0], m_stencilPassDepthPass[0], m_stencilCompare[0]);
 		enable = enable
-			|| !stencilTestDisabled(
-				   m_stencilFail[1], m_stencilPassDepthFail[1], m_stencilPassDepthPass[1], m_stencilCompare[1]);
+				 || !stencilTestDisabled(
+						m_stencilFail[1], m_stencilPassDepthFail[1], m_stencilPassDepthPass[1], m_stencilCompare[1]);
 
 		if(enable != m_stencilTestEnabled)
 		{

src/anki/gr/vulkan/BufferImpl.cpp

@@ -172,8 +172,9 @@ VkPipelineStageFlags BufferImpl::computePplineStage(BufferUsageBit usage)
 		stageMask |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
 	}
 
-	if(!!(usage & (BufferUsageBit::UNIFORM_TESSELLATION_EVALUATION
-					  | BufferUsageBit::STORAGE_TESSELLATION_EVALUATION_READ_WRITE)))
+	if(!!(usage
+		   & (BufferUsageBit::UNIFORM_TESSELLATION_EVALUATION
+				 | BufferUsageBit::STORAGE_TESSELLATION_EVALUATION_READ_WRITE)))
 	{
 		stageMask |= VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT;
 	}
@@ -202,8 +203,8 @@ VkPipelineStageFlags BufferImpl::computePplineStage(BufferUsageBit usage)
 	if(!!(usage & (BufferUsageBit::INDEX | BufferUsageBit::VERTEX)))
 	{
 		stageMask |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT | 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;
+					 | VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT
+					 | VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT | VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
 	}
 
 	if(!!(usage & BufferUsageBit::INDIRECT))
@@ -234,15 +235,15 @@ VkAccessFlags BufferImpl::computeAccessMask(BufferUsageBit usage)
 {
 	VkAccessFlags mask = 0;
 
-	const BufferUsageBit SHADER_READ = BufferUsageBit::STORAGE_VERTEX_READ
-		| BufferUsageBit::STORAGE_TESSELLATION_CONTROL_READ | BufferUsageBit::STORAGE_TESSELLATION_EVALUATION_READ
-		| BufferUsageBit::STORAGE_GEOMETRY_READ | BufferUsageBit::STORAGE_FRAGMENT_READ
-		| BufferUsageBit::STORAGE_COMPUTE_READ;
+	const BufferUsageBit SHADER_READ =
+		BufferUsageBit::STORAGE_VERTEX_READ | BufferUsageBit::STORAGE_TESSELLATION_CONTROL_READ
+		| BufferUsageBit::STORAGE_TESSELLATION_EVALUATION_READ | BufferUsageBit::STORAGE_GEOMETRY_READ
+		| BufferUsageBit::STORAGE_FRAGMENT_READ | BufferUsageBit::STORAGE_COMPUTE_READ;
 
-	const BufferUsageBit SHADER_WRITE = BufferUsageBit::STORAGE_VERTEX_WRITE
-		| BufferUsageBit::STORAGE_TESSELLATION_CONTROL_WRITE | BufferUsageBit::STORAGE_TESSELLATION_EVALUATION_WRITE
-		| BufferUsageBit::STORAGE_GEOMETRY_WRITE | BufferUsageBit::STORAGE_FRAGMENT_WRITE
-		| BufferUsageBit::STORAGE_COMPUTE_WRITE;
+	const BufferUsageBit SHADER_WRITE =
+		BufferUsageBit::STORAGE_VERTEX_WRITE | BufferUsageBit::STORAGE_TESSELLATION_CONTROL_WRITE
+		| BufferUsageBit::STORAGE_TESSELLATION_EVALUATION_WRITE | BufferUsageBit::STORAGE_GEOMETRY_WRITE
+		| BufferUsageBit::STORAGE_FRAGMENT_WRITE | BufferUsageBit::STORAGE_COMPUTE_WRITE;
 
 	if(!!(usage & BufferUsageBit::UNIFORM_ALL))
 	{

src/anki/gr/vulkan/CommandBufferImpl.cpp

@@ -468,12 +468,10 @@ void CommandBufferImpl::flushBarriers()
 
 			if(prev && prev->image == crnt.image
 				&& prev->subresourceRange.aspectMask == crnt.subresourceRange.aspectMask
-				&& prev->oldLayout == crnt.oldLayout
-				&& prev->newLayout == crnt.newLayout
-				&& prev->srcAccessMask == crnt.srcAccessMask
-				&& prev->dstAccessMask == crnt.dstAccessMask
+				&& prev->oldLayout == crnt.oldLayout && prev->newLayout == crnt.newLayout
+				&& prev->srcAccessMask == crnt.srcAccessMask && prev->dstAccessMask == crnt.dstAccessMask
 				&& prev->subresourceRange.baseMipLevel + prev->subresourceRange.levelCount
-					== crnt.subresourceRange.baseMipLevel
+					   == crnt.subresourceRange.baseMipLevel
 				&& prev->subresourceRange.baseArrayLayer == crnt.subresourceRange.baseArrayLayer
 				&& prev->subresourceRange.layerCount == crnt.subresourceRange.layerCount)
 			{
@@ -500,14 +498,12 @@ void CommandBufferImpl::flushBarriers()
 
 			if(prev && prev->image == crnt.image
 				&& prev->subresourceRange.aspectMask == crnt.subresourceRange.aspectMask
-				&& prev->oldLayout == crnt.oldLayout
-				&& prev->newLayout == crnt.newLayout
-				&& prev->srcAccessMask == crnt.srcAccessMask
-				&& prev->dstAccessMask == crnt.dstAccessMask
+				&& prev->oldLayout == crnt.oldLayout && prev->newLayout == crnt.newLayout
+				&& prev->srcAccessMask == crnt.srcAccessMask && prev->dstAccessMask == crnt.dstAccessMask
 				&& prev->subresourceRange.baseMipLevel == crnt.subresourceRange.baseMipLevel
 				&& prev->subresourceRange.levelCount == crnt.subresourceRange.levelCount
 				&& prev->subresourceRange.baseArrayLayer + prev->subresourceRange.layerCount
-					== crnt.subresourceRange.baseArrayLayer)
+					   == crnt.subresourceRange.baseArrayLayer)
 			{
 				// Can batch
 				finalImgBarriers[finalImgBarrierCount - 1].subresourceRange.layerCount +=
@@ -714,9 +710,10 @@ void CommandBufferImpl::copyBufferToTextureViewInternal(
 	else if(!!(tex.m_workarounds & TextureImplWorkaround::R8G8B8_TO_R8G8B8A8))
 	{
 		// Create a new shadow buffer
-		const PtrSize shadowSize = (is3D)
-			? computeVolumeSize(width, height, depth, PixelFormat(ComponentFormat::R8G8B8A8, TransformFormat::UNORM))
-			: computeSurfaceSize(width, height, PixelFormat(ComponentFormat::R8G8B8A8, TransformFormat::UNORM));
+		const PtrSize shadowSize =
+			(is3D) ? computeVolumeSize(
+						 width, height, depth, PixelFormat(ComponentFormat::R8G8B8A8, TransformFormat::UNORM))
+				   : computeSurfaceSize(width, height, PixelFormat(ComponentFormat::R8G8B8A8, TransformFormat::UNORM));
 		BufferPtr shadow = getManager().newBuffer(
 			BufferInitInfo(shadowSize, BufferUsageBit::TRANSFER_ALL, BufferMapAccessBit::NONE, "Workaround"));
 		const VkBuffer shadowHandle = static_cast<const BufferImpl&>(*shadow).getHandle();

src/anki/gr/vulkan/CommandBufferImpl.h

@@ -28,7 +28,7 @@ class CommandBufferInitInfo;
 /// @addtogroup vulkan
 /// @{
 
-#define ANKI_CMD(x_, t_)                        \
+#define ANKI_CMD(x_, t_) \
 	flushBatches(CommandBufferCommandType::t_); \
 	x_;
 

src/anki/gr/vulkan/CommandBufferImpl.inl.h

@@ -193,7 +193,7 @@ inline void CommandBufferImpl::setTextureVolumeBarrier(
 	if(vol.m_level > 0)
 	{
 		ANKI_ASSERT(!(nextUsage & TextureUsageBit::GENERATE_MIPMAPS)
-			&& "This transition happens inside CommandBufferImpl::generateMipmaps");
+					&& "This transition happens inside CommandBufferImpl::generateMipmaps");
 	}
 
 	const TextureImpl& impl = static_cast<const TextureImpl&>(*tex);
@@ -428,7 +428,7 @@ inline void CommandBufferImpl::pushSecondLevelCommandBuffer(CommandBufferPtr cmd
 	commandCommon();
 	ANKI_ASSERT(insideRenderPass());
 	ANKI_ASSERT(m_subpassContents == VK_SUBPASS_CONTENTS_MAX_ENUM
-		|| m_subpassContents == VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
+				|| m_subpassContents == VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
 
 	ANKI_ASSERT(static_cast<const CommandBufferImpl&>(*cmdb).m_finalized);
 
@@ -575,7 +575,7 @@ inline void CommandBufferImpl::commandCommon()
 	}
 
 	ANKI_ASSERT(Thread::getCurrentThreadId() == m_tid
-		&& "Commands must be recorder and flushed by the thread this command buffer was created");
+				&& "Commands must be recorder and flushed by the thread this command buffer was created");
 
 	ANKI_ASSERT(m_handle);
 }
@@ -730,7 +730,7 @@ inline void CommandBufferImpl::copyBufferToBuffer(
 inline Bool CommandBufferImpl::flipViewport() const
 {
 	return static_cast<const FramebufferImpl&>(*m_activeFb).isDefaultFramebuffer()
-		&& !!(getGrManagerImpl().getExtensions() & VulkanExtensions::KHR_MAINENANCE1);
+		   && !!(getGrManagerImpl().getExtensions() & VulkanExtensions::KHR_MAINENANCE1);
 }
 
 } // end namespace anki

src/anki/gr/vulkan/Common.h

@@ -8,11 +8,11 @@
 #include <anki/gr/Common.h>
 
 #if ANKI_OS == ANKI_OS_LINUX
-#define VK_USE_PLATFORM_XCB_KHR 1
+#	define VK_USE_PLATFORM_XCB_KHR 1
 #elif ANKI_OS == ANKI_OS_WINDOWS
-#define VK_USE_PLATFORM_WIN32_KHR 1
+#	define VK_USE_PLATFORM_WIN32_KHR 1
 #else
-#error TODO
+#	error TODO
 #endif
 #include <vulkan/vulkan.h>
 #include <anki/util/CleanupWindows.h> // Clean global namespace
@@ -58,26 +58,26 @@ const U DESCRIPTOR_FRAME_BUFFERING = 60 * 5; ///< How many frames worth of descr
 /// @}
 
 /// Check if a vulkan function failed. It will abort on failure.
-#define ANKI_VK_CHECKF(x)                                                       \
-	do                                                                          \
-	{                                                                           \
-		VkResult rez;                                                           \
-		if((rez = (x)) < 0)                                                     \
-		{                                                                       \
+#define ANKI_VK_CHECKF(x) \
+	do \
+	{ \
+		VkResult rez; \
+		if((rez = (x)) < 0) \
+		{ \
 			ANKI_VK_LOGF("Vulkan function failed (VkResult: %d): %s", rez, #x); \
-		}                                                                       \
+		} \
 	} while(0)
 
 /// Check if a vulkan function failed.
-#define ANKI_VK_CHECK(x)                                                        \
-	do                                                                          \
-	{                                                                           \
-		VkResult rez;                                                           \
-		if((rez = (x)) < 0)                                                     \
-		{                                                                       \
+#define ANKI_VK_CHECK(x) \
+	do \
+	{ \
+		VkResult rez; \
+		if((rez = (x)) < 0) \
+		{ \
 			ANKI_VK_LOGE("Vulkan function failed (VkResult: %d): %s", rez, #x); \
-			return Error::FUNCTION_FAILED;                                      \
-		}                                                                       \
+			return Error::FUNCTION_FAILED; \
+		} \
 	} while(0)
 
 /// Convert compare op.

src/anki/gr/vulkan/GrManagerImpl.cpp

@@ -205,8 +205,8 @@ Error GrManagerImpl::initInternal(const GrManagerInitInfo& init)
 	m_pplineLayoutFactory.init(getAllocator(), m_device);
 
 	m_capabilities |= !!(m_extensions & VulkanExtensions::EXT_SHADER_SUBGROUP_BALLOT)
-		? GpuDeviceCapabilitiesBit::SHADER_BALLOT
-		: GpuDeviceCapabilitiesBit::NONE;
+						  ? GpuDeviceCapabilitiesBit::SHADER_BALLOT
+						  : GpuDeviceCapabilitiesBit::NONE;
 
 	return Error::NONE;
 }
@@ -309,7 +309,7 @@ Error GrManagerImpl::initInstance(const GrManagerInitInfo& init)
 				instExtensions[instExtensionCount++] = VK_KHR_WIN32_SURFACE_EXTENSION_NAME;
 			}
 #else
-#error TODO
+#	error TODO
 #endif
 			else if(CString(instExtensionInf[i].extensionName) == VK_KHR_SURFACE_EXTENSION_NAME)
 			{
@@ -358,7 +358,7 @@ Error GrManagerImpl::initInstance(const GrManagerInitInfo& init)
 		ci.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
 		ci.pfnCallback = debugReportCallbackEXT;
 		ci.flags = VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT
-			| VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT;
+				   | VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT;
 		ci.pUserData = this;
 
 		PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT =
@@ -492,13 +492,13 @@ Error GrManagerImpl::initDevice(const GrManagerInitInfo& init)
 				extensionsToEnable[extensionsToEnableCount++] = VK_KHR_MAINTENANCE1_EXTENSION_NAME;
 			}
 			else if(CString(&extensionInfos[extCount].extensionName[0])
-				== VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME)
+					== VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME)
 			{
 				m_extensions |= VulkanExtensions::AMD_NEGATIVE_VIEWPORT_HEIGHT;
 				// Don't add it just yet. Can't enable it at the same time with VK_KHR_maintenance1
 			}
 			else if(CString(extensionInfos[extCount].extensionName) == VK_EXT_DEBUG_MARKER_EXTENSION_NAME
-				&& init.m_config->getNumber("window.debugMarkers"))
+					&& init.m_config->getNumber("window.debugMarkers"))
 			{
 				m_extensions |= VulkanExtensions::EXT_DEBUG_MARKER;
 				extensionsToEnable[extensionsToEnableCount++] = VK_EXT_DEBUG_MARKER_EXTENSION_NAME;

src/anki/gr/vulkan/GrManagerImplSdl.cpp

@@ -10,11 +10,11 @@
 #include <SDL_syswm.h>
 #include <SDL_vulkan.h>
 #if ANKI_OS == ANKI_OS_LINUX
-#include <X11/Xlib-xcb.h>
+#	include <X11/Xlib-xcb.h>
 #elif ANKI_OS == ANKI_OS_WINDOWS
-#include <Winuser.h>
+#	include <Winuser.h>
 #else
-#error TODO
+#	error TODO
 #endif
 
 namespace anki
@@ -50,7 +50,7 @@ Error GrManagerImpl::initSurface(const GrManagerInitInfo& init)
 
 	ANKI_VK_CHECK(vkCreateWin32SurfaceKHR(m_instance, &ci, nullptr, &m_surface));
 #else
-#error TODO
+#	error TODO
 #endif
 
 	return Error::NONE;

src/anki/gr/vulkan/Pipeline.cpp

@@ -111,7 +111,7 @@ Bool PipelineStateTracker::updateHashes()
 	if(!!m_shaderColorAttachmentWritemask)
 	{
 		ANKI_ASSERT(m_fbColorAttachmentMask == m_shaderColorAttachmentWritemask
-			&& "Shader and fb should have same attachment mask");
+					&& "Shader and fb should have same attachment mask");
 
 		if(m_dirty.m_color)
 		{
@@ -288,7 +288,7 @@ const VkGraphicsPipelineCreateInfo& PipelineStateTracker::updatePipelineCreateIn
 		{
 			dsCi.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
 			dsCi.depthTestEnable = m_state.m_depth.m_depthCompareFunction != CompareOperation::ALWAYS
-				|| m_state.m_depth.m_depthWriteEnabled;
+								   || m_state.m_depth.m_depthWriteEnabled;
 			dsCi.depthWriteEnable = m_state.m_depth.m_depthWriteEnabled;
 			dsCi.depthCompareOp = convertCompareOp(m_state.m_depth.m_depthCompareFunction);
 		}
@@ -299,10 +299,10 @@ const VkGraphicsPipelineCreateInfo& PipelineStateTracker::updatePipelineCreateIn
 										 m_state.m_stencil.m_face[0].m_stencilPassDepthFailOperation,
 										 m_state.m_stencil.m_face[0].m_stencilPassDepthPassOperation,
 										 m_state.m_stencil.m_face[0].m_compareFunction)
-				|| !stencilTestDisabled(m_state.m_stencil.m_face[1].m_stencilFailOperation,
-					   m_state.m_stencil.m_face[1].m_stencilPassDepthFailOperation,
-					   m_state.m_stencil.m_face[1].m_stencilPassDepthPassOperation,
-					   m_state.m_stencil.m_face[1].m_compareFunction);
+									 || !stencilTestDisabled(m_state.m_stencil.m_face[1].m_stencilFailOperation,
+											m_state.m_stencil.m_face[1].m_stencilPassDepthFailOperation,
+											m_state.m_stencil.m_face[1].m_stencilPassDepthPassOperation,
+											m_state.m_stencil.m_face[1].m_compareFunction);
 
 			dsCi.front.failOp = convertStencilOp(m_state.m_stencil.m_face[0].m_stencilFailOperation);
 			dsCi.front.passOp = convertStencilOp(m_state.m_stencil.m_face[0].m_stencilPassDepthPassOperation);

src/anki/gr/vulkan/ShaderImpl.cpp

@@ -11,8 +11,8 @@
 #define ANKI_DUMP_SHADERS ANKI_EXTRA_CHECKS
 
 #if ANKI_DUMP_SHADERS
-#include <anki/util/File.h>
-#include <anki/gr/GrManager.h>
+#	include <anki/util/File.h>
+#	include <anki/gr/GrManager.h>
 #endif
 
 namespace anki

src/anki/gr/vulkan/TextureImpl.cpp

@@ -192,7 +192,7 @@ Error TextureImpl::initImage(const TextureInitInfo& init_)
 {
 	TextureInitInfo init = init_;
 	Bool useDedicatedMemory = !!(init.m_usage & TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE)
-		&& !!(getGrManagerImpl().getExtensions() & VulkanExtensions::NV_DEDICATED_ALLOCATION);
+							  && !!(getGrManagerImpl().getExtensions() & VulkanExtensions::NV_DEDICATED_ALLOCATION);
 
 	// Check if format is supported
 	Bool supported;
@@ -620,13 +620,13 @@ VkImageLayout TextureImpl::computeLayout(TextureUsageBit usage, U level) const
 		}
 	}
 	else if(depthStencil
-		&& !(usage & ~(TextureUsageBit::SAMPLED_ALL_GRAPHICS | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ)))
+			&& !(usage & ~(TextureUsageBit::SAMPLED_ALL_GRAPHICS | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ)))
 	{
 		// FB read & shader read
 		out = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
 	}
 	else if(depthStencil
-		&& !(usage & ~(TextureUsageBit::SAMPLED_ALL_GRAPHICS | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE)))
+			&& !(usage & ~(TextureUsageBit::SAMPLED_ALL_GRAPHICS | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE)))
 	{
 		// Wild guess: One aspect is shader read and the other is read write
 		out = VK_IMAGE_LAYOUT_GENERAL;

src/anki/gr/vulkan/VulkanObject.cpp

@@ -20,20 +20,20 @@
 namespace anki
 {
 
-#define ANKI_INSTANTIATE_GR_OBJECT(type_)                                                              \
-	template<>                                                                                         \
-	VkDevice VulkanObject<type_, type_##Impl>::getDevice() const                                       \
-	{                                                                                                  \
-		return getGrManagerImpl().getDevice();                                                         \
-	}                                                                                                  \
-	template<>                                                                                         \
-	GrManagerImpl& VulkanObject<type_, type_##Impl>::getGrManagerImpl()                                \
-	{                                                                                                  \
-		return static_cast<GrManagerImpl&>(static_cast<type_##Impl*>(this)->getManager());             \
-	}                                                                                                  \
-	template<>                                                                                         \
-	const GrManagerImpl& VulkanObject<type_, type_##Impl>::getGrManagerImpl() const                    \
-	{                                                                                                  \
+#define ANKI_INSTANTIATE_GR_OBJECT(type_) \
+	template<> \
+	VkDevice VulkanObject<type_, type_##Impl>::getDevice() const \
+	{ \
+		return getGrManagerImpl().getDevice(); \
+	} \
+	template<> \
+	GrManagerImpl& VulkanObject<type_, type_##Impl>::getGrManagerImpl() \
+	{ \
+		return static_cast<GrManagerImpl&>(static_cast<type_##Impl*>(this)->getManager()); \
+	} \
+	template<> \
+	const GrManagerImpl& VulkanObject<type_, type_##Impl>::getGrManagerImpl() const \
+	{ \
 		return static_cast<const GrManagerImpl&>(static_cast<const type_##Impl*>(this)->getManager()); \
 	}
 

src/anki/gr/vulkan/VulkanObject.h

@@ -30,12 +30,12 @@ public:
 };
 
 // Do this trick to avoid including heavy headers
-#define ANKI_INSTANTIATE_GR_OBJECT(type_)                                \
-	template<>                                                           \
-	VkDevice VulkanObject<type_, type_##Impl>::getDevice() const;        \
-	template<>                                                           \
+#define ANKI_INSTANTIATE_GR_OBJECT(type_) \
+	template<> \
+	VkDevice VulkanObject<type_, type_##Impl>::getDevice() const; \
+	template<> \
 	GrManagerImpl& VulkanObject<type_, type_##Impl>::getGrManagerImpl(); \
-	template<>                                                           \
+	template<> \
 	const GrManagerImpl& VulkanObject<type_, type_##Impl>::getGrManagerImpl() const;
 #define ANKI_INSTANTIATE_GR_OBJECT_DELIMITER()
 #include <anki/gr/common/InstantiationMacros.h>

src/anki/math/Axisang.h

@@ -59,8 +59,7 @@ public:
 		{
 
 			if((absolute<T>(m3(0, 1) + m3(1, 0)) < 0.1) && (absolute<T>(m3(0, 2) + m3(2, 0)) < 0.1)
-				&& (absolute<T>(m3(1, 2) + m3(2, 1)) < 0.1)
-				&& (absolute<T>(m3(0, 0) + m3(1, 1) + m3(2, 2)) - 3) < 0.1)
+				&& (absolute<T>(m3(1, 2) + m3(2, 1)) < 0.1) && (absolute<T>(m3(0, 0) + m3(1, 1) + m3(2, 2)) - 3) < 0.1)
 			{
 				m_axis = TVec3<T>(1.0, 0.0, 0.0);
 				m_ang = 0.0;
@@ -129,7 +128,7 @@ public:
 		}
 
 		T s = sqrt((m3(2, 1) - m3(1, 2)) * (m3(2, 1) - m3(1, 2)) + (m3(0, 2) - m3(2, 0)) * (m3(0, 2) - m3(2, 0))
-			+ (m3(1, 0) - m3(0, 1)) * (m3(1, 0) - m3(0, 1)));
+				   + (m3(1, 0) - m3(0, 1)) * (m3(1, 0) - m3(0, 1)));
 
 		if(absolute(s) < 0.001)
 		{

src/anki/math/Functions.h

@@ -89,11 +89,11 @@ inline T mod(const T x, const T y)
 template<typename T>
 T absolute(const T f);
 
-#define ANKI_SPECIALIZE_ABS(type_)       \
-	template<>                           \
+#define ANKI_SPECIALIZE_ABS(type_) \
+	template<> \
 	inline type_ absolute(const type_ f) \
-	{                                    \
-		return (f < type_(0)) ? -f : f;  \
+	{ \
+		return (f < type_(0)) ? -f : f; \
 	}
 
 ANKI_SPECIALIZE_ABS(I8)
@@ -112,10 +112,10 @@ inline Bool isZero(const T f)
 }
 
 #define ANKI_SPECIALIZE_IS_ZERO_INT(type_) \
-	template<>                             \
-	inline Bool isZero(const type_ x)      \
-	{                                      \
-		return x == type_(0);              \
+	template<> \
+	inline Bool isZero(const type_ x) \
+	{ \
+		return x == type_(0); \
 	}
 
 ANKI_SPECIALIZE_IS_ZERO_INT(I8)

src/anki/math/Mat3.h

@@ -95,7 +95,7 @@ public:
 		const TMat3& m = *this;
 		// For the accurate method see < r664
 		return m(0, 0) * (m(1, 1) * m(2, 2) - m(1, 2) * m(2, 1)) - m(0, 1) * (m(1, 0) * m(2, 2) - m(1, 2) * m(2, 0))
-			+ m(0, 2) * (m(0, 1) * m(2, 1) - m(1, 1) * m(2, 0));
+			   + m(0, 2) * (m(0, 1) * m(2, 1) - m(1, 1) * m(2, 0));
 	}
 
 	TMat3 getInverse() const

src/anki/math/Mat3x4.h

@@ -232,7 +232,7 @@ TMat3x4<F32> TMat3x4<F32>::combineTransformations(const TMat3x4<F32>& b) const;
 
 #elif ANKI_SIMD == ANKI_SIMD_NEON
 
-#error "TODO"
+#	error "TODO"
 
 #endif
 

src/anki/math/Mat4.h

@@ -195,17 +195,17 @@ public:
 	{
 		const TMat4& t = *this;
 		return t(0, 3) * t(1, 2) * t(2, 1) * t(3, 0) - t(0, 2) * t(1, 3) * t(2, 1) * t(3, 0)
-			- t(0, 3) * t(1, 1) * t(2, 2) * t(3, 0) + t(0, 1) * t(1, 3) * t(2, 2) * t(3, 0)
-			+ t(0, 2) * t(1, 1) * t(2, 3) * t(3, 0) - t(0, 1) * t(1, 2) * t(2, 3) * t(3, 0)
-			- t(0, 3) * t(1, 2) * t(2, 0) * t(3, 1) + t(0, 2) * t(1, 3) * t(2, 0) * t(3, 1)
-			+ t(0, 3) * t(1, 0) * t(2, 2) * t(3, 1) - t(0, 0) * t(1, 3) * t(2, 2) * t(3, 1)
-			- t(0, 2) * t(1, 0) * t(2, 3) * t(3, 1) + t(0, 0) * t(1, 2) * t(2, 3) * t(3, 1)
-			+ t(0, 3) * t(1, 1) * t(2, 0) * t(3, 2) - t(0, 1) * t(1, 3) * t(2, 0) * t(3, 2)
-			- t(0, 3) * t(1, 0) * t(2, 1) * t(3, 2) + t(0, 0) * t(1, 3) * t(2, 1) * t(3, 2)
-			+ t(0, 1) * t(1, 0) * t(2, 3) * t(3, 2) - t(0, 0) * t(1, 1) * t(2, 3) * t(3, 2)
-			- t(0, 2) * t(1, 1) * t(2, 0) * t(3, 3) + t(0, 1) * t(1, 2) * t(2, 0) * t(3, 3)
-			+ t(0, 2) * t(1, 0) * t(2, 1) * t(3, 3) - t(0, 0) * t(1, 2) * t(2, 1) * t(3, 3)
-			- t(0, 1) * t(1, 0) * t(2, 2) * t(3, 3) + t(0, 0) * t(1, 1) * t(2, 2) * t(3, 3);
+			   - t(0, 3) * t(1, 1) * t(2, 2) * t(3, 0) + t(0, 1) * t(1, 3) * t(2, 2) * t(3, 0)
+			   + t(0, 2) * t(1, 1) * t(2, 3) * t(3, 0) - t(0, 1) * t(1, 2) * t(2, 3) * t(3, 0)
+			   - t(0, 3) * t(1, 2) * t(2, 0) * t(3, 1) + t(0, 2) * t(1, 3) * t(2, 0) * t(3, 1)
+			   + t(0, 3) * t(1, 0) * t(2, 2) * t(3, 1) - t(0, 0) * t(1, 3) * t(2, 2) * t(3, 1)
+			   - t(0, 2) * t(1, 0) * t(2, 3) * t(3, 1) + t(0, 0) * t(1, 2) * t(2, 3) * t(3, 1)
+			   + t(0, 3) * t(1, 1) * t(2, 0) * t(3, 2) - t(0, 1) * t(1, 3) * t(2, 0) * t(3, 2)
+			   - t(0, 3) * t(1, 0) * t(2, 1) * t(3, 2) + t(0, 0) * t(1, 3) * t(2, 1) * t(3, 2)
+			   + t(0, 1) * t(1, 0) * t(2, 3) * t(3, 2) - t(0, 0) * t(1, 1) * t(2, 3) * t(3, 2)
+			   - t(0, 2) * t(1, 1) * t(2, 0) * t(3, 3) + t(0, 1) * t(1, 2) * t(2, 0) * t(3, 3)
+			   + t(0, 2) * t(1, 0) * t(2, 1) * t(3, 3) - t(0, 0) * t(1, 2) * t(2, 1) * t(3, 3)
+			   - t(0, 1) * t(1, 0) * t(2, 2) * t(3, 3) + t(0, 0) * t(1, 1) * t(2, 2) * t(3, 3);
 	}
 
 	/// Invert using Cramer's rule
@@ -316,7 +316,7 @@ public:
 
 		// one of the 2 mat4 doesnt represent transformation
 		ANKI_ASSERT(isZero<T>(m0(3, 0) + m0(3, 1) + m0(3, 2) + m0(3, 3) - 1.0)
-			&& isZero<T>(m1(3, 0) + m1(3, 1) + m1(3, 2) + m1(3, 3) - 1.0));
+					&& isZero<T>(m1(3, 0) + m1(3, 1) + m1(3, 2) + m1(3, 3) - 1.0));
 
 		TMat4 m4;
 
@@ -510,7 +510,7 @@ void TMat4F32Base::transpose();
 
 #elif ANKI_SIMD == ANKI_SIMD_NEON
 
-#error "TODO"
+#	error "TODO"
 
 #endif
 

src/anki/math/Mat4.inl.h

@@ -179,7 +179,7 @@ inline void TMat4F32Base::transpose()
 
 #elif ANKI_SIMD == ANKI_SIMD_NEON
 
-#error "TODO"
+#	error "TODO"
 
 #endif
 

src/anki/math/Simd.h

@@ -8,11 +8,11 @@
 #include <anki/Config.h>
 
 #if ANKI_SIMD == ANKI_SIMD_SSE
-#include <smmintrin.h>
+#	include <smmintrin.h>
 #elif ANKI_SIMD == ANKI_SIMD_NEON
-#include <arm_neon.h>
+#	include <arm_neon.h>
 #elif ANKI_SIMD == ANKI_SIMD_NONE
-#define ANKI_DUMMY_DUMMY_DUMMY 1
+#	define ANKI_DUMMY_DUMMY_DUMMY 1
 #else
-#error "See file"
+#	error "See file"
 #endif

src/anki/math/Vec4.h

@@ -225,7 +225,7 @@ TVec4<F32> TVec4<F32>::Base::operator-() const;
 
 #elif ANKI_SIMD == ANKI_SIMD_NEON
 
-#error "TODO"
+#	error "TODO"
 
 #endif
 

src/anki/math/Vec4.inl.h

@@ -185,7 +185,7 @@ inline TVec4<F32> TVec4<F32>::Base::operator-() const
 
 #elif ANKI_SIMD == ANKI_SIMD_NEON
 
-#error "TODO"
+#	error "TODO"
 
 #endif
 

src/anki/misc/Xml.h

@@ -12,7 +12,7 @@
 #include <anki/Math.h>
 #include <tinyxml2.h>
 #if !ANKI_TINYXML2
-#error "Wrong tinyxml2 included"
+#	error "Wrong tinyxml2 included"
 #endif
 
 namespace anki

src/anki/renderer/Clusterer.cpp

@@ -157,8 +157,8 @@ void Clusterer::init(const GenericMemoryPoolAllocator<U8>& alloc, U clusterCount
 
 	// Init planes. One plane for each direction, plus near/far plus the world space of those
 	U planesCount = (m_counts[0] - 1) * 2 // planes J
-		+ (m_counts[1] - 1) * 2 // planes I
-		+ 2; // Near and far planes
+					+ (m_counts[1] - 1) * 2 // planes I
+					+ 2; // Near and far planes
 
 	m_allPlanes.create(m_alloc, planesCount);
 

src/anki/renderer/Drawer.cpp

@@ -103,7 +103,8 @@ void RenderableDrawer::drawSingle(DrawContext& ctx)
 		lod = min<U8>(m_r->calculateLod(rqel.m_distanceFromCamera), MAX_LOD_COUNT - 1);
 	}
 
-	const Bool shouldFlush = ctx.m_cachedRenderElementCount > 0
+	const Bool shouldFlush =
+		ctx.m_cachedRenderElementCount > 0
 		&& (!canMergeRenderableQueueElements(ctx.m_cachedRenderElements[ctx.m_cachedRenderElementCount - 1], rqel)
 			   || ctx.m_cachedRenderElementLods[ctx.m_cachedRenderElementCount - 1] != lod);
 

src/anki/renderer/Indirect.cpp

@@ -803,7 +803,7 @@ Bool Indirect::findBestCacheEntry(U64 probeUuid, U32& cacheEntryIdxAllocated, Bo
 			break;
 		}
 		else if(m_cacheEntries[cacheEntryIdx].m_lastUsedTimestamp != m_r->getGlobalTimestamp()
-			&& m_cacheEntries[cacheEntryIdx].m_lastUsedTimestamp < cacheEntryIdxToKickMinTimestamp)
+				&& m_cacheEntries[cacheEntryIdx].m_lastUsedTimestamp < cacheEntryIdxToKickMinTimestamp)
 		{
 			// Found some with low timestamp
 			cacheEntryIdxToKick = cacheEntryIdx;

src/anki/renderer/LensFlare.cpp

@@ -191,7 +191,7 @@ void LensFlare::runDrawFlares(const RenderingContext& ctx, CommandBufferPtr& cmd
 		sprites[c].m_scale = flareEl.m_firstFlareSize * Vec2(1.0, m_r->getAspectRatio());
 		sprites[c].m_depth = 0.0;
 		F32 alpha = flareEl.m_colorMultiplier.w() * (1.0 - pow(absolute(posNdc.x()), 6.0))
-			* (1.0 - pow(absolute(posNdc.y()), 6.0)); // Fade the flare on the edges
+					* (1.0 - pow(absolute(posNdc.y()), 6.0)); // Fade the flare on the edges
 		sprites[c].m_color = Vec4(flareEl.m_colorMultiplier.xyz(), alpha);
 		++c;
 

src/anki/renderer/ShadowMapping.cpp

@@ -308,12 +308,13 @@ void ShadowMapping::processLights(RenderingContext& ctx, U32& threadCountForScra
 				++numOfFacesThatHaveDrawcalls;
 			}
 		}
-		const Bool allocationFailed = numOfFacesThatHaveDrawcalls == 0 || allocateTilesAndScratchTiles(light->m_uuid,
-																			  numOfFacesThatHaveDrawcalls,
-																			  &timestamps[0],
-																			  &faceIndices[0],
-																			  &tiles[0],
-																			  &scratchTiles[0]);
+		const Bool allocationFailed = numOfFacesThatHaveDrawcalls == 0
+									  || allocateTilesAndScratchTiles(light->m_uuid,
+											 numOfFacesThatHaveDrawcalls,
+											 &timestamps[0],
+											 &faceIndices[0],
+											 &tiles[0],
+											 &scratchTiles[0]);
 
 		if(!allocationFailed)
 		{
@@ -371,12 +372,12 @@ void ShadowMapping::processLights(RenderingContext& ctx, U32& threadCountForScra
 		// Allocate tiles
 		U32 tileIdx, scratchTileIdx, faceIdx = 0;
 		const Bool allocationFailed = light->m_shadowRenderQueue->m_renderables.getSize() == 0
-			|| allocateTilesAndScratchTiles(light->m_uuid,
-				   1,
-				   &light->m_shadowRenderQueue->m_shadowRenderablesLastUpdateTimestamp,
-				   &faceIdx,
-				   &tileIdx,
-				   &scratchTileIdx);
+									  || allocateTilesAndScratchTiles(light->m_uuid,
+											 1,
+											 &light->m_shadowRenderQueue->m_shadowRenderablesLastUpdateTimestamp,
+											 &faceIdx,
+											 &tileIdx,
+											 &scratchTileIdx);
 
 		if(!allocationFailed)
 		{
@@ -650,7 +651,7 @@ Bool ShadowMapping::allocateTile(U64 lightTimestamp, U64 lightUuid, U32 face, U3
 			break;
 		}
 		else if(m_tiles[tileIdx].m_lastUsedTimestamp != m_r->getGlobalTimestamp()
-			&& m_tiles[tileIdx].m_lastUsedTimestamp < tileToKickMinTimestamp)
+				&& m_tiles[tileIdx].m_lastUsedTimestamp < tileToKickMinTimestamp)
 		{
 			// Found some with low timestamp
 			tileToKick = tileIdx;

src/anki/resource/Common.h

@@ -52,7 +52,7 @@ using ResourcePtr = IntrusivePtr<T, ResourcePtrDeleter<T>>;
 
 // NOTE: Add resources in 3 places
 #define ANKI_INSTANTIATE_RESOURCE(rsrc_, name_) \
-	class rsrc_;                                \
+	class rsrc_; \
 	using name_ = ResourcePtr<rsrc_>;
 
 #define ANKI_INSTANSIATE_RESOURCE_DELIMITER()

src/anki/resource/ImageLoader.cpp

@@ -333,8 +333,7 @@ static ANKI_USE_RESULT Error loadAnkiTexture(ResourceFilePtr file,
 	}
 
 	if(header.m_width == 0 || !isPowerOfTwo(header.m_width) || header.m_width > 4096 || header.m_height == 0
-		|| !isPowerOfTwo(header.m_height)
-		|| header.m_height > 4096)
+		|| !isPowerOfTwo(header.m_height) || header.m_height > 4096)
 	{
 		ANKI_RESOURCE_LOGE("Incorrect width/height value");
 		return Error::USER_DATA;

src/anki/resource/Material.cpp

@@ -514,7 +514,7 @@ const MaterialVariant& Material::getOrCreateVariant(const RenderingKey& key_, Bo
 	if(variant.m_variant == nullptr)
 	{
 		const U mutatorCount = m_mutations.getSize() + ((m_instanceMutator) ? 1 : 0) + ((m_passMutator) ? 1 : 0)
-			+ ((m_lodMutator) ? 1 : 0) + ((m_bonesMutator) ? 1 : 0);
+							   + ((m_lodMutator) ? 1 : 0) + ((m_bonesMutator) ? 1 : 0);
 
 		DynamicArrayAuto<ShaderProgramResourceMutation> mutations(getTempAllocator());
 		mutations.create(mutatorCount);

src/anki/resource/Material.h

@@ -96,14 +96,14 @@ protected:
 };
 
 // Specialize the MaterialVariable::getValue
-#define ANKI_SPECIALIZE_GET_VALUE(t_, var_, shaderType_)                                          \
-	template<>                                                                                    \
-	inline const t_& MaterialVariable::getValue<t_>() const                                       \
-	{                                                                                             \
-		ANKI_ASSERT(m_input);                                                                     \
+#define ANKI_SPECIALIZE_GET_VALUE(t_, var_, shaderType_) \
+	template<> \
+	inline const t_& MaterialVariable::getValue<t_>() const \
+	{ \
+		ANKI_ASSERT(m_input); \
 		ANKI_ASSERT(m_input->getShaderVariableDataType() == ShaderVariableDataType::shaderType_); \
-		ANKI_ASSERT(m_builtin == BuiltinMaterialVariableId::NONE);                                \
-		return var_;                                                                              \
+		ANKI_ASSERT(m_builtin == BuiltinMaterialVariableId::NONE); \
+		return var_; \
 	}
 
 ANKI_SPECIALIZE_GET_VALUE(I32, m_int, INT)
@@ -126,7 +126,7 @@ inline const TextureResourcePtr& MaterialVariable::getValue() const
 {
 	ANKI_ASSERT(m_input);
 	ANKI_ASSERT(m_input->getShaderVariableDataType() >= ShaderVariableDataType::SAMPLERS_FIRST
-		&& m_input->getShaderVariableDataType() <= ShaderVariableDataType::SAMPLERS_LAST);
+				&& m_input->getShaderVariableDataType() <= ShaderVariableDataType::SAMPLERS_LAST);
 	ANKI_ASSERT(m_builtin == BuiltinMaterialVariableId::NONE);
 	return m_tex;
 }

src/anki/resource/Mesh.cpp

@@ -58,7 +58,7 @@ Mesh::~Mesh()
 Bool Mesh::isCompatible(const Mesh& other) const
 {
 	return hasBoneWeights() == other.hasBoneWeights() && getSubMeshesCount() == other.getSubMeshesCount()
-		&& m_texChannelsCount == other.m_texChannelsCount;
+		   && m_texChannelsCount == other.m_texChannelsCount;
 }
 
 Error Mesh::load(const ResourceFilename& filename, Bool async)

src/anki/resource/MeshLoader.cpp

@@ -44,8 +44,7 @@ Error MeshLoader::load(const ResourceFilename& filename)
 	if(checkFormat(m_header.m_positionsFormat, "positions", true)
 		|| checkFormat(m_header.m_normalsFormat, "normals", true)
 		|| checkFormat(m_header.m_tangentsFormat, "tangents", true)
-		|| checkFormat(m_header.m_colorsFormat, "colors", false)
-		|| checkFormat(m_header.m_uvsFormat, "UVs", true)
+		|| checkFormat(m_header.m_colorsFormat, "colors", false) || checkFormat(m_header.m_uvsFormat, "UVs", true)
 		|| checkFormat(m_header.m_boneWeightsFormat, "bone weights", false)
 		|| checkFormat(m_header.m_boneIndicesFormat, "bone ids", false)
 		|| checkFormat(m_header.m_indicesFormat, "indices format", true))
@@ -140,8 +139,7 @@ Error MeshLoader::load(const ResourceFilename& filename)
 	// Check indices
 	U indicesPerFace = ((m_header.m_flags & Flag::QUADS) == Flag::QUADS) ? 4 : 3;
 	if(m_header.m_totalIndicesCount < indicesPerFace || (m_header.m_totalIndicesCount % indicesPerFace) != 0
-		|| m_header.m_totalIndicesCount > MAX_U16
-		|| m_header.m_indicesFormat.m_components != ComponentFormat::R16
+		|| m_header.m_totalIndicesCount > MAX_U16 || m_header.m_indicesFormat.m_components != ComponentFormat::R16
 		|| m_header.m_indicesFormat.m_transform != FormatTransform::UINT)
 	{
 		// Only 16bit indices are supported for now
@@ -204,10 +202,10 @@ Error MeshLoader::load(const ResourceFilename& filename)
 	// Read vertices
 	//
 	m_vertSize = 3 * sizeof(F32) // pos
-		+ 1 * sizeof(U32) // norm
-		+ 1 * sizeof(U32) // tang
-		+ 2 * sizeof(U16) // uvs
-		+ ((hasBoneInfo) ? (4 * sizeof(U8) + 4 * sizeof(U16)) : 0);
+				 + 1 * sizeof(U32) // norm
+				 + 1 * sizeof(U32) // tang
+				 + 2 * sizeof(U16) // uvs
+				 + ((hasBoneInfo) ? (4 * sizeof(U8) + 4 * sizeof(U16)) : 0);
 
 	m_verts.create(alloc, m_header.m_totalVerticesCount * m_vertSize);
 	ANKI_CHECK(file->read(&m_verts[0], m_verts.getSizeInBytes()));

src/anki/resource/ResourceManager.h

@@ -103,7 +103,7 @@ public:
 class ResourceManager:
 
 #define ANKI_INSTANTIATE_RESOURCE(rsrc_, ptr_) \
-public                                         \
+public \
 	TypeResourceManager<rsrc_>
 
 #define ANKI_INSTANSIATE_RESOURCE_DELIMITER() ,

src/anki/resource/ShaderProgramResource.cpp

@@ -653,8 +653,7 @@ Error ShaderProgramResource::parseInputs(XmlElement& inputsEl,
 		}
 
 		if(var.m_dataType >= ShaderVariableDataType::MATRIX_FIRST
-			&& var.m_dataType <= ShaderVariableDataType::MATRIX_LAST
-			&& var.m_const)
+			&& var.m_dataType <= ShaderVariableDataType::MATRIX_LAST && var.m_const)
 		{
 			ANKI_RESOURCE_LOGE("Matrix input variable %s cannot be constant", &var.m_name[0]);
 			return Error::USER_DATA;
@@ -901,7 +900,7 @@ void ShaderProgramResource::initVariant(ConstWeakArray<ShaderProgramResourceMuta
 				}
 			}
 			else if(in.m_dataType == ShaderVariableDataType::VEC2 || in.m_dataType == ShaderVariableDataType::IVEC2
-				|| in.m_dataType == ShaderVariableDataType::UVEC2)
+					|| in.m_dataType == ShaderVariableDataType::UVEC2)
 			{
 				blockInfo.m_arrayStride = sizeof(Vec4);
 
@@ -917,7 +916,7 @@ void ShaderProgramResource::initVariant(ConstWeakArray<ShaderProgramResourceMuta
 				}
 			}
 			else if(in.m_dataType == ShaderVariableDataType::VEC3 || in.m_dataType == ShaderVariableDataType::IVEC3
-				|| in.m_dataType == ShaderVariableDataType::UVEC3)
+					|| in.m_dataType == ShaderVariableDataType::UVEC3)
 			{
 				alignRoundUp(sizeof(Vec4), blockInfo.m_offset);
 				blockInfo.m_arrayStride = sizeof(Vec4);
@@ -932,7 +931,7 @@ void ShaderProgramResource::initVariant(ConstWeakArray<ShaderProgramResourceMuta
 				}
 			}
 			else if(in.m_dataType == ShaderVariableDataType::VEC4 || in.m_dataType == ShaderVariableDataType::IVEC4
-				|| in.m_dataType == ShaderVariableDataType::UVEC4)
+					|| in.m_dataType == ShaderVariableDataType::UVEC4)
 			{
 				blockInfo.m_arrayStride = sizeof(Vec4);
 				alignRoundUp(sizeof(Vec4), blockInfo.m_offset);

src/anki/resource/ShaderProgramResource.h

@@ -130,7 +130,7 @@ private:
 	Bool isTexture() const
 	{
 		return m_dataType >= ShaderVariableDataType::SAMPLERS_FIRST
-			&& m_dataType <= ShaderVariableDataType::SAMPLERS_LAST;
+			   && m_dataType <= ShaderVariableDataType::SAMPLERS_LAST;
 	}
 
 	Bool inBlock() const

src/anki/resource/SkelAnim.cpp

@@ -4,7 +4,7 @@
 // http://www.anki3d.org/LICENSE
 
 #if 0
-#include <anki/resource/SkelAnim.h>
+#	include <anki/resource/SkelAnim.h>
 
 namespace anki {
 

src/anki/resource/TextureResource.cpp

@@ -69,7 +69,7 @@ Error TextureResource::load(const ResourceFilename& filename, Bool async)
 
 	TextureInitInfo init("RsrcTex");
 	init.m_usage = TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::SAMPLED_TESSELLATION_EVALUATION
-		| TextureUsageBit::TRANSFER_DESTINATION;
+				   | TextureUsageBit::TRANSFER_DESTINATION;
 	init.m_initialUsage = TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::SAMPLED_TESSELLATION_EVALUATION;
 	U faces = 0;
 

src/anki/scene/CameraNode.cpp

@@ -74,13 +74,11 @@ Error CameraNode::init(Frustum* frustum)
 
 	// Frustum component
 	FrustumComponent* frc = newComponent<FrustumComponent>(this, frustum);
-	frc->setEnabledVisibilityTests(FrustumComponentVisibilityTestFlag::RENDER_COMPONENTS
-		| FrustumComponentVisibilityTestFlag::LIGHT_COMPONENTS
+	frc->setEnabledVisibilityTests(
+		FrustumComponentVisibilityTestFlag::RENDER_COMPONENTS | FrustumComponentVisibilityTestFlag::LIGHT_COMPONENTS
 		| FrustumComponentVisibilityTestFlag::LENS_FLARE_COMPONENTS
-		| FrustumComponentVisibilityTestFlag::REFLECTION_PROBES
-		| FrustumComponentVisibilityTestFlag::REFLECTION_PROXIES
-		| FrustumComponentVisibilityTestFlag::OCCLUDERS
-		| FrustumComponentVisibilityTestFlag::DECALS
+		| FrustumComponentVisibilityTestFlag::REFLECTION_PROBES | FrustumComponentVisibilityTestFlag::REFLECTION_PROXIES
+		| FrustumComponentVisibilityTestFlag::OCCLUDERS | FrustumComponentVisibilityTestFlag::DECALS
 		| FrustumComponentVisibilityTestFlag::EARLY_Z);
 
 	// Feedback component #2

src/anki/scene/Visibility.cpp

@@ -512,35 +512,35 @@ void CombineResultsTask::combine()
 	}
 	ANKI_ASSERT(m_results->m_shadowRenderablesLastUpdateTimestamp);
 
-#define ANKI_VIS_COMBINE(t_, member_)                                                      \
-	{                                                                                      \
-		Array<TRenderQueueElementStorage<t_>, 64> subStorages;                             \
-		for(U i = 0; i < m_tests.getSize(); ++i)                                           \
-		{                                                                                  \
-			subStorages[i] = m_tests[i].m_result.member_;                                  \
-		}                                                                                  \
-		combineQueueElements<t_>(alloc,                                                    \
+#define ANKI_VIS_COMBINE(t_, member_) \
+	{ \
+		Array<TRenderQueueElementStorage<t_>, 64> subStorages; \
+		for(U i = 0; i < m_tests.getSize(); ++i) \
+		{ \
+			subStorages[i] = m_tests[i].m_result.member_; \
+		} \
+		combineQueueElements<t_>(alloc, \
 			WeakArray<TRenderQueueElementStorage<t_>>(&subStorages[0], m_tests.getSize()), \
-			nullptr,                                                                       \
-			m_results->member_,                                                            \
-			nullptr);                                                                      \
+			nullptr, \
+			m_results->member_, \
+			nullptr); \
 	}
 
-#define ANKI_VIS_COMBINE_AND_PTR(t_, member_, ptrMember_)                                      \
-	{                                                                                          \
-		Array<TRenderQueueElementStorage<t_>, 64> subStorages;                                 \
-		Array<TRenderQueueElementStorage<U32>, 64> ptrSubStorages;                             \
-		for(U i = 0; i < m_tests.getSize(); ++i)                                               \
-		{                                                                                      \
-			subStorages[i] = m_tests[i].m_result.member_;                                      \
-			ptrSubStorages[i] = m_tests[i].m_result.ptrMember_;                                \
-		}                                                                                      \
+#define ANKI_VIS_COMBINE_AND_PTR(t_, member_, ptrMember_) \
+	{ \
+		Array<TRenderQueueElementStorage<t_>, 64> subStorages; \
+		Array<TRenderQueueElementStorage<U32>, 64> ptrSubStorages; \
+		for(U i = 0; i < m_tests.getSize(); ++i) \
+		{ \
+			subStorages[i] = m_tests[i].m_result.member_; \
+			ptrSubStorages[i] = m_tests[i].m_result.ptrMember_; \
+		} \
 		WeakArray<TRenderQueueElementStorage<U32>> arr(&ptrSubStorages[0], m_tests.getSize()); \
-		combineQueueElements<t_>(alloc,                                                        \
-			WeakArray<TRenderQueueElementStorage<t_>>(&subStorages[0], m_tests.getSize()),     \
-			&arr,                                                                              \
-			m_results->member_,                                                                \
-			&m_results->ptrMember_);                                                           \
+		combineQueueElements<t_>(alloc, \
+			WeakArray<TRenderQueueElementStorage<t_>>(&subStorages[0], m_tests.getSize()), \
+			&arr, \
+			m_results->member_, \
+			&m_results->ptrMember_); \
 	}
 
 	ANKI_VIS_COMBINE(RenderableQueueElement, m_renderables);

src/anki/scene/components/DecalComponent.h

@@ -121,11 +121,11 @@ public:
 	void setupDecalQueueElement(DecalQueueElement& el) const
 	{
 		el.m_diffuseAtlas = (m_layers[LayerType::DIFFUSE].m_atlas)
-			? m_layers[LayerType::DIFFUSE].m_atlas->getGrTextureView().get()
-			: nullptr;
+								? m_layers[LayerType::DIFFUSE].m_atlas->getGrTextureView().get()
+								: nullptr;
 		el.m_normalRoughnessAtlas = (m_layers[LayerType::NORMAL_ROUGHNESS].m_atlas)
-			? m_layers[LayerType::NORMAL_ROUGHNESS].m_atlas->getGrTextureView().get()
-			: nullptr;
+										? m_layers[LayerType::NORMAL_ROUGHNESS].m_atlas->getGrTextureView().get()
+										: nullptr;
 		el.m_diffuseAtlasUv = m_layers[LayerType::DIFFUSE].m_uv;
 		el.m_normalRoughnessAtlasUv = m_layers[LayerType::NORMAL_ROUGHNESS].m_uv;
 		el.m_diffuseAtlasBlendFactor = m_layers[LayerType::DIFFUSE].m_blendFactor;

src/anki/scene/components/FrustumComponent.h

@@ -33,9 +33,7 @@ enum class FrustumComponentVisibilityTestFlag : U16
 	EARLY_Z = 1 << 8,
 
 	ALL_TESTS = RENDER_COMPONENTS | LIGHT_COMPONENTS | LENS_FLARE_COMPONENTS | SHADOW_CASTERS | REFLECTION_PROBES
-		| REFLECTION_PROXIES
-		| DECALS
-		| EARLY_Z
+				| REFLECTION_PROXIES | DECALS | EARLY_Z
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(FrustumComponentVisibilityTestFlag, inline)
 

src/anki/script/LuaBinder.cpp

@@ -198,7 +198,7 @@ Error LuaBinder::checkUserData(lua_State* l, I32 stackIdx, const char* typeName,
 		{
 			// Check using a LUA method again
 			ANKI_ASSERT(luaL_testudata(l, stackIdx, typeName) != nullptr
-				&& "ANKI type check passes but LUA's type check failed");
+						&& "ANKI type check passes but LUA's type check failed");
 		}
 		else
 		{

src/anki/script/LuaBinder.h

@@ -13,7 +13,7 @@
 #include <anki/util/Functions.h>
 #include <lua.hpp>
 #ifndef ANKI_LUA_HPP
-#error "Wrong LUA header included"
+#	error "Wrong LUA header included"
 #endif
 
 namespace anki

src/anki/ui/Common.h

@@ -25,7 +25,7 @@ class UiManager;
 using UiAllocator = HeapAllocator<U8>;
 
 #define ANKI_UI_OBJECT_FW(name_) \
-	class name_;                 \
+	class name_; \
 	using name_##Ptr = IntrusivePtr<name_>;
 
 ANKI_UI_OBJECT_FW(Font)

src/anki/ui/NuklearImpl.cpp

@@ -4,8 +4,8 @@
 // http://www.anki3d.org/LICENSE
 
 #if defined(__GNUC__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-function"
+#	pragma GCC diagnostic push
+#	pragma GCC diagnostic ignored "-Wunused-function"
 #endif
 
 #define NK_IMPLEMENTATION

src/anki/util/Assert.cpp

@@ -8,7 +8,7 @@
 #include <cstdlib>
 #include <cstdio>
 #if ANKI_OS == ANKI_OS_ANDROID
-#include <android/log.h>
+#	include <android/log.h>
 #endif
 
 namespace anki
@@ -18,16 +18,16 @@ namespace anki
 
 void akassert(const char* exprTxt, const char* file, int line, const char* func)
 {
-#if ANKI_OS == ANKI_OS_ANDROID
+#	if ANKI_OS == ANKI_OS_ANDROID
 	__android_log_print(ANDROID_LOG_ERROR, "AnKi", "(%s:%d %s) Assertion failed: %s", file, line, func, exprTxt);
-#else
-#if ANKI_OS == ANKI_OS_LINUX
+#	else
+#		if ANKI_OS == ANKI_OS_LINUX
 	if(runningFromATerminal())
 		fprintf(stderr, "\033[1;31m(%s:%d %s) Assertion failed: %s\033[0m\n", file, line, func, exprTxt);
 	else
-#endif
+#		endif
 		fprintf(stderr, "(%s:%d %s) Assertion failed: %s\n", file, line, func, exprTxt);
-#endif
+#	endif
 
 	class BW : public BackTraceWalker
 	{

src/anki/util/Assert.h

@@ -9,8 +9,8 @@
 
 /// Assertion. Print an error and stop the debugger (if it runs through a debugger) and then abort.
 #if !ANKI_EXTRA_CHECKS
-#define ANKI_ASSERT(x) ((void)0)
-#define ANKI_ASSERTS_ENABLED 0
+#	define ANKI_ASSERT(x) ((void)0)
+#	define ANKI_ASSERTS_ENABLED 0
 #else
 
 namespace anki
@@ -20,14 +20,14 @@ void akassert(const char* exprTxt, const char* file, int line, const char* func)
 
 } // end namespace
 
-#define ANKI_ASSERT(x)                                          \
-	do                                                          \
-	{                                                           \
-		if(!(x))                                                \
-		{                                                       \
-			anki::akassert(#x, ANKI_FILE, __LINE__, ANKI_FUNC); \
-		}                                                       \
-	} while(0)
-#define ANKI_ASSERTS_ENABLED 1
+#	define ANKI_ASSERT(x) \
+		do \
+		{ \
+			if(!(x)) \
+			{ \
+				anki::akassert(#x, ANKI_FILE, __LINE__, ANKI_FUNC); \
+			} \
+		} while(0)
+#	define ANKI_ASSERTS_ENABLED 1
 
 #endif

src/anki/util/CleanupWindows.h

@@ -10,32 +10,32 @@
 
 #if ANKI_OS == ANKI_OS_WINDOWS
 
-#ifdef near
-#undef near
-#endif
+#	ifdef near
+#		undef near
+#	endif
 
-#ifdef far
-#undef far
-#endif
+#	ifdef far
+#		undef far
+#	endif
 
-#ifdef ERROR
-#undef ERROR
-#endif
+#	ifdef ERROR
+#		undef ERROR
+#	endif
 
-#ifdef DELETE
-#undef DELETE
-#endif
+#	ifdef DELETE
+#		undef DELETE
+#	endif
 
-#ifdef OUT
-#undef OUT
-#endif
+#	ifdef OUT
+#		undef OUT
+#	endif
 
-#ifdef min
-#undef min
-#endif
+#	ifdef min
+#		undef min
+#	endif
 
-#ifdef max
-#undef max
-#endif
+#	ifdef max
+#		undef max
+#	endif
 
 #endif

src/anki/util/Enum.h

@@ -24,79 +24,79 @@ constexpr inline typename EnumUnderlyingType<TEnum>::Type enumToType(TEnum e)
 	return static_cast<typename EnumUnderlyingType<TEnum>::Type>(e);
 }
 
-#define _ANKI_ENUM_OPERATOR(enum_, qualifier_, operator_, assignOperator_)                                \
-	constexpr qualifier_ enum_ operator operator_(const enum_ a, const enum_ b)                           \
-	{                                                                                                     \
-		using Int = EnumUnderlyingType<enum_>::Type;                                                      \
-		return static_cast<enum_>(static_cast<Int>(a) operator_ static_cast<Int>(b));                     \
-	}                                                                                                     \
+#define _ANKI_ENUM_OPERATOR(enum_, qualifier_, operator_, assignOperator_) \
+	constexpr qualifier_ enum_ operator operator_(const enum_ a, const enum_ b) \
+	{ \
+		using Int = EnumUnderlyingType<enum_>::Type; \
+		return static_cast<enum_>(static_cast<Int>(a) operator_ static_cast<Int>(b)); \
+	} \
 	constexpr qualifier_ enum_ operator operator_(const enum_ a, const EnumUnderlyingType<enum_>::Type b) \
-	{                                                                                                     \
-		using Int = EnumUnderlyingType<enum_>::Type;                                                      \
-		return static_cast<enum_>(static_cast<Int>(a) operator_ b);                                       \
-	}                                                                                                     \
+	{ \
+		using Int = EnumUnderlyingType<enum_>::Type; \
+		return static_cast<enum_>(static_cast<Int>(a) operator_ b); \
+	} \
 	constexpr qualifier_ enum_ operator operator_(const EnumUnderlyingType<enum_>::Type a, const enum_ b) \
-	{                                                                                                     \
-		using Int = EnumUnderlyingType<enum_>::Type;                                                      \
-		return static_cast<enum_>(a operator_ static_cast<Int>(b));                                       \
-	}                                                                                                     \
-	qualifier_ enum_& operator assignOperator_(enum_& a, const enum_ b)                                   \
-	{                                                                                                     \
-		a = a operator_ b;                                                                                \
-		return a;                                                                                         \
-	}                                                                                                     \
-	qualifier_ enum_& operator assignOperator_(enum_& a, const EnumUnderlyingType<enum_>::Type b)         \
-	{                                                                                                     \
-		a = a operator_ b;                                                                                \
-		return a;                                                                                         \
-	}                                                                                                     \
-	qualifier_ EnumUnderlyingType<enum_>::Type& operator assignOperator_(                                 \
-		EnumUnderlyingType<enum_>::Type& a, const enum_ b)                                                \
-	{                                                                                                     \
-		using Int = EnumUnderlyingType<enum_>::Type;                                                      \
-		a = a operator_ static_cast<Int>(b);                                                              \
-		return a;                                                                                         \
+	{ \
+		using Int = EnumUnderlyingType<enum_>::Type; \
+		return static_cast<enum_>(a operator_ static_cast<Int>(b)); \
+	} \
+	qualifier_ enum_& operator assignOperator_(enum_& a, const enum_ b) \
+	{ \
+		a = a operator_ b; \
+		return a; \
+	} \
+	qualifier_ enum_& operator assignOperator_(enum_& a, const EnumUnderlyingType<enum_>::Type b) \
+	{ \
+		a = a operator_ b; \
+		return a; \
+	} \
+	qualifier_ EnumUnderlyingType<enum_>::Type& operator assignOperator_( \
+		EnumUnderlyingType<enum_>::Type& a, const enum_ b) \
+	{ \
+		using Int = EnumUnderlyingType<enum_>::Type; \
+		a = a operator_ static_cast<Int>(b); \
+		return a; \
 	}
 
-#define _ANKI_ENUM_UNARAY_OPERATOR(enum_, qualifier_, operator_)  \
-	constexpr qualifier_ enum_ operator operator_(const enum_ a)  \
-	{                                                             \
-		using Int = EnumUnderlyingType<enum_>::Type;              \
+#define _ANKI_ENUM_UNARAY_OPERATOR(enum_, qualifier_, operator_) \
+	constexpr qualifier_ enum_ operator operator_(const enum_ a) \
+	{ \
+		using Int = EnumUnderlyingType<enum_>::Type; \
 		return static_cast<enum_>(operator_ static_cast<Int>(a)); \
 	}
 
 #define _ANKI_ENUM_INCREMENT_DECREMENT(enum_, qualifier_) \
-	qualifier_ enum_& operator++(enum_& a)                \
-	{                                                     \
-		using Int = EnumUnderlyingType<enum_>::Type;      \
-		a = static_cast<enum_>(static_cast<Int>(a) + 1);  \
-		return a;                                         \
-	}                                                     \
-	qualifier_ enum_& operator--(enum_& a)                \
-	{                                                     \
-		using Int = EnumUnderlyingType<enum_>::Type;      \
-		a = static_cast<enum_>(static_cast<Int>(a) - 1);  \
-		return a;                                         \
-	}                                                     \
-	qualifier_ enum_ operator++(enum_& a, int)            \
-	{                                                     \
-		enum_ old = a;                                    \
-		++a;                                              \
-		return old;                                       \
-	}                                                     \
-	qualifier_ enum_ operator--(enum_& a, int)            \
-	{                                                     \
-		enum_ old = a;                                    \
-		--a;                                              \
-		return old;                                       \
+	qualifier_ enum_& operator++(enum_& a) \
+	{ \
+		using Int = EnumUnderlyingType<enum_>::Type; \
+		a = static_cast<enum_>(static_cast<Int>(a) + 1); \
+		return a; \
+	} \
+	qualifier_ enum_& operator--(enum_& a) \
+	{ \
+		using Int = EnumUnderlyingType<enum_>::Type; \
+		a = static_cast<enum_>(static_cast<Int>(a) - 1); \
+		return a; \
+	} \
+	qualifier_ enum_ operator++(enum_& a, int) \
+	{ \
+		enum_ old = a; \
+		++a; \
+		return old; \
+	} \
+	qualifier_ enum_ operator--(enum_& a, int) \
+	{ \
+		enum_ old = a; \
+		--a; \
+		return old; \
 	}
 
 #define _ANKI_ENUM_NEGATIVE_OPERATOR(enum_, qualifier_) \
-	qualifier_ bool operator!(const enum_& a)           \
-	{                                                   \
-		using Int = EnumUnderlyingType<enum_>::Type;    \
-		return static_cast<Int>(a) == 0;                \
-	}                                                   \
+	qualifier_ bool operator!(const enum_& a) \
+	{ \
+		using Int = EnumUnderlyingType<enum_>::Type; \
+		return static_cast<Int>(a) == 0; \
+	} \
 /// @}
 
 /// @addtogroup util_other
@@ -104,17 +104,17 @@ constexpr inline typename EnumUnderlyingType<TEnum>::Type enumToType(TEnum e)
 
 /// Implement all those functions that will make a stronly typed enum behave like the old type of enums.
 #define ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(enum_, qualifier_) \
-	_ANKI_ENUM_OPERATOR(enum_, qualifier_, |, |=)             \
-	_ANKI_ENUM_OPERATOR(enum_, qualifier_, &, &=)             \
-	_ANKI_ENUM_OPERATOR(enum_, qualifier_, ^, ^=)             \
-	_ANKI_ENUM_OPERATOR(enum_, qualifier_, +, +=)             \
-	_ANKI_ENUM_OPERATOR(enum_, qualifier_, -, -=)             \
-	_ANKI_ENUM_OPERATOR(enum_, qualifier_, *, *=)             \
-	_ANKI_ENUM_OPERATOR(enum_, qualifier_, /, /=)             \
-	_ANKI_ENUM_OPERATOR(enum_, qualifier_, <<, <<=)           \
-	_ANKI_ENUM_OPERATOR(enum_, qualifier_, >>, >>=)           \
-	_ANKI_ENUM_UNARAY_OPERATOR(enum_, qualifier_, ~)          \
-	_ANKI_ENUM_INCREMENT_DECREMENT(enum_, qualifier_)         \
+	_ANKI_ENUM_OPERATOR(enum_, qualifier_, |, |=) \
+	_ANKI_ENUM_OPERATOR(enum_, qualifier_, &, &=) \
+	_ANKI_ENUM_OPERATOR(enum_, qualifier_, ^, ^=) \
+	_ANKI_ENUM_OPERATOR(enum_, qualifier_, +, +=) \
+	_ANKI_ENUM_OPERATOR(enum_, qualifier_, -, -=) \
+	_ANKI_ENUM_OPERATOR(enum_, qualifier_, *, *=) \
+	_ANKI_ENUM_OPERATOR(enum_, qualifier_, /, /=) \
+	_ANKI_ENUM_OPERATOR(enum_, qualifier_, <<, <<=) \
+	_ANKI_ENUM_OPERATOR(enum_, qualifier_, >>, >>=) \
+	_ANKI_ENUM_UNARAY_OPERATOR(enum_, qualifier_, ~) \
+	_ANKI_ENUM_INCREMENT_DECREMENT(enum_, qualifier_) \
 	_ANKI_ENUM_NEGATIVE_OPERATOR(enum_, qualifier_)
 
 /// Convert enum to the underlying type.

src/anki/util/File.cpp

@@ -16,7 +16,7 @@ namespace anki
 #if ANKI_OS == ANKI_OS_ANDROID
 extern android_app* gAndroidApp;
 
-#define ANKI_AFILE reinterpret_cast<AAsset*>(m_file)
+#	define ANKI_AFILE reinterpret_cast<AAsset*>(m_file)
 #endif
 
 #define ANKI_CFILE reinterpret_cast<FILE*>(m_file)
@@ -48,10 +48,10 @@ Error File::open(const CString& filename, FileOpenFlag flags)
 	ANKI_ASSERT(m_file == nullptr && m_flags == FileOpenFlag::NONE && m_type == Type::NONE);
 
 	// Only these flags are accepted
-	ANKI_ASSERT((flags & (FileOpenFlag::READ | FileOpenFlag::WRITE | FileOpenFlag::APPEND | FileOpenFlag::BINARY
-							 | FileOpenFlag::ENDIAN_LITTLE
-							 | FileOpenFlag::ENDIAN_BIG))
-		!= FileOpenFlag::NONE);
+	ANKI_ASSERT((flags
+					& (FileOpenFlag::READ | FileOpenFlag::WRITE | FileOpenFlag::APPEND | FileOpenFlag::BINARY
+						  | FileOpenFlag::ENDIAN_LITTLE | FileOpenFlag::ENDIAN_BIG))
+				!= FileOpenFlag::NONE);
 
 	// Cannot be both
 	ANKI_ASSERT((flags & FileOpenFlag::READ) != (flags & FileOpenFlag::WRITE));
@@ -312,7 +312,7 @@ Error File::readU32(U32& out)
 	ANKI_ASSERT((m_flags & FileOpenFlag::READ) != FileOpenFlag::NONE);
 	ANKI_ASSERT((m_flags & FileOpenFlag::BINARY) != FileOpenFlag::NONE && "Should be binary file");
 	ANKI_ASSERT((m_flags & FileOpenFlag::ENDIAN_BIG) != (m_flags & FileOpenFlag::ENDIAN_LITTLE)
-		&& "One of those 2 should be active");
+				&& "One of those 2 should be active");
 
 	Error err = read(&out, sizeof(out));
 	if(!err)
@@ -320,8 +320,8 @@ Error File::readU32(U32& out)
 		// Copy it
 		FileOpenFlag machineEndianness = getMachineEndianness();
 		FileOpenFlag fileEndianness = ((m_flags & FileOpenFlag::ENDIAN_BIG) != FileOpenFlag::NONE)
-			? FileOpenFlag::ENDIAN_BIG
-			: FileOpenFlag::ENDIAN_LITTLE;
+										  ? FileOpenFlag::ENDIAN_BIG
+										  : FileOpenFlag::ENDIAN_LITTLE;
 
 		if(machineEndianness == fileEndianness)
 		{

src/anki/util/FilesystemPosix.cpp

@@ -16,7 +16,7 @@
 
 // Define PATH_MAX if needed
 #ifndef PATH_MAX
-#define PATH_MAX 4096
+#	define PATH_MAX 4096
 #endif
 
 namespace anki

src/anki/util/Functions.h

@@ -186,17 +186,17 @@ struct TypesAreTheSame<T, T>
 template<typename T>
 void memorySet(T* dest, T value, const PtrSize count);
 
-#define ANKI_SPECIALISE_MEMORY_SET(T)                                 \
-	template<>                                                        \
-	inline void memorySet(T* dest, T value, const PtrSize count)      \
-	{                                                                 \
-		ANKI_ASSERT(dest);                                            \
-		const T* end = dest + count;                                  \
-		while(dest != end)                                            \
-		{                                                             \
+#define ANKI_SPECIALISE_MEMORY_SET(T) \
+	template<> \
+	inline void memorySet(T* dest, T value, const PtrSize count) \
+	{ \
+		ANKI_ASSERT(dest); \
+		const T* end = dest + count; \
+		while(dest != end) \
+		{ \
 			memcpy(reinterpret_cast<char*>(dest), &value, sizeof(T)); \
-			++dest;                                                   \
-		}                                                             \
+			++dest; \
+		} \
 	}
 
 ANKI_SPECIALISE_MEMORY_SET(U8)

src/anki/util/List.inl.h

@@ -10,7 +10,7 @@ namespace detail
 
 template<typename TNodePointer, typename TValuePointer, typename TValueReference, typename TList>
 ListIterator<TNodePointer, TValuePointer, TValueReference, TList>&
-	ListIterator<TNodePointer, TValuePointer, TValueReference, TList>::operator--()
+ListIterator<TNodePointer, TValuePointer, TValueReference, TList>::operator--()
 {
 	ANKI_ASSERT(m_list);
 

src/anki/util/Logger.cpp

@@ -11,7 +11,7 @@
 #include <cstdio>
 #include <cstdlib>
 #if ANKI_OS == ANKI_OS_ANDROID
-#include <android/log.h>
+#	include <android/log.h>
 #endif
 
 namespace anki

src/anki/util/Logger.h

@@ -96,10 +96,10 @@ private:
 
 typedef Singleton<Logger> LoggerSingleton;
 
-#define ANKI_LOG(subsystem_, t, ...)                                                          \
-	do                                                                                        \
-	{                                                                                         \
-		LoggerSingleton::get().writeFormated(                                                 \
+#define ANKI_LOG(subsystem_, t, ...) \
+	do \
+	{ \
+		LoggerSingleton::get().writeFormated( \
 			ANKI_FILE, __LINE__, ANKI_FUNC, subsystem_, Logger::MessageType::t, __VA_ARGS__); \
 	} while(false);
 /// @}

src/anki/util/Memory.cpp

@@ -51,7 +51,7 @@ void* mallocAligned(PtrSize size, PtrSize alignmentBytes)
 	ANKI_ASSERT(alignmentBytes > 0);
 
 #if ANKI_POSIX
-#if ANKI_OS != ANKI_OS_ANDROID
+#	if ANKI_OS != ANKI_OS_ANDROID
 	void* out = nullptr;
 	U alignment = getAlignedRoundUp(alignmentBytes, sizeof(void*));
 	int err = posix_memalign(&out, alignment, size);
@@ -68,7 +68,7 @@ void* mallocAligned(PtrSize size, PtrSize alignmentBytes)
 	}
 
 	return out;
-#else
+#	else
 	void* out = memalign(getAlignedRoundUp(alignmentBytes, sizeof(void*)), size);
 
 	if(out)
@@ -82,7 +82,7 @@ void* mallocAligned(PtrSize size, PtrSize alignmentBytes)
 	}
 
 	return out;
-#endif
+#	endif
 #elif ANKI_OS == ANKI_OS_WINDOWS
 	void* out = _aligned_malloc(size, alignmentBytes);
 
@@ -98,7 +98,7 @@ void* mallocAligned(PtrSize size, PtrSize alignmentBytes)
 
 	return out;
 #else
-#error "Unimplemented"
+#	error "Unimplemented"
 #endif
 }
 
@@ -109,7 +109,7 @@ void freeAligned(void* ptr)
 #elif ANKI_OS == ANKI_OS_WINDOWS
 	_aligned_free(ptr);
 #else
-#error "Unimplemented"
+#	error "Unimplemented"
 #endif
 }
 

src/anki/util/SparseArray.h

@@ -226,7 +226,7 @@ public:
 				,
 			m_iteratorVer
 #endif
-			);
+		);
 	}
 
 	/// Get begin.
@@ -238,7 +238,7 @@ public:
 				,
 			m_iteratorVer
 #endif
-			);
+		);
 	}
 
 	/// Get end.
@@ -250,7 +250,7 @@ public:
 			,
 			m_iteratorVer
 #endif
-			);
+		);
 	}
 
 	/// Get end.
@@ -262,7 +262,7 @@ public:
 			,
 			m_iteratorVer
 #endif
-			);
+		);
 	}
 
 	/// Get begin.
@@ -318,7 +318,7 @@ public:
 				,
 			m_iteratorVer
 #endif
-			);
+		);
 	}
 
 	/// Get an iterator.
@@ -330,7 +330,7 @@ public:
 				,
 			m_iteratorVer
 #endif
-			);
+		);
 	}
 
 	/// Remove an element.

src/anki/util/SparseArray.inl.h

@@ -58,7 +58,7 @@ typename SparseArray<T, TIndex>::Iterator SparseArray<T, TIndex>::emplace(TAlloc
 			,
 		m_iteratorVer
 #endif
-		);
+	);
 }
 
 template<typename T, typename TIndex>

src/anki/util/StdTypes.h

@@ -159,31 +159,31 @@ private:
 };
 
 /// Macro to check if a method/function returned an error.
-#define ANKI_CHECK(x_)           \
-	do                           \
-	{                            \
-		Error error = x_;        \
+#define ANKI_CHECK(x_) \
+	do \
+	{ \
+		Error error = x_; \
 		if(ANKI_UNLIKELY(error)) \
-		{                        \
-			return error;        \
-		}                        \
+		{ \
+			return error; \
+		} \
 	} while(0)
 
 /// Macro the check if a memory allocation is OOM.
-#define ANKI_CHECK_OOM(x_)               \
-	do                                   \
-	{                                    \
+#define ANKI_CHECK_OOM(x_) \
+	do \
+	{ \
 		if(ANKI_UNLIKELY(x_ == nullptr)) \
-		{                                \
+		{ \
 			return Error::OUT_OF_MEMORY; \
-		}                                \
+		} \
 	} while(0)
 
 /// Macro to nuliffy a pointer on debug builds.
 #if ANKI_EXTRA_CHECKS
-#define ANKI_DBG_NULLIFY = {}
+#	define ANKI_DBG_NULLIFY = {}
 #else
-#define ANKI_DBG_NULLIFY
+#	define ANKI_DBG_NULLIFY
 #endif
 
 /// @name Size user literals
@@ -223,8 +223,8 @@ static constexpr long double operator""_ns(long double x)
 /// @}
 
 /// Convenience macro that defines the type of a class.
-#define ANKI_DEFINE_CLASS_SELF                  \
-	typedef auto _selfFn()->decltype(*this);    \
+#define ANKI_DEFINE_CLASS_SELF \
+	typedef auto _selfFn()->decltype(*this); \
 	using _SelfRef = decltype(((_selfFn*)0)()); \
 	using Self = std::remove_reference<_SelfRef>::type;
 /// @}

src/anki/util/String.h

@@ -29,11 +29,11 @@ constexpr const char* toStringFormat()
 	return nullptr;
 }
 
-#define ANKI_DEPLOY_TO_STRING(type_, string_)     \
-	template<>                                    \
+#define ANKI_DEPLOY_TO_STRING(type_, string_) \
+	template<> \
 	constexpr const char* toStringFormat<type_>() \
-	{                                             \
-		return string_;                           \
+	{ \
+		return string_; \
 	}
 
 ANKI_DEPLOY_TO_STRING(I8, "%" PRId8)

src/anki/util/System.cpp

@@ -8,18 +8,18 @@
 #include <cstdio>
 
 #if ANKI_POSIX
-#include <unistd.h>
-#include <signal.h>
+#	include <unistd.h>
+#	include <signal.h>
 #elif ANKI_OS == ANKI_OS_WINDOWS
-#include <windows.h>
+#	include <windows.h>
 #else
-#error "Unimplemented"
+#	error "Unimplemented"
 #endif
 
 // For print backtrace
 #if ANKI_POSIX && ANKI_OS != ANKI_OS_ANDROID
-#include <execinfo.h>
-#include <cstdlib>
+#	include <execinfo.h>
+#	include <cstdlib>
 #endif
 
 namespace anki
@@ -34,7 +34,7 @@ U32 getCpuCoresCount()
 	GetSystemInfo(&sysinfo);
 	return sysinfo.dwNumberOfProcessors;
 #else
-#error "Unimplemented"
+#	error "Unimplemented"
 #endif
 }
 

src/anki/util/ThreadHive.cpp

@@ -13,9 +13,9 @@ namespace anki
 #define ANKI_ENABLE_HIVE_DEBUG_PRINT 0
 
 #if ANKI_ENABLE_HIVE_DEBUG_PRINT
-#define ANKI_HIVE_DEBUG_PRINT(...) printf(__VA_ARGS__)
+#	define ANKI_HIVE_DEBUG_PRINT(...) printf(__VA_ARGS__)
 #else
-#define ANKI_HIVE_DEBUG_PRINT(...) ((void)0)
+#	define ANKI_HIVE_DEBUG_PRINT(...) ((void)0)
 #endif
 
 class ThreadHive::Thread

tests/framework/Framework.h

@@ -85,108 +85,108 @@ extern void deleteTesterSingleton();
 // Macros
 
 /// Create a new test and add it. It does a trick to add the test by using a static function
-#define ANKI_TEST(suiteName_, name_)                                                     \
-	using namespace anki;                                                                \
-	void test_##suiteName_##name_(Test&);                                                \
-	struct Foo##suiteName_##name_                                                        \
-	{                                                                                    \
-		Foo##suiteName_##name_()                                                         \
-		{                                                                                \
+#define ANKI_TEST(suiteName_, name_) \
+	using namespace anki; \
+	void test_##suiteName_##name_(Test&); \
+	struct Foo##suiteName_##name_ \
+	{ \
+		Foo##suiteName_##name_() \
+		{ \
 			getTesterSingleton().addTest(#name_, #suiteName_, test_##suiteName_##name_); \
-		}                                                                                \
-	};                                                                                   \
-	static Foo##suiteName_##name_ yada##suiteName_##name_;                               \
+		} \
+	}; \
+	static Foo##suiteName_##name_ yada##suiteName_##name_; \
 	void test_##suiteName_##name_(Test&)
 
 /// Intermediate macro
-#define ANKI_TEST_EXPECT_EQ_IMPL(file_, line_, func_, x, y)                                  \
-	do                                                                                       \
-	{                                                                                        \
-		if((x) != (y))                                                                       \
-		{                                                                                    \
-			std::stringstream ss;                                                            \
+#define ANKI_TEST_EXPECT_EQ_IMPL(file_, line_, func_, x, y) \
+	do \
+	{ \
+		if((x) != (y)) \
+		{ \
+			std::stringstream ss; \
 			ss << "FAILURE: " << #x << " != " << #y << " (" << file_ << ":" << line_ << ")"; \
-			fprintf(stderr, "%s\n", ss.str().c_str());                                       \
-			abort();                                                                         \
-		}                                                                                    \
+			fprintf(stderr, "%s\n", ss.str().c_str()); \
+			abort(); \
+		} \
 	} while(0);
 
 /// Intermediate macro
-#define ANKI_TEST_EXPECT_NEQ_IMPL(file_, line_, func_, x, y)                                 \
-	do                                                                                       \
-	{                                                                                        \
-		if((x) == (y))                                                                       \
-		{                                                                                    \
-			std::stringstream ss;                                                            \
+#define ANKI_TEST_EXPECT_NEQ_IMPL(file_, line_, func_, x, y) \
+	do \
+	{ \
+		if((x) == (y)) \
+		{ \
+			std::stringstream ss; \
 			ss << "FAILURE: " << #x << " == " << #y << " (" << file_ << ":" << line_ << ")"; \
-			fprintf(stderr, "%s\n", ss.str().c_str());                                       \
-			abort();                                                                         \
-		}                                                                                    \
+			fprintf(stderr, "%s\n", ss.str().c_str()); \
+			abort(); \
+		} \
 	} while(0);
 
 /// Intermediate macro
-#define ANKI_TEST_EXPECT_GT_IMPL(file_, line_, func_, x, y)                                 \
-	do                                                                                      \
-	{                                                                                       \
-		if((x) <= (y))                                                                      \
-		{                                                                                   \
-			std::stringstream ss;                                                           \
+#define ANKI_TEST_EXPECT_GT_IMPL(file_, line_, func_, x, y) \
+	do \
+	{ \
+		if((x) <= (y)) \
+		{ \
+			std::stringstream ss; \
 			ss << "FAILURE: " << #x << " > " << #y << " (" << file_ << ":" << line_ << ")"; \
-			fprintf(stderr, "%s\n", ss.str().c_str());                                      \
-			abort();                                                                        \
-		}                                                                                   \
+			fprintf(stderr, "%s\n", ss.str().c_str()); \
+			abort(); \
+		} \
 	} while(0);
 
 /// Intermediate macro
-#define ANKI_TEST_EXPECT_GEQ_IMPL(file_, line_, func_, x, y)                                 \
-	do                                                                                       \
-	{                                                                                        \
-		if((x) < (y))                                                                        \
-		{                                                                                    \
-			std::stringstream ss;                                                            \
+#define ANKI_TEST_EXPECT_GEQ_IMPL(file_, line_, func_, x, y) \
+	do \
+	{ \
+		if((x) < (y)) \
+		{ \
+			std::stringstream ss; \
 			ss << "FAILURE: " << #x << " >= " << #y << " (" << file_ << ":" << line_ << ")"; \
-			fprintf(stderr, "%s\n", ss.str().c_str());                                       \
-			abort();                                                                         \
-		}                                                                                    \
+			fprintf(stderr, "%s\n", ss.str().c_str()); \
+			abort(); \
+		} \
 	} while(0);
 
 /// Intermediate macro
-#define ANKI_TEST_EXPECT_LT_IMPL(file_, line_, func_, x, y)                                 \
-	do                                                                                      \
-	{                                                                                       \
-		if((x) >= (y))                                                                      \
-		{                                                                                   \
-			std::stringstream ss;                                                           \
+#define ANKI_TEST_EXPECT_LT_IMPL(file_, line_, func_, x, y) \
+	do \
+	{ \
+		if((x) >= (y)) \
+		{ \
+			std::stringstream ss; \
 			ss << "FAILURE: " << #x << " < " << #y << " (" << file_ << ":" << line_ << ")"; \
-			fprintf(stderr, "%s\n", ss.str().c_str());                                      \
-			abort();                                                                        \
-		}                                                                                   \
+			fprintf(stderr, "%s\n", ss.str().c_str()); \
+			abort(); \
+		} \
 	} while(0);
 
 /// Intermediate macro
-#define ANKI_TEST_EXPECT_LEQ_IMPL(file_, line_, func_, x, y)                                 \
-	do                                                                                       \
-	{                                                                                        \
-		if((x) > (y))                                                                        \
-		{                                                                                    \
-			std::stringstream ss;                                                            \
+#define ANKI_TEST_EXPECT_LEQ_IMPL(file_, line_, func_, x, y) \
+	do \
+	{ \
+		if((x) > (y)) \
+		{ \
+			std::stringstream ss; \
 			ss << "FAILURE: " << #x << " <= " << #y << " (" << file_ << ":" << line_ << ")"; \
-			fprintf(stderr, "%s\n", ss.str().c_str());                                       \
-			abort();                                                                         \
-		}                                                                                    \
+			fprintf(stderr, "%s\n", ss.str().c_str()); \
+			abort(); \
+		} \
 	} while(0);
 
 /// Intermediate macro
-#define ANKI_TEST_EXPECT_NEAR_IMPL(file_, line_, func_, x, y, epsilon_)                      \
-	do                                                                                       \
-	{                                                                                        \
-		if(absolute((x) - (y)) > (epsilon_))                                                 \
-		{                                                                                    \
-			std::stringstream ss;                                                            \
+#define ANKI_TEST_EXPECT_NEAR_IMPL(file_, line_, func_, x, y, epsilon_) \
+	do \
+	{ \
+		if(absolute((x) - (y)) > (epsilon_)) \
+		{ \
+			std::stringstream ss; \
 			ss << "FAILURE: " << #x << " != " << #y << " (" << file_ << ":" << line_ << ")"; \
-			fprintf(stderr, "%s\n", ss.str().c_str());                                       \
-			abort();                                                                         \
-		}                                                                                    \
+			fprintf(stderr, "%s\n", ss.str().c_str()); \
+			abort(); \
+		} \
 	} while(0);
 
 /// Macro to compare equal

tests/gr/Gr.cpp

@@ -286,29 +286,29 @@ static NativeWindow* win = nullptr;
 static GrManager* gr = nullptr;
 static StagingGpuMemoryManager* stagingMem = nullptr;
 
-#define COMMON_BEGIN()                                                          \
-	stagingMem = new StagingGpuMemoryManager();                                 \
-	Config cfg;                                                                 \
-	cfg.set("width", WIDTH);                                                    \
-	cfg.set("height", HEIGHT);                                                  \
-	cfg.set("window.debugContext", true);                                       \
-	cfg.set("window.vsync", false);                                             \
-	win = createWindow(cfg);                                                    \
-	gr = createGrManager(cfg, win);                                             \
-	ANKI_TEST_EXPECT_NO_ERR(stagingMem->init(gr, Config()));                    \
-	TransferGpuAllocator* transfAlloc = new TransferGpuAllocator();             \
+#define COMMON_BEGIN() \
+	stagingMem = new StagingGpuMemoryManager(); \
+	Config cfg; \
+	cfg.set("width", WIDTH); \
+	cfg.set("height", HEIGHT); \
+	cfg.set("window.debugContext", true); \
+	cfg.set("window.vsync", false); \
+	win = createWindow(cfg); \
+	gr = createGrManager(cfg, win); \
+	ANKI_TEST_EXPECT_NO_ERR(stagingMem->init(gr, Config())); \
+	TransferGpuAllocator* transfAlloc = new TransferGpuAllocator(); \
 	ANKI_TEST_EXPECT_NO_ERR(transfAlloc->init(128_MB, gr, gr->getAllocator())); \
 	{
 
-#define COMMON_END()               \
-	}                              \
-	gr->finish();                  \
-	delete transfAlloc;            \
-	delete stagingMem;             \
+#define COMMON_END() \
+	} \
+	gr->finish(); \
+	delete transfAlloc; \
+	delete stagingMem; \
 	GrManager::deleteInstance(gr); \
-	delete win;                    \
-	win = nullptr;                 \
-	gr = nullptr;                  \
+	delete win; \
+	win = nullptr; \
+	gr = nullptr; \
 	stagingMem = nullptr;
 
 static void* setUniforms(PtrSize size, CommandBufferPtr& cmdb, U set, U binding)
@@ -330,23 +330,23 @@ static void* setStorage(PtrSize size, CommandBufferPtr& cmdb, U set, U binding)
 #define SET_UNIFORMS(type_, size_, cmdb_, set_, binding_) static_cast<type_>(setUniforms(size_, cmdb_, set_, binding_))
 #define SET_STORAGE(type_, size_, cmdb_, set_, binding_) static_cast<type_>(setStorage(size_, cmdb_, set_, binding_))
 
-#define UPLOAD_TEX_SURFACE(cmdb_, tex_, surf_, ptr_, size_, handle_)                                        \
-	do                                                                                                      \
-	{                                                                                                       \
-		ANKI_TEST_EXPECT_NO_ERR(transfAlloc->allocate(size_, handle_));                                     \
-		void* f = handle_.getMappedMemory();                                                                \
-		memcpy(f, ptr_, size_);                                                                             \
-		TextureViewPtr view = gr->newTextureView(TextureViewInitInfo(tex_, surf_));                         \
+#define UPLOAD_TEX_SURFACE(cmdb_, tex_, surf_, ptr_, size_, handle_) \
+	do \
+	{ \
+		ANKI_TEST_EXPECT_NO_ERR(transfAlloc->allocate(size_, handle_)); \
+		void* f = handle_.getMappedMemory(); \
+		memcpy(f, ptr_, size_); \
+		TextureViewPtr view = gr->newTextureView(TextureViewInitInfo(tex_, surf_)); \
 		cmdb_->copyBufferToTextureView(handle_.getBuffer(), handle_.getOffset(), handle_.getRange(), view); \
 	} while(0)
 
-#define UPLOAD_TEX_VOL(cmdb_, tex_, vol_, ptr_, size_, handle_)                                             \
-	do                                                                                                      \
-	{                                                                                                       \
-		ANKI_TEST_EXPECT_NO_ERR(transfAlloc->allocate(size_, handle_));                                     \
-		void* f = handle_.getMappedMemory();                                                                \
-		memcpy(f, ptr_, size_);                                                                             \
-		TextureViewPtr view = gr->newTextureView(TextureViewInitInfo(tex_, vol_));                          \
+#define UPLOAD_TEX_VOL(cmdb_, tex_, vol_, ptr_, size_, handle_) \
+	do \
+	{ \
+		ANKI_TEST_EXPECT_NO_ERR(transfAlloc->allocate(size_, handle_)); \
+		void* f = handle_.getMappedMemory(); \
+		memcpy(f, ptr_, size_); \
+		TextureViewPtr view = gr->newTextureView(TextureViewInitInfo(tex_, vol_)); \
 		cmdb_->copyBufferToTextureView(handle_.getBuffer(), handle_.getOffset(), handle_.getRange(), view); \
 	} while(0)
 

tests/util/Foo.h

@@ -8,13 +8,13 @@
 #include <cstdio>
 
 #ifndef ANKI_TESTS_FOO_VERBOSE
-#define ANKI_TESTS_FOO_VERBOSE 0
+#	define ANKI_TESTS_FOO_VERBOSE 0
 #endif
 
 #if ANKI_TESTS_FOO_VERBOSE
-#define ANKI_TESTS_FOO_PRINT() printf("%s\n", __PRETTY_FUNCTION__)
+#	define ANKI_TESTS_FOO_PRINT() printf("%s\n", __PRETTY_FUNCTION__)
 #else
-#define ANKI_TESTS_FOO_PRINT() ((void)0)
+#	define ANKI_TESTS_FOO_PRINT() ((void)0)
 #endif
 
 /// Struct for testing

tests/util/String.cpp

@@ -94,11 +94,11 @@ ANKI_TEST(Util, String)
 
 	// Compare
 	{
-#define COMPARE(x_, y_, op_)                                          \
-	a.append(alloc, x_);                                              \
-	b.append(alloc, y_);                                              \
+#define COMPARE(x_, y_, op_) \
+	a.append(alloc, x_); \
+	b.append(alloc, y_); \
 	ANKI_TEST_EXPECT_EQ(a op_ b, std::string(x_) op_ std::string(y_)) \
-	a.destroy(alloc);                                                 \
+	a.destroy(alloc); \
 	b.destroy(alloc);
 
 		String a, b;