ClangFormat: apply to source, most of intern

Apply clang format as proposed in T53211.

For details on usage and instructions for migrating branches
without conflicts, see:

https://wiki.blender.org/wiki/Tools/ClangFormat

1 files changed, 341 insertions, 313 deletions

diff --git a/source/blender/gpu/intern/gpu_immediate_util.c b/source/blender/gpu/intern/gpu_immediate_util.c
index 53a69b0b9d7..ca0c2506750 100644
--- a/source/blender/gpu/intern/gpu_immediate_util.c
+++ b/source/blender/gpu/intern/gpu_immediate_util.c
@@ -31,112 +31,114 @@
 #include "GPU_matrix.h"
 
 static const float cube_coords[8][3] = {
-	{-1, -1, -1},
-	{-1, -1, +1},
-	{-1, +1, -1},
-	{-1, +1, +1},
-	{+1, -1, -1},
-	{+1, -1, +1},
-	{+1, +1, -1},
-	{+1, +1, +1},
+    {-1, -1, -1},
+    {-1, -1, +1},
+    {-1, +1, -1},
+    {-1, +1, +1},
+    {+1, -1, -1},
+    {+1, -1, +1},
+    {+1, +1, -1},
+    {+1, +1, +1},
 };
 static const int cube_quad_index[6][4] = {
-	{0, 1, 3, 2},
-	{0, 2, 6, 4},
-	{0, 4, 5, 1},
-	{1, 5, 7, 3},
-	{2, 3, 7, 6},
-	{4, 6, 7, 5},
+    {0, 1, 3, 2},
+    {0, 2, 6, 4},
+    {0, 4, 5, 1},
+    {1, 5, 7, 3},
+    {2, 3, 7, 6},
+    {4, 6, 7, 5},
 };
 static const int cube_line_index[12][2] = {
-	{0, 1},
-	{0, 2},
-	{0, 4},
-	{1, 3},
-	{1, 5},
-	{2, 3},
-	{2, 6},
-	{3, 7},
-	{4, 5},
-	{4, 6},
-	{5, 7},
-	{6, 7},
+    {0, 1},
+    {0, 2},
+    {0, 4},
+    {1, 3},
+    {1, 5},
+    {2, 3},
+    {2, 6},
+    {3, 7},
+    {4, 5},
+    {4, 6},
+    {5, 7},
+    {6, 7},
 };
 
 void immRectf(uint pos, float x1, float y1, float x2, float y2)
 {
-	immBegin(GPU_PRIM_TRI_FAN, 4);
-	immVertex2f(pos, x1, y1);
-	immVertex2f(pos, x2, y1);
-	immVertex2f(pos, x2, y2);
-	immVertex2f(pos, x1, y2);
-	immEnd();
+  immBegin(GPU_PRIM_TRI_FAN, 4);
+  immVertex2f(pos, x1, y1);
+  immVertex2f(pos, x2, y1);
+  immVertex2f(pos, x2, y2);
+  immVertex2f(pos, x1, y2);
+  immEnd();
 }
 
 void immRecti(uint pos, int x1, int y1, int x2, int y2)
 {
-	immBegin(GPU_PRIM_TRI_FAN, 4);
-	immVertex2i(pos, x1, y1);
-	immVertex2i(pos, x2, y1);
-	immVertex2i(pos, x2, y2);
-	immVertex2i(pos, x1, y2);
-	immEnd();
+  immBegin(GPU_PRIM_TRI_FAN, 4);
+  immVertex2i(pos, x1, y1);
+  immVertex2i(pos, x2, y1);
+  immVertex2i(pos, x2, y2);
+  immVertex2i(pos, x1, y2);
+  immEnd();
 }
 
 void immRectf_fast(uint pos, float x1, float y1, float x2, float y2)
 {
-	immVertex2f(pos, x1, y1);
-	immVertex2f(pos, x2, y1);
-	immVertex2f(pos, x2, y2);
+  immVertex2f(pos, x1, y1);
+  immVertex2f(pos, x2, y1);
+  immVertex2f(pos, x2, y2);
 
-	immVertex2f(pos, x1, y1);
-	immVertex2f(pos, x2, y2);
-	immVertex2f(pos, x1, y2);
+  immVertex2f(pos, x1, y1);
+  immVertex2f(pos, x2, y2);
+  immVertex2f(pos, x1, y2);
 }
 
-void immRectf_fast_with_color(uint pos, uint col, float x1, float y1, float x2, float y2, const float color[4])
+void immRectf_fast_with_color(
+    uint pos, uint col, float x1, float y1, float x2, float y2, const float color[4])
 {
-	immAttr4fv(col, color);
-	immVertex2f(pos, x1, y1);
-	immAttr4fv(col, color);
-	immVertex2f(pos, x2, y1);
-	immAttr4fv(col, color);
-	immVertex2f(pos, x2, y2);
-
-	immAttr4fv(col, color);
-	immVertex2f(pos, x1, y1);
-	immAttr4fv(col, color);
-	immVertex2f(pos, x2, y2);
-	immAttr4fv(col, color);
-	immVertex2f(pos, x1, y2);
+  immAttr4fv(col, color);
+  immVertex2f(pos, x1, y1);
+  immAttr4fv(col, color);
+  immVertex2f(pos, x2, y1);
+  immAttr4fv(col, color);
+  immVertex2f(pos, x2, y2);
+
+  immAttr4fv(col, color);
+  immVertex2f(pos, x1, y1);
+  immAttr4fv(col, color);
+  immVertex2f(pos, x2, y2);
+  immAttr4fv(col, color);
+  immVertex2f(pos, x1, y2);
 }
 
-void immRecti_fast_with_color(uint pos, uint col, int x1, int y1, int x2, int y2, const float color[4])
+void immRecti_fast_with_color(
+    uint pos, uint col, int x1, int y1, int x2, int y2, const float color[4])
 {
-	immAttr4fv(col, color);
-	immVertex2i(pos, x1, y1);
-	immAttr4fv(col, color);
-	immVertex2i(pos, x2, y1);
-	immAttr4fv(col, color);
-	immVertex2i(pos, x2, y2);
-
-	immAttr4fv(col, color);
-	immVertex2i(pos, x1, y1);
-	immAttr4fv(col, color);
-	immVertex2i(pos, x2, y2);
-	immAttr4fv(col, color);
-	immVertex2i(pos, x1, y2);
+  immAttr4fv(col, color);
+  immVertex2i(pos, x1, y1);
+  immAttr4fv(col, color);
+  immVertex2i(pos, x2, y1);
+  immAttr4fv(col, color);
+  immVertex2i(pos, x2, y2);
+
+  immAttr4fv(col, color);
+  immVertex2i(pos, x1, y1);
+  immAttr4fv(col, color);
+  immVertex2i(pos, x2, y2);
+  immAttr4fv(col, color);
+  immVertex2i(pos, x1, y2);
 }
 
 #if 0 /* more complete version in case we want that */
 void immRecti_complete(int x1, int y1, int x2, int y2, const float color[4])
 {
-	GPUVertFormat *format = immVertexFormat();
-	uint pos = add_attr(format, "pos", GPU_COMP_I32, 2, GPU_FETCH_INT_TO_FLOAT);
-	immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
-	immUniformColor4fv(color);
-	immRecti(pos, x1, y1, x2, y2);
-	immUnbindProgram();
+  GPUVertFormat *format = immVertexFormat();
+  uint pos = add_attr(format, "pos", GPU_COMP_I32, 2, GPU_FETCH_INT_TO_FLOAT);
+  immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
+  immUniformColor4fv(color);
+  immRecti(pos, x1, y1, x2, y2);
+  immUnbindProgram();
 }
 #endif
 
@@ -153,20 +155,23 @@ void immRecti_complete(int x1, int y1, int x2, int y2, const float color[4])
  */
 void imm_cpack(uint x)
 {
-	immUniformColor3ub(((x) & 0xFF),
-	                   (((x) >> 8) & 0xFF),
-	                   (((x) >> 16) & 0xFF));
+  immUniformColor3ub(((x)&0xFF), (((x) >> 8) & 0xFF), (((x) >> 16) & 0xFF));
 }
 
-static void imm_draw_circle(
-        GPUPrimType prim_type, const uint shdr_pos, float x, float y, float rad_x, float rad_y, int nsegments)
+static void imm_draw_circle(GPUPrimType prim_type,
+                            const uint shdr_pos,
+                            float x,
+                            float y,
+                            float rad_x,
+                            float rad_y,
+                            int nsegments)
 {
-	immBegin(prim_type, nsegments);
-	for (int i = 0; i < nsegments; ++i) {
-		const float angle = (float)(2 * M_PI) * ((float)i / (float)nsegments);
-		immVertex2f(shdr_pos, x + (rad_x * cosf(angle)), y + (rad_y * sinf(angle)));
-	}
-	immEnd();
+  immBegin(prim_type, nsegments);
+  for (int i = 0; i < nsegments; ++i) {
+    const float angle = (float)(2 * M_PI) * ((float)i / (float)nsegments);
+    immVertex2f(shdr_pos, x + (rad_x * cosf(angle)), y + (rad_y * sinf(angle)));
+  }
+  immEnd();
 }
 
 /**
@@ -181,7 +186,7 @@ static void imm_draw_circle(
  */
 void imm_draw_circle_wire_2d(uint shdr_pos, float x, float y, float rad, int nsegments)
 {
-	imm_draw_circle(GPU_PRIM_LINE_LOOP, shdr_pos, x, y, rad, rad, nsegments);
+  imm_draw_circle(GPU_PRIM_LINE_LOOP, shdr_pos, x, y, rad, rad, nsegments);
 }
 
 /**
@@ -196,64 +201,76 @@ void imm_draw_circle_wire_2d(uint shdr_pos, float x, float y, float rad, int nse
  */
 void imm_draw_circle_fill_2d(uint shdr_pos, float x, float y, float rad, int nsegments)
 {
-	imm_draw_circle(GPU_PRIM_TRI_FAN, shdr_pos, x, y, rad, rad, nsegments);
+  imm_draw_circle(GPU_PRIM_TRI_FAN, shdr_pos, x, y, rad, rad, nsegments);
 }
 
-void imm_draw_circle_wire_aspect_2d(uint shdr_pos, float x, float y, float rad_x, float rad_y, int nsegments)
+void imm_draw_circle_wire_aspect_2d(
+    uint shdr_pos, float x, float y, float rad_x, float rad_y, int nsegments)
 {
-	imm_draw_circle(GPU_PRIM_LINE_LOOP, shdr_pos, x, y, rad_x, rad_y, nsegments);
+  imm_draw_circle(GPU_PRIM_LINE_LOOP, shdr_pos, x, y, rad_x, rad_y, nsegments);
 }
-void imm_draw_circle_fill_aspect_2d(uint shdr_pos, float x, float y, float rad_x, float rad_y, int nsegments)
+void imm_draw_circle_fill_aspect_2d(
+    uint shdr_pos, float x, float y, float rad_x, float rad_y, int nsegments)
 {
-	imm_draw_circle(GPU_PRIM_TRI_FAN, shdr_pos, x, y, rad_x, rad_y, nsegments);
+  imm_draw_circle(GPU_PRIM_TRI_FAN, shdr_pos, x, y, rad_x, rad_y, nsegments);
 }
 
-static void imm_draw_circle_partial(
-        GPUPrimType prim_type, uint pos, float x, float y,
-        float rad, int nsegments, float start, float sweep)
+static void imm_draw_circle_partial(GPUPrimType prim_type,
+                                    uint pos,
+                                    float x,
+                                    float y,
+                                    float rad,
+                                    int nsegments,
+                                    float start,
+                                    float sweep)
 {
-	/* shift & reverse angle, increase 'nsegments' to match gluPartialDisk */
-	const float angle_start = -(DEG2RADF(start)) + (float)(M_PI / 2);
-	const float angle_end   = -(DEG2RADF(sweep) - angle_start);
-	nsegments += 1;
-	immBegin(prim_type, nsegments);
-	for (int i = 0; i < nsegments; ++i) {
-		const float angle = interpf(angle_start, angle_end, ((float)i / (float)(nsegments - 1)));
-		const float angle_sin = sinf(angle);
-		const float angle_cos = cosf(angle);
-		immVertex2f(pos, x + rad * angle_cos, y + rad * angle_sin);
-	}
-	immEnd();
+  /* shift & reverse angle, increase 'nsegments' to match gluPartialDisk */
+  const float angle_start = -(DEG2RADF(start)) + (float)(M_PI / 2);
+  const float angle_end = -(DEG2RADF(sweep) - angle_start);
+  nsegments += 1;
+  immBegin(prim_type, nsegments);
+  for (int i = 0; i < nsegments; ++i) {
+    const float angle = interpf(angle_start, angle_end, ((float)i / (float)(nsegments - 1)));
+    const float angle_sin = sinf(angle);
+    const float angle_cos = cosf(angle);
+    immVertex2f(pos, x + rad * angle_cos, y + rad * angle_sin);
+  }
+  immEnd();
 }
 
 void imm_draw_circle_partial_wire_2d(
-        uint pos, float x, float y,
-        float rad, int nsegments, float start, float sweep)
+    uint pos, float x, float y, float rad, int nsegments, float start, float sweep)
 {
-	imm_draw_circle_partial(GPU_PRIM_LINE_STRIP, pos, x, y, rad, nsegments, start, sweep);
+  imm_draw_circle_partial(GPU_PRIM_LINE_STRIP, pos, x, y, rad, nsegments, start, sweep);
 }
 
-static void imm_draw_disk_partial(
-        GPUPrimType prim_type, uint pos, float x, float y,
-        float rad_inner, float rad_outer, int nsegments, float start, float sweep)
+static void imm_draw_disk_partial(GPUPrimType prim_type,
+                                  uint pos,
+                                  float x,
+                                  float y,
+                                  float rad_inner,
+                                  float rad_outer,
+                                  int nsegments,
+                                  float start,
+                                  float sweep)
 {
-	/* to avoid artifacts */
-	const float max_angle = 3 * 360;
-	CLAMP(sweep, -max_angle, max_angle);
-
-	/* shift & reverse angle, increase 'nsegments' to match gluPartialDisk */
-	const float angle_start = -(DEG2RADF(start)) + (float)(M_PI / 2);
-	const float angle_end   = -(DEG2RADF(sweep) - angle_start);
-	nsegments += 1;
-	immBegin(prim_type, nsegments * 2);
-	for (int i = 0; i < nsegments; ++i) {
-		const float angle = interpf(angle_start, angle_end, ((float)i / (float)(nsegments - 1)));
-		const float angle_sin = sinf(angle);
-		const float angle_cos = cosf(angle);
-		immVertex2f(pos, x + rad_inner * angle_cos, y + rad_inner * angle_sin);
-		immVertex2f(pos, x + rad_outer * angle_cos, y + rad_outer * angle_sin);
-	}
-	immEnd();
+  /* to avoid artifacts */
+  const float max_angle = 3 * 360;
+  CLAMP(sweep, -max_angle, max_angle);
+
+  /* shift & reverse angle, increase 'nsegments' to match gluPartialDisk */
+  const float angle_start = -(DEG2RADF(start)) + (float)(M_PI / 2);
+  const float angle_end = -(DEG2RADF(sweep) - angle_start);
+  nsegments += 1;
+  immBegin(prim_type, nsegments * 2);
+  for (int i = 0; i < nsegments; ++i) {
+    const float angle = interpf(angle_start, angle_end, ((float)i / (float)(nsegments - 1)));
+    const float angle_sin = sinf(angle);
+    const float angle_cos = cosf(angle);
+    immVertex2f(pos, x + rad_inner * angle_cos, y + rad_inner * angle_sin);
+    immVertex2f(pos, x + rad_outer * angle_cos, y + rad_outer * angle_sin);
+  }
+  immEnd();
 }
 
 /**
@@ -271,33 +288,38 @@ static void imm_draw_disk_partial(
  * \param start: Specifies the starting angle, in degrees, of the disk portion.
  * \param sweep: Specifies the sweep angle, in degrees, of the disk portion.
  */
-void imm_draw_disk_partial_fill_2d(
-        uint pos, float x, float y,
-        float rad_inner, float rad_outer, int nsegments, float start, float sweep)
+void imm_draw_disk_partial_fill_2d(uint pos,
+                                   float x,
+                                   float y,
+                                   float rad_inner,
+                                   float rad_outer,
+                                   int nsegments,
+                                   float start,
+                                   float sweep)
 {
-	imm_draw_disk_partial(GPU_PRIM_TRI_STRIP, pos, x, y, rad_inner, rad_outer, nsegments, start, sweep);
+  imm_draw_disk_partial(
+      GPU_PRIM_TRI_STRIP, pos, x, y, rad_inner, rad_outer, nsegments, start, sweep);
 }
 
 static void imm_draw_circle_3D(
-        GPUPrimType prim_type, uint pos, float x, float y,
-        float rad, int nsegments)
+    GPUPrimType prim_type, uint pos, float x, float y, float rad, int nsegments)
 {
-	immBegin(prim_type, nsegments);
-	for (int i = 0; i < nsegments; ++i) {
-		float angle = (float)(2 * M_PI) * ((float)i / (float)nsegments);
-		immVertex3f(pos, x + rad * cosf(angle), y + rad * sinf(angle), 0.0f);
-	}
-	immEnd();
+  immBegin(prim_type, nsegments);
+  for (int i = 0; i < nsegments; ++i) {
+    float angle = (float)(2 * M_PI) * ((float)i / (float)nsegments);
+    immVertex3f(pos, x + rad * cosf(angle), y + rad * sinf(angle), 0.0f);
+  }
+  immEnd();
 }
 
 void imm_draw_circle_wire_3d(uint pos, float x, float y, float rad, int nsegments)
 {
-	imm_draw_circle_3D(GPU_PRIM_LINE_LOOP, pos, x, y, rad, nsegments);
+  imm_draw_circle_3D(GPU_PRIM_LINE_LOOP, pos, x, y, rad, nsegments);
 }
 
 void imm_draw_circle_fill_3d(uint pos, float x, float y, float rad, int nsegments)
 {
-	imm_draw_circle_3D(GPU_PRIM_TRI_FAN, pos, x, y, rad, nsegments);
+  imm_draw_circle_3D(GPU_PRIM_TRI_FAN, pos, x, y, rad, nsegments);
 }
 
 /**
@@ -311,23 +333,23 @@ void imm_draw_circle_fill_3d(uint pos, float x, float y, float rad, int nsegment
  */
 void imm_draw_box_wire_2d(uint pos, float x1, float y1, float x2, float y2)
 {
-	immBegin(GPU_PRIM_LINE_LOOP, 4);
-	immVertex2f(pos, x1, y1);
-	immVertex2f(pos, x1, y2);
-	immVertex2f(pos, x2, y2);
-	immVertex2f(pos, x2, y1);
-	immEnd();
+  immBegin(GPU_PRIM_LINE_LOOP, 4);
+  immVertex2f(pos, x1, y1);
+  immVertex2f(pos, x1, y2);
+  immVertex2f(pos, x2, y2);
+  immVertex2f(pos, x2, y1);
+  immEnd();
 }
 
 void imm_draw_box_wire_3d(uint pos, float x1, float y1, float x2, float y2)
 {
-	/* use this version when GPUVertFormat has a vec3 position */
-	immBegin(GPU_PRIM_LINE_LOOP, 4);
-	immVertex3f(pos, x1, y1, 0.0f);
-	immVertex3f(pos, x1, y2, 0.0f);
-	immVertex3f(pos, x2, y2, 0.0f);
-	immVertex3f(pos, x2, y1, 0.0f);
-	immEnd();
+  /* use this version when GPUVertFormat has a vec3 position */
+  immBegin(GPU_PRIM_LINE_LOOP, 4);
+  immVertex3f(pos, x1, y1, 0.0f);
+  immVertex3f(pos, x1, y2, 0.0f);
+  immVertex3f(pos, x2, y2, 0.0f);
+  immVertex3f(pos, x2, y1, 0.0f);
+  immEnd();
 }
 
 /**
@@ -335,53 +357,53 @@ void imm_draw_box_wire_3d(uint pos, float x1, float y1, float x2, float y2)
  */
 void imm_draw_box_checker_2d(float x1, float y1, float x2, float y2)
 {
-	uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
-	immBindBuiltinProgram(GPU_SHADER_2D_CHECKER);
+  uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
+  immBindBuiltinProgram(GPU_SHADER_2D_CHECKER);
 
-	immUniform4f("color1", 0.15f, 0.15f, 0.15f, 1.0f);
-	immUniform4f("color2", 0.2f, 0.2f, 0.2f, 1.0f);
-	immUniform1i("size", 8);
+  immUniform4f("color1", 0.15f, 0.15f, 0.15f, 1.0f);
+  immUniform4f("color2", 0.2f, 0.2f, 0.2f, 1.0f);
+  immUniform1i("size", 8);
 
-	immRectf(pos, x1, y1, x2, y2);
+  immRectf(pos, x1, y1, x2, y2);
 
-	immUnbindProgram();
+  immUnbindProgram();
 }
 
 void imm_draw_cube_fill_3d(uint pos, const float co[3], const float aspect[3])
 {
-	float coords[ARRAY_SIZE(cube_coords)][3];
-
-	for (int i = 0; i < ARRAY_SIZE(cube_coords); i++) {
-		madd_v3_v3v3v3(coords[i], co, cube_coords[i], aspect);
-	}
-
-	immBegin(GPU_PRIM_TRIS, ARRAY_SIZE(cube_quad_index) * 3 * 2);
-	for (int i = 0; i < ARRAY_SIZE(cube_quad_index); i++) {
-		immVertex3fv(pos, coords[cube_quad_index[i][0]]);
-		immVertex3fv(pos, coords[cube_quad_index[i][1]]);
-		immVertex3fv(pos, coords[cube_quad_index[i][2]]);
-
-		immVertex3fv(pos, coords[cube_quad_index[i][0]]);
-		immVertex3fv(pos, coords[cube_quad_index[i][2]]);
-		immVertex3fv(pos, coords[cube_quad_index[i][3]]);
-	}
-	immEnd();
+  float coords[ARRAY_SIZE(cube_coords)][3];
+
+  for (int i = 0; i < ARRAY_SIZE(cube_coords); i++) {
+    madd_v3_v3v3v3(coords[i], co, cube_coords[i], aspect);
+  }
+
+  immBegin(GPU_PRIM_TRIS, ARRAY_SIZE(cube_quad_index) * 3 * 2);
+  for (int i = 0; i < ARRAY_SIZE(cube_quad_index); i++) {
+    immVertex3fv(pos, coords[cube_quad_index[i][0]]);
+    immVertex3fv(pos, coords[cube_quad_index[i][1]]);
+    immVertex3fv(pos, coords[cube_quad_index[i][2]]);
+
+    immVertex3fv(pos, coords[cube_quad_index[i][0]]);
+    immVertex3fv(pos, coords[cube_quad_index[i][2]]);
+    immVertex3fv(pos, coords[cube_quad_index[i][3]]);
+  }
+  immEnd();
 }
 
 void imm_draw_cube_wire_3d(uint pos, const float co[3], const float aspect[3])
 {
-	float coords[ARRAY_SIZE(cube_coords)][3];
-
-	for (int i = 0; i < ARRAY_SIZE(cube_coords); i++) {
-		madd_v3_v3v3v3(coords[i], co, cube_coords[i], aspect);
-	}
-
-	immBegin(GPU_PRIM_LINES, ARRAY_SIZE(cube_line_index) * 2);
-	for (int i = 0; i < ARRAY_SIZE(cube_line_index); i++) {
-		immVertex3fv(pos, coords[cube_line_index[i][0]]);
-		immVertex3fv(pos, coords[cube_line_index[i][1]]);
-	}
-	immEnd();
+  float coords[ARRAY_SIZE(cube_coords)][3];
+
+  for (int i = 0; i < ARRAY_SIZE(cube_coords); i++) {
+    madd_v3_v3v3v3(coords[i], co, cube_coords[i], aspect);
+  }
+
+  immBegin(GPU_PRIM_LINES, ARRAY_SIZE(cube_line_index) * 2);
+  for (int i = 0; i < ARRAY_SIZE(cube_line_index); i++) {
+    immVertex3fv(pos, coords[cube_line_index[i][0]]);
+    immVertex3fv(pos, coords[cube_line_index[i][1]]);
+  }
+  immEnd();
 }
 
 /**
@@ -397,128 +419,134 @@ void imm_draw_cube_wire_3d(uint pos, const float co[3], const float aspect[3])
  * \param stacks: Specifies the number of subdivisions along the z axis.
  */
 void imm_draw_cylinder_fill_normal_3d(
-        uint pos, uint nor, float base, float top, float height, int slices, int stacks)
+    uint pos, uint nor, float base, float top, float height, int slices, int stacks)
 {
-	immBegin(GPU_PRIM_TRIS, 6 * slices * stacks);
-	for (int i = 0; i < slices; ++i) {
-		const float angle1 = (float)(2 * M_PI) * ((float)i / (float)slices);
-		const float angle2 = (float)(2 * M_PI) * ((float)(i + 1) / (float)slices);
-		const float cos1 = cosf(angle1);
-		const float sin1 = sinf(angle1);
-		const float cos2 = cosf(angle2);
-		const float sin2 = sinf(angle2);
-
-		for (int j = 0; j < stacks; ++j) {
-			float fac1 = (float)j / (float)stacks;
-			float fac2 = (float)(j + 1) / (float)stacks;
-			float r1 = base * (1.f - fac1) + top * fac1;
-			float r2 = base * (1.f - fac2) + top * fac2;
-			float h1 = height * ((float)j / (float)stacks);
-			float h2 = height * ((float)(j + 1) / (float)stacks);
-
-			float v1[3] = {r1 * cos2, r1 * sin2, h1};
-			float v2[3] = {r2 * cos2, r2 * sin2, h2};
-			float v3[3] = {r2 * cos1, r2 * sin1, h2};
-			float v4[3] = {r1 * cos1, r1 * sin1, h1};
-			float n1[3], n2[3];
-
-			/* calc normals */
-			sub_v3_v3v3(n1, v2, v1);
-			normalize_v3(n1);
-			n1[0] = cos1; n1[1] = sin1; n1[2] = 1 - n1[2];
-
-			sub_v3_v3v3(n2, v3, v4);
-			normalize_v3(n2);
-			n2[0] = cos2; n2[1] = sin2; n2[2] = 1 - n2[2];
-
-			/* first tri */
-			immAttr3fv(nor, n2);
-			immVertex3fv(pos, v1);
-			immVertex3fv(pos, v2);
-			immAttr3fv(nor, n1);
-			immVertex3fv(pos, v3);
-
-			/* second tri */
-			immVertex3fv(pos, v3);
-			immVertex3fv(pos, v4);
-			immAttr3fv(nor, n2);
-			immVertex3fv(pos, v1);
-		}
-	}
-	immEnd();
+  immBegin(GPU_PRIM_TRIS, 6 * slices * stacks);
+  for (int i = 0; i < slices; ++i) {
+    const float angle1 = (float)(2 * M_PI) * ((float)i / (float)slices);
+    const float angle2 = (float)(2 * M_PI) * ((float)(i + 1) / (float)slices);
+    const float cos1 = cosf(angle1);
+    const float sin1 = sinf(angle1);
+    const float cos2 = cosf(angle2);
+    const float sin2 = sinf(angle2);
+
+    for (int j = 0; j < stacks; ++j) {
+      float fac1 = (float)j / (float)stacks;
+      float fac2 = (float)(j + 1) / (float)stacks;
+      float r1 = base * (1.f - fac1) + top * fac1;
+      float r2 = base * (1.f - fac2) + top * fac2;
+      float h1 = height * ((float)j / (float)stacks);
+      float h2 = height * ((float)(j + 1) / (float)stacks);
+
+      float v1[3] = {r1 * cos2, r1 * sin2, h1};
+      float v2[3] = {r2 * cos2, r2 * sin2, h2};
+      float v3[3] = {r2 * cos1, r2 * sin1, h2};
+      float v4[3] = {r1 * cos1, r1 * sin1, h1};
+      float n1[3], n2[3];
+
+      /* calc normals */
+      sub_v3_v3v3(n1, v2, v1);
+      normalize_v3(n1);
+      n1[0] = cos1;
+      n1[1] = sin1;
+      n1[2] = 1 - n1[2];
+
+      sub_v3_v3v3(n2, v3, v4);
+      normalize_v3(n2);
+      n2[0] = cos2;
+      n2[1] = sin2;
+      n2[2] = 1 - n2[2];
+
+      /* first tri */
+      immAttr3fv(nor, n2);
+      immVertex3fv(pos, v1);
+      immVertex3fv(pos, v2);
+      immAttr3fv(nor, n1);
+      immVertex3fv(pos, v3);
+
+      /* second tri */
+      immVertex3fv(pos, v3);
+      immVertex3fv(pos, v4);
+      immAttr3fv(nor, n2);
+      immVertex3fv(pos, v1);
+    }
+  }
+  immEnd();
 }
 
-void imm_draw_cylinder_wire_3d(uint pos, float base, float top, float height, int slices, int stacks)
+void imm_draw_cylinder_wire_3d(
+    uint pos, float base, float top, float height, int slices, int stacks)
 {
-	immBegin(GPU_PRIM_LINES, 6 * slices * stacks);
-	for (int i = 0; i < slices; ++i) {
-		const float angle1 = (float)(2 * M_PI) * ((float)i / (float)slices);
-		const float angle2 = (float)(2 * M_PI) * ((float)(i + 1) / (float)slices);
-		const float cos1 = cosf(angle1);
-		const float sin1 = sinf(angle1);
-		const float cos2 = cosf(angle2);
-		const float sin2 = sinf(angle2);
-
-		for (int j = 0; j < stacks; ++j) {
-			float fac1 = (float)j / (float)stacks;
-			float fac2 = (float)(j + 1) / (float)stacks;
-			float r1 = base * (1.f - fac1) + top * fac1;
-			float r2 = base * (1.f - fac2) + top * fac2;
-			float h1 = height * ((float)j / (float)stacks);
-			float h2 = height * ((float)(j + 1) / (float)stacks);
-
-			float v1[3] = {r1 * cos2, r1 * sin2, h1};
-			float v2[3] = {r2 * cos2, r2 * sin2, h2};
-			float v3[3] = {r2 * cos1, r2 * sin1, h2};
-			float v4[3] = {r1 * cos1, r1 * sin1, h1};
-
-			immVertex3fv(pos, v1);
-			immVertex3fv(pos, v2);
-
-			immVertex3fv(pos, v2);
-			immVertex3fv(pos, v3);
-
-			immVertex3fv(pos, v1);
-			immVertex3fv(pos, v4);
-		}
-	}
-	immEnd();
+  immBegin(GPU_PRIM_LINES, 6 * slices * stacks);
+  for (int i = 0; i < slices; ++i) {
+    const float angle1 = (float)(2 * M_PI) * ((float)i / (float)slices);
+    const float angle2 = (float)(2 * M_PI) * ((float)(i + 1) / (float)slices);
+    const float cos1 = cosf(angle1);
+    const float sin1 = sinf(angle1);
+    const float cos2 = cosf(angle2);
+    const float sin2 = sinf(angle2);
+
+    for (int j = 0; j < stacks; ++j) {
+      float fac1 = (float)j / (float)stacks;
+      float fac2 = (float)(j + 1) / (float)stacks;
+      float r1 = base * (1.f - fac1) + top * fac1;
+      float r2 = base * (1.f - fac2) + top * fac2;
+      float h1 = height * ((float)j / (float)stacks);
+      float h2 = height * ((float)(j + 1) / (float)stacks);
+
+      float v1[3] = {r1 * cos2, r1 * sin2, h1};
+      float v2[3] = {r2 * cos2, r2 * sin2, h2};
+      float v3[3] = {r2 * cos1, r2 * sin1, h2};
+      float v4[3] = {r1 * cos1, r1 * sin1, h1};
+
+      immVertex3fv(pos, v1);
+      immVertex3fv(pos, v2);
+
+      immVertex3fv(pos, v2);
+      immVertex3fv(pos, v3);
+
+      immVertex3fv(pos, v1);
+      immVertex3fv(pos, v4);
+    }
+  }
+  immEnd();
 }
 
-void imm_draw_cylinder_fill_3d(uint pos, float base, float top, float height, int slices, int stacks)
+void imm_draw_cylinder_fill_3d(
+    uint pos, float base, float top, float height, int slices, int stacks)
 {
-	immBegin(GPU_PRIM_TRIS, 6 * slices * stacks);
-	for (int i = 0; i < slices; ++i) {
-		const float angle1 = (float)(2 * M_PI) * ((float)i / (float)slices);
-		const float angle2 = (float)(2 * M_PI) * ((float)(i + 1) / (float)slices);
-		const float cos1 = cosf(angle1);
-		const float sin1 = sinf(angle1);
-		const float cos2 = cosf(angle2);
-		const float sin2 = sinf(angle2);
-
-		for (int j = 0; j < stacks; ++j) {
-			float fac1 = (float)j / (float)stacks;
-			float fac2 = (float)(j + 1) / (float)stacks;
-			float r1 = base * (1.f - fac1) + top * fac1;
-			float r2 = base * (1.f - fac2) + top * fac2;
-			float h1 = height * ((float)j / (float)stacks);
-			float h2 = height * ((float)(j + 1) / (float)stacks);
-
-			float v1[3] = {r1 * cos2, r1 * sin2, h1};
-			float v2[3] = {r2 * cos2, r2 * sin2, h2};
-			float v3[3] = {r2 * cos1, r2 * sin1, h2};
-			float v4[3] = {r1 * cos1, r1 * sin1, h1};
-
-			/* first tri */
-			immVertex3fv(pos, v1);
-			immVertex3fv(pos, v2);
-			immVertex3fv(pos, v3);
-
-			/* second tri */
-			immVertex3fv(pos, v3);
-			immVertex3fv(pos, v4);
-			immVertex3fv(pos, v1);
-		}
-	}
-	immEnd();
+  immBegin(GPU_PRIM_TRIS, 6 * slices * stacks);
+  for (int i = 0; i < slices; ++i) {
+    const float angle1 = (float)(2 * M_PI) * ((float)i / (float)slices);
+    const float angle2 = (float)(2 * M_PI) * ((float)(i + 1) / (float)slices);
+    const float cos1 = cosf(angle1);
+    const float sin1 = sinf(angle1);
+    const float cos2 = cosf(angle2);
+    const float sin2 = sinf(angle2);
+
+    for (int j = 0; j < stacks; ++j) {
+      float fac1 = (float)j / (float)stacks;
+      float fac2 = (float)(j + 1) / (float)stacks;
+      float r1 = base * (1.f - fac1) + top * fac1;
+      float r2 = base * (1.f - fac2) + top * fac2;
+      float h1 = height * ((float)j / (float)stacks);
+      float h2 = height * ((float)(j + 1) / (float)stacks);
+
+      float v1[3] = {r1 * cos2, r1 * sin2, h1};
+      float v2[3] = {r2 * cos2, r2 * sin2, h2};
+      float v3[3] = {r2 * cos1, r2 * sin1, h2};
+      float v4[3] = {r1 * cos1, r1 * sin1, h1};
+
+      /* first tri */
+      immVertex3fv(pos, v1);
+      immVertex3fv(pos, v2);
+      immVertex3fv(pos, v3);
+
+      /* second tri */
+      immVertex3fv(pos, v3);
+      immVertex3fv(pos, v4);
+      immVertex3fv(pos, v1);
+    }
+  }
+  immEnd();
 }