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, 331 insertions, 308 deletions

diff --git a/source/blender/gpu/intern/gpu_matrix.c b/source/blender/gpu/intern/gpu_matrix.c
index 9f0a5851390..667ee7f6e47 100644
--- a/source/blender/gpu/intern/gpu_matrix.c
+++ b/source/blender/gpu/intern/gpu_matrix.c
@@ -24,7 +24,7 @@
 #include "GPU_shader_interface.h"
 
 #define SUPPRESS_GENERIC_MATRIX_API
-#define USE_GPU_PY_MATRIX_API  /* only so values are declared */
+#define USE_GPU_PY_MATRIX_API /* only so values are declared */
 #include "GPU_matrix.h"
 #undef USE_GPU_PY_MATRIX_API
 
@@ -32,7 +32,6 @@
 #include "BLI_math_rotation.h"
 #include "BLI_math_vector.h"
 
-
 #define DEBUG_MATRIX_BIND 0
 
 #define MATRIX_STACK_DEPTH 32
@@ -41,33 +40,36 @@ typedef float Mat4[4][4];
 typedef float Mat3[3][3];
 
 typedef struct MatrixStack {
-	Mat4 stack[MATRIX_STACK_DEPTH];
-	uint top;
+  Mat4 stack[MATRIX_STACK_DEPTH];
+  uint top;
 } MatrixStack;
 
 typedef struct {
-	MatrixStack model_view_stack;
-	MatrixStack projection_stack;
+  MatrixStack model_view_stack;
+  MatrixStack projection_stack;
 
-	bool dirty;
+  bool dirty;
 
-	/* TODO: cache of derived matrices (Normal, MVP, inverse MVP, etc)
-	 * generate as needed for shaders, invalidate when original matrices change
-	 *
-	 * TODO: separate Model from View transform? Batches/objects have model,
-	 * camera/eye has view & projection
-	 */
+  /* TODO: cache of derived matrices (Normal, MVP, inverse MVP, etc)
+   * generate as needed for shaders, invalidate when original matrices change
+   *
+   * TODO: separate Model from View transform? Batches/objects have model,
+   * camera/eye has view & projection
+   */
 } MatrixState;
 
-#define MATRIX_4X4_IDENTITY {{1.0f, 0.0f, 0.0f, 0.0f}, \
-                             {0.0f, 1.0f, 0.0f, 0.0f}, \
-                             {0.0f, 0.0f, 1.0f, 0.0f}, \
-                             {0.0f, 0.0f, 0.0f, 1.0f}}
+#define MATRIX_4X4_IDENTITY \
+  { \
+    {1.0f, 0.0f, 0.0f, 0.0f}, {0.0f, 1.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 1.0f, 0.0f}, \
+    { \
+      0.0f, 0.0f, 0.0f, 1.0f \
+    } \
+  }
 
 static MatrixState state = {
-	.model_view_stack = {{MATRIX_4X4_IDENTITY}, 0},
-	.projection_stack = {{MATRIX_4X4_IDENTITY}, 0},
-	.dirty = true,
+    .model_view_stack = {{MATRIX_4X4_IDENTITY}, 0},
+    .projection_stack = {{MATRIX_4X4_IDENTITY}, 0},
+    .dirty = true,
 };
 
 #undef MATRIX_4X4_IDENTITY
@@ -80,11 +82,11 @@ static MatrixState state = {
 
 void GPU_matrix_reset(void)
 {
-	state.model_view_stack.top = 0;
-	state.projection_stack.top = 0;
-	unit_m4(ModelView);
-	unit_m4(Projection);
-	state.dirty = true;
+  state.model_view_stack.top = 0;
+  state.projection_stack.top = 0;
+  unit_m4(ModelView);
+  unit_m4(Projection);
+  state.dirty = true;
 }
 
 #ifdef WITH_GPU_SAFETY
@@ -92,241 +94,242 @@ void GPU_matrix_reset(void)
 /* Check if matrix is numerically good */
 static void checkmat(cosnt float *m)
 {
-	const int n = 16;
-	for (int i = 0; i < n; i++) {
-#if _MSC_VER
-		BLI_assert(_finite(m[i]));
-#else
-		BLI_assert(!isinf(m[i]));
-#endif
-	}
+  const int n = 16;
+  for (int i = 0; i < n; i++) {
+#  if _MSC_VER
+    BLI_assert(_finite(m[i]));
+#  else
+    BLI_assert(!isinf(m[i]));
+#  endif
+  }
 }
 
-#define CHECKMAT(m) checkmat((const float *)m)
+#  define CHECKMAT(m) checkmat((const float *)m)
 
 #else
 
-#define CHECKMAT(m)
+#  define CHECKMAT(m)
 
 #endif
 
-
 void GPU_matrix_push(void)
 {
-	BLI_assert(ModelViewStack.top + 1 < MATRIX_STACK_DEPTH);
-	ModelViewStack.top++;
-	copy_m4_m4(ModelView, ModelViewStack.stack[ModelViewStack.top - 1]);
+  BLI_assert(ModelViewStack.top + 1 < MATRIX_STACK_DEPTH);
+  ModelViewStack.top++;
+  copy_m4_m4(ModelView, ModelViewStack.stack[ModelViewStack.top - 1]);
 }
 
 void GPU_matrix_pop(void)
 {
-	BLI_assert(ModelViewStack.top > 0);
-	ModelViewStack.top--;
-	state.dirty = true;
+  BLI_assert(ModelViewStack.top > 0);
+  ModelViewStack.top--;
+  state.dirty = true;
 }
 
 void GPU_matrix_push_projection(void)
 {
-	BLI_assert(ProjectionStack.top + 1 < MATRIX_STACK_DEPTH);
-	ProjectionStack.top++;
-	copy_m4_m4(Projection, ProjectionStack.stack[ProjectionStack.top - 1]);
+  BLI_assert(ProjectionStack.top + 1 < MATRIX_STACK_DEPTH);
+  ProjectionStack.top++;
+  copy_m4_m4(Projection, ProjectionStack.stack[ProjectionStack.top - 1]);
 }
 
 void GPU_matrix_pop_projection(void)
 {
-	BLI_assert(ProjectionStack.top > 0);
-	ProjectionStack.top--;
-	state.dirty = true;
+  BLI_assert(ProjectionStack.top > 0);
+  ProjectionStack.top--;
+  state.dirty = true;
 }
 
 void GPU_matrix_set(const float m[4][4])
 {
-	copy_m4_m4(ModelView, m);
-	CHECKMAT(ModelView3D);
-	state.dirty = true;
+  copy_m4_m4(ModelView, m);
+  CHECKMAT(ModelView3D);
+  state.dirty = true;
 }
 
 void GPU_matrix_identity_projection_set(void)
 {
-	unit_m4(Projection);
-	CHECKMAT(Projection3D);
-	state.dirty = true;
+  unit_m4(Projection);
+  CHECKMAT(Projection3D);
+  state.dirty = true;
 }
 
 void GPU_matrix_projection_set(const float m[4][4])
 {
-	copy_m4_m4(Projection, m);
-	CHECKMAT(Projection3D);
-	state.dirty = true;
+  copy_m4_m4(Projection, m);
+  CHECKMAT(Projection3D);
+  state.dirty = true;
 }
 
 void GPU_matrix_identity_set(void)
 {
-	unit_m4(ModelView);
-	state.dirty = true;
+  unit_m4(ModelView);
+  state.dirty = true;
 }
 
 void GPU_matrix_translate_2f(float x, float y)
 {
-	Mat4 m;
-	unit_m4(m);
-	m[3][0] = x;
-	m[3][1] = y;
-	GPU_matrix_mul(m);
+  Mat4 m;
+  unit_m4(m);
+  m[3][0] = x;
+  m[3][1] = y;
+  GPU_matrix_mul(m);
 }
 
 void GPU_matrix_translate_2fv(const float vec[2])
 {
-	GPU_matrix_translate_2f(vec[0], vec[1]);
+  GPU_matrix_translate_2f(vec[0], vec[1]);
 }
 
 void GPU_matrix_translate_3f(float x, float y, float z)
 {
 #if 1
-	translate_m4(ModelView, x, y, z);
-	CHECKMAT(ModelView);
+  translate_m4(ModelView, x, y, z);
+  CHECKMAT(ModelView);
 #else /* above works well in early testing, below is generic version */
-	Mat4 m;
-	unit_m4(m);
-	m[3][0] = x;
-	m[3][1] = y;
-	m[3][2] = z;
-	GPU_matrix_mul(m);
+  Mat4 m;
+  unit_m4(m);
+  m[3][0] = x;
+  m[3][1] = y;
+  m[3][2] = z;
+  GPU_matrix_mul(m);
 #endif
-	state.dirty = true;
+  state.dirty = true;
 }
 
 void GPU_matrix_translate_3fv(const float vec[3])
 {
-	GPU_matrix_translate_3f(vec[0], vec[1], vec[2]);
+  GPU_matrix_translate_3f(vec[0], vec[1], vec[2]);
 }
 
 void GPU_matrix_scale_1f(float factor)
 {
-	Mat4 m;
-	scale_m4_fl(m, factor);
-	GPU_matrix_mul(m);
+  Mat4 m;
+  scale_m4_fl(m, factor);
+  GPU_matrix_mul(m);
 }
 
 void GPU_matrix_scale_2f(float x, float y)
 {
-	Mat4 m = {{0.0f}};
-	m[0][0] = x;
-	m[1][1] = y;
-	m[2][2] = 1.0f;
-	m[3][3] = 1.0f;
-	GPU_matrix_mul(m);
+  Mat4 m = {{0.0f}};
+  m[0][0] = x;
+  m[1][1] = y;
+  m[2][2] = 1.0f;
+  m[3][3] = 1.0f;
+  GPU_matrix_mul(m);
 }
 
 void GPU_matrix_scale_2fv(const float vec[2])
 {
-	GPU_matrix_scale_2f(vec[0], vec[1]);
+  GPU_matrix_scale_2f(vec[0], vec[1]);
 }
 
 void GPU_matrix_scale_3f(float x, float y, float z)
 {
-	Mat4 m = {{0.0f}};
-	m[0][0] = x;
-	m[1][1] = y;
-	m[2][2] = z;
-	m[3][3] = 1.0f;
-	GPU_matrix_mul(m);
+  Mat4 m = {{0.0f}};
+  m[0][0] = x;
+  m[1][1] = y;
+  m[2][2] = z;
+  m[3][3] = 1.0f;
+  GPU_matrix_mul(m);
 }
 
 void GPU_matrix_scale_3fv(const float vec[3])
 {
-	GPU_matrix_scale_3f(vec[0], vec[1], vec[2]);
+  GPU_matrix_scale_3f(vec[0], vec[1], vec[2]);
 }
 
 void GPU_matrix_mul(const float m[4][4])
 {
-	mul_m4_m4_post(ModelView, m);
-	CHECKMAT(ModelView);
-	state.dirty = true;
+  mul_m4_m4_post(ModelView, m);
+  CHECKMAT(ModelView);
+  state.dirty = true;
 }
 
 void GPU_matrix_rotate_2d(float deg)
 {
-	/* essentially RotateAxis('Z')
-	 * TODO: simpler math for 2D case
-	 */
-	rotate_m4(ModelView, 'Z', DEG2RADF(deg));
+  /* essentially RotateAxis('Z')
+   * TODO: simpler math for 2D case
+   */
+  rotate_m4(ModelView, 'Z', DEG2RADF(deg));
 }
 
 void GPU_matrix_rotate_3f(float deg, float x, float y, float z)
 {
-	const float axis[3] = {x, y, z};
-	GPU_matrix_rotate_3fv(deg, axis);
+  const float axis[3] = {x, y, z};
+  GPU_matrix_rotate_3fv(deg, axis);
 }
 
 void GPU_matrix_rotate_3fv(float deg, const float axis[3])
 {
-	Mat4 m;
-	axis_angle_to_mat4(m, axis, DEG2RADF(deg));
-	GPU_matrix_mul(m);
+  Mat4 m;
+  axis_angle_to_mat4(m, axis, DEG2RADF(deg));
+  GPU_matrix_mul(m);
 }
 
 void GPU_matrix_rotate_axis(float deg, char axis)
 {
-	/* rotate_m4 works in place */
-	rotate_m4(ModelView, axis, DEG2RADF(deg));
-	CHECKMAT(ModelView);
-	state.dirty = true;
+  /* rotate_m4 works in place */
+  rotate_m4(ModelView, axis, DEG2RADF(deg));
+  CHECKMAT(ModelView);
+  state.dirty = true;
 }
 
-static void mat4_ortho_set(float m[4][4], float left, float right, float bottom, float top, float near, float far)
+static void mat4_ortho_set(
+    float m[4][4], float left, float right, float bottom, float top, float near, float far)
 {
-	m[0][0] = 2.0f / (right - left);
-	m[1][0] = 0.0f;
-	m[2][0] = 0.0f;
-	m[3][0] = -(right + left) / (right - left);
+  m[0][0] = 2.0f / (right - left);
+  m[1][0] = 0.0f;
+  m[2][0] = 0.0f;
+  m[3][0] = -(right + left) / (right - left);
 
-	m[0][1] = 0.0f;
-	m[1][1] = 2.0f / (top - bottom);
-	m[2][1] = 0.0f;
-	m[3][1] = -(top + bottom) / (top - bottom);
+  m[0][1] = 0.0f;
+  m[1][1] = 2.0f / (top - bottom);
+  m[2][1] = 0.0f;
+  m[3][1] = -(top + bottom) / (top - bottom);
 
-	m[0][2] = 0.0f;
-	m[1][2] = 0.0f;
-	m[2][2] = -2.0f / (far - near);
-	m[3][2] = -(far + near) / (far - near);
+  m[0][2] = 0.0f;
+  m[1][2] = 0.0f;
+  m[2][2] = -2.0f / (far - near);
+  m[3][2] = -(far + near) / (far - near);
 
-	m[0][3] = 0.0f;
-	m[1][3] = 0.0f;
-	m[2][3] = 0.0f;
-	m[3][3] = 1.0f;
+  m[0][3] = 0.0f;
+  m[1][3] = 0.0f;
+  m[2][3] = 0.0f;
+  m[3][3] = 1.0f;
 
-	state.dirty = true;
+  state.dirty = true;
 }
 
-static void mat4_frustum_set(float m[4][4], float left, float right, float bottom, float top, float near, float far)
+static void mat4_frustum_set(
+    float m[4][4], float left, float right, float bottom, float top, float near, float far)
 {
-	m[0][0] = 2.0f * near / (right - left);
-	m[1][0] = 0.0f;
-	m[2][0] = (right + left) / (right - left);
-	m[3][0] = 0.0f;
+  m[0][0] = 2.0f * near / (right - left);
+  m[1][0] = 0.0f;
+  m[2][0] = (right + left) / (right - left);
+  m[3][0] = 0.0f;
 
-	m[0][1] = 0.0f;
-	m[1][1] = 2.0f * near / (top - bottom);
-	m[2][1] = (top + bottom) / (top - bottom);
-	m[3][1] = 0.0f;
+  m[0][1] = 0.0f;
+  m[1][1] = 2.0f * near / (top - bottom);
+  m[2][1] = (top + bottom) / (top - bottom);
+  m[3][1] = 0.0f;
 
-	m[0][2] = 0.0f;
-	m[1][2] = 0.0f;
-	m[2][2] = -(far + near) / (far - near);
-	m[3][2] = -2.0f * far * near / (far - near);
+  m[0][2] = 0.0f;
+  m[1][2] = 0.0f;
+  m[2][2] = -(far + near) / (far - near);
+  m[3][2] = -2.0f * far * near / (far - near);
 
-	m[0][3] = 0.0f;
-	m[1][3] = 0.0f;
-	m[2][3] = -1.0f;
-	m[3][3] = 0.0f;
+  m[0][3] = 0.0f;
+  m[1][3] = 0.0f;
+  m[2][3] = -1.0f;
+  m[3][3] = 0.0f;
 
-	state.dirty = true;
+  state.dirty = true;
 }
 
 static void mat4_look_from_origin(float m[4][4], float lookdir[3], float camup[3])
 {
-/* This function is loosely based on Mesa implementation.
+  /* This function is loosely based on Mesa implementation.
  *
  * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
  * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
@@ -357,98 +360,111 @@ static void mat4_look_from_origin(float m[4][4], float lookdir[3], float camup[3
  * Silicon Graphics, Inc.
  */
 
-	float side[3];
+  float side[3];
 
-	normalize_v3(lookdir);
+  normalize_v3(lookdir);
 
-	cross_v3_v3v3(side, lookdir, camup);
+  cross_v3_v3v3(side, lookdir, camup);
 
-	normalize_v3(side);
+  normalize_v3(side);
 
-	cross_v3_v3v3(camup, side, lookdir);
+  cross_v3_v3v3(camup, side, lookdir);
 
-	m[0][0] = side[0];
-	m[1][0] = side[1];
-	m[2][0] = side[2];
-	m[3][0] = 0.0f;
+  m[0][0] = side[0];
+  m[1][0] = side[1];
+  m[2][0] = side[2];
+  m[3][0] = 0.0f;
 
-	m[0][1] = camup[0];
-	m[1][1] = camup[1];
-	m[2][1] = camup[2];
-	m[3][1] = 0.0f;
+  m[0][1] = camup[0];
+  m[1][1] = camup[1];
+  m[2][1] = camup[2];
+  m[3][1] = 0.0f;
 
-	m[0][2] = -lookdir[0];
-	m[1][2] = -lookdir[1];
-	m[2][2] = -lookdir[2];
-	m[3][2] = 0.0f;
+  m[0][2] = -lookdir[0];
+  m[1][2] = -lookdir[1];
+  m[2][2] = -lookdir[2];
+  m[3][2] = 0.0f;
 
-	m[0][3] = 0.0f;
-	m[1][3] = 0.0f;
-	m[2][3] = 0.0f;
-	m[3][3] = 1.0f;
+  m[0][3] = 0.0f;
+  m[1][3] = 0.0f;
+  m[2][3] = 0.0f;
+  m[3][3] = 1.0f;
 
-	state.dirty = true;
+  state.dirty = true;
 }
 
 void GPU_matrix_ortho_set(float left, float right, float bottom, float top, float near, float far)
 {
-	mat4_ortho_set(Projection, left, right, bottom, top, near, far);
-	CHECKMAT(Projection);
-	state.dirty = true;
+  mat4_ortho_set(Projection, left, right, bottom, top, near, far);
+  CHECKMAT(Projection);
+  state.dirty = true;
 }
 
 void GPU_matrix_ortho_2d_set(float left, float right, float bottom, float top)
 {
-	Mat4 m;
-	mat4_ortho_set(m, left, right, bottom, top, -1.0f, 1.0f);
-	CHECKMAT(Projection2D);
-	state.dirty = true;
+  Mat4 m;
+  mat4_ortho_set(m, left, right, bottom, top, -1.0f, 1.0f);
+  CHECKMAT(Projection2D);
+  state.dirty = true;
 }
 
-void GPU_matrix_frustum_set(float left, float right, float bottom, float top, float near, float far)
+void GPU_matrix_frustum_set(
+    float left, float right, float bottom, float top, float near, float far)
 {
-	mat4_frustum_set(Projection, left, right, bottom, top, near, far);
-	CHECKMAT(Projection);
-	state.dirty = true;
+  mat4_frustum_set(Projection, left, right, bottom, top, near, far);
+  CHECKMAT(Projection);
+  state.dirty = true;
 }
 
 void GPU_matrix_perspective_set(float fovy, float aspect, float near, float far)
 {
-	float half_height = tanf(fovy * (float)(M_PI / 360.0)) * near;
-	float half_width = half_height * aspect;
-	GPU_matrix_frustum_set(-half_width, +half_width, -half_height, +half_height, near, far);
+  float half_height = tanf(fovy * (float)(M_PI / 360.0)) * near;
+  float half_width = half_height * aspect;
+  GPU_matrix_frustum_set(-half_width, +half_width, -half_height, +half_height, near, far);
 }
 
-void GPU_matrix_look_at(float eyeX, float eyeY, float eyeZ, float centerX, float centerY, float centerZ, float upX, float upY, float upZ)
+void GPU_matrix_look_at(float eyeX,
+                        float eyeY,
+                        float eyeZ,
+                        float centerX,
+                        float centerY,
+                        float centerZ,
+                        float upX,
+                        float upY,
+                        float upZ)
 {
-	Mat4 cm;
-	float lookdir[3];
-	float camup[3] = {upX, upY, upZ};
+  Mat4 cm;
+  float lookdir[3];
+  float camup[3] = {upX, upY, upZ};
 
-	lookdir[0] = centerX - eyeX;
-	lookdir[1] = centerY - eyeY;
-	lookdir[2] = centerZ - eyeZ;
+  lookdir[0] = centerX - eyeX;
+  lookdir[1] = centerY - eyeY;
+  lookdir[2] = centerZ - eyeZ;
 
-	mat4_look_from_origin(cm, lookdir, camup);
+  mat4_look_from_origin(cm, lookdir, camup);
 
-	GPU_matrix_mul(cm);
-	GPU_matrix_translate_3f(-eyeX, -eyeY, -eyeZ);
+  GPU_matrix_mul(cm);
+  GPU_matrix_translate_3f(-eyeX, -eyeY, -eyeZ);
 }
 
-void GPU_matrix_project(const float world[3], const float model[4][4], const float proj[4][4], const int view[4], float win[3])
+void GPU_matrix_project(const float world[3],
+                        const float model[4][4],
+                        const float proj[4][4],
+                        const int view[4],
+                        float win[3])
 {
-	float v[4];
+  float v[4];
 
-	mul_v4_m4v3(v, model, world);
-	mul_m4_v4(proj, v);
+  mul_v4_m4v3(v, model, world);
+  mul_m4_v4(proj, v);
 
-	if (v[3] != 0.0f) {
-		mul_v3_fl(v, 1.0f / v[3]);
-	}
+  if (v[3] != 0.0f) {
+    mul_v3_fl(v, 1.0f / v[3]);
+  }
 
-	win[0] = view[0] + (view[2] * (v[0] + 1)) * 0.5f;
-	win[1] = view[1] + (view[3] * (v[1] + 1)) * 0.5f;
-	win[2] = (v[2] + 1) * 0.5f;
+  win[0] = view[0] + (view[2] * (v[0] + 1)) * 0.5f;
+  win[1] = view[1] + (view[3] * (v[1] + 1)) * 0.5f;
+  win[2] = (v[2] + 1) * 0.5f;
 }
 
 /**
@@ -468,179 +484,186 @@ void GPU_matrix_project(const float world[3], const float model[4][4], const flo
  */
 static void gpu_mul_invert_projmat_m4_unmapped_v3(const float projmat[4][4], float co[3])
 {
-	float left, right, bottom, top, near, far;
-	bool is_persp = projmat[3][3] == 0.0f;
+  float left, right, bottom, top, near, far;
+  bool is_persp = projmat[3][3] == 0.0f;
 
-	projmat_dimensions(
-	        projmat, &left, &right, &bottom, &top, &near, &far);
+  projmat_dimensions(projmat, &left, &right, &bottom, &top, &near, &far);
 
-	co[0] = left   + co[0] * (right - left);
-	co[1] = bottom + co[1] * (top - bottom);
+  co[0] = left + co[0] * (right - left);
+  co[1] = bottom + co[1] * (top - bottom);
 
-	if (is_persp) {
-		co[2] = far * near / (far + co[2] * (near - far));
-		co[0] *= co[2];
-		co[1] *= co[2];
-	}
-	else {
-		co[2] = near + co[2] * (far - near);
-	}
-	co[2] *= -1;
+  if (is_persp) {
+    co[2] = far * near / (far + co[2] * (near - far));
+    co[0] *= co[2];
+    co[1] *= co[2];
+  }
+  else {
+    co[2] = near + co[2] * (far - near);
+  }
+  co[2] *= -1;
 }
 
-bool GPU_matrix_unproject(const float win[3], const float model[4][4], const float proj[4][4], const int view[4], float world[3])
+bool GPU_matrix_unproject(const float win[3],
+                          const float model[4][4],
+                          const float proj[4][4],
+                          const int view[4],
+                          float world[3])
 {
-	float in[3];
-	float viewinv[4][4];
+  float in[3];
+  float viewinv[4][4];
 
-	if (!invert_m4_m4(viewinv, model)) {
-		zero_v3(world);
-		return false;
-	}
+  if (!invert_m4_m4(viewinv, model)) {
+    zero_v3(world);
+    return false;
+  }
 
-	copy_v3_v3(in, win);
+  copy_v3_v3(in, win);
 
-	/* Map x and y from window coordinates */
-	in[0] = (in[0] - view[0]) / view[2];
-	in[1] = (in[1] - view[1]) / view[3];
+  /* Map x and y from window coordinates */
+  in[0] = (in[0] - view[0]) / view[2];
+  in[1] = (in[1] - view[1]) / view[3];
 
-	gpu_mul_invert_projmat_m4_unmapped_v3(proj, in);
-	mul_v3_m4v3(world, viewinv, in);
+  gpu_mul_invert_projmat_m4_unmapped_v3(proj, in);
+  mul_v3_m4v3(world, viewinv, in);
 
-	return true;
+  return true;
 }
 
 const float (*GPU_matrix_model_view_get(float m[4][4]))[4]
 {
-	if (m) {
-		copy_m4_m4(m, ModelView);
-		return m;
-	}
-	else {
-		return ModelView;
-	}
+  if (m) {
+    copy_m4_m4(m, ModelView);
+    return m;
+  }
+  else {
+    return ModelView;
+  }
 }
 
 const float (*GPU_matrix_projection_get(float m[4][4]))[4]
 {
-	if (m) {
-		copy_m4_m4(m, Projection);
-		return m;
-	}
-	else {
-		return Projection;
-	}
+  if (m) {
+    copy_m4_m4(m, Projection);
+    return m;
+  }
+  else {
+    return Projection;
+  }
 }
 
 const float (*GPU_matrix_model_view_projection_get(float m[4][4]))[4]
 {
-	if (m == NULL) {
-		static Mat4 temp;
-		m = temp;
-	}
+  if (m == NULL) {
+    static Mat4 temp;
+    m = temp;
+  }
 
-	mul_m4_m4m4(m, Projection, ModelView);
-	return m;
+  mul_m4_m4m4(m, Projection, ModelView);
+  return m;
 }
 
 const float (*GPU_matrix_normal_get(float m[3][3]))[3]
 {
-	if (m == NULL) {
-		static Mat3 temp3;
-		m = temp3;
-	}
+  if (m == NULL) {
+    static Mat3 temp3;
+    m = temp3;
+  }
 
-	copy_m3_m4(m, (const float (*)[4])GPU_matrix_model_view_get(NULL));
+  copy_m3_m4(m, (const float(*)[4])GPU_matrix_model_view_get(NULL));
 
-	invert_m3(m);
-	transpose_m3(m);
+  invert_m3(m);
+  transpose_m3(m);
 
-	return m;
+  return m;
 }
 
 const float (*GPU_matrix_normal_inverse_get(float m[3][3]))[3]
 {
-	if (m == NULL) {
-		static Mat3 temp3;
-		m = temp3;
-	}
+  if (m == NULL) {
+    static Mat3 temp3;
+    m = temp3;
+  }
 
-	GPU_matrix_normal_get(m);
-	invert_m3(m);
+  GPU_matrix_normal_get(m);
+  invert_m3(m);
 
-	return m;
+  return m;
 }
 
 void GPU_matrix_bind(const GPUShaderInterface *shaderface)
 {
-	/* set uniform values to matrix stack values
-	 * call this before a draw call if desired matrices are dirty
-	 * call glUseProgram before this, as glUniform expects program to be bound
-	 */
+  /* set uniform values to matrix stack values
+   * call this before a draw call if desired matrices are dirty
+   * call glUseProgram before this, as glUniform expects program to be bound
+   */
 
-	const GPUShaderInput *MV = GPU_shaderinterface_uniform_builtin(shaderface, GPU_UNIFORM_MODELVIEW);
-	const GPUShaderInput *P = GPU_shaderinterface_uniform_builtin(shaderface, GPU_UNIFORM_PROJECTION);
-	const GPUShaderInput *MVP = GPU_shaderinterface_uniform_builtin(shaderface, GPU_UNIFORM_MVP);
+  const GPUShaderInput *MV = GPU_shaderinterface_uniform_builtin(shaderface,
+                                                                 GPU_UNIFORM_MODELVIEW);
+  const GPUShaderInput *P = GPU_shaderinterface_uniform_builtin(shaderface,
+                                                                GPU_UNIFORM_PROJECTION);
+  const GPUShaderInput *MVP = GPU_shaderinterface_uniform_builtin(shaderface, GPU_UNIFORM_MVP);
 
-	const GPUShaderInput *N = GPU_shaderinterface_uniform_builtin(shaderface, GPU_UNIFORM_NORMAL);
-	const GPUShaderInput *MV_inv = GPU_shaderinterface_uniform_builtin(shaderface, GPU_UNIFORM_MODELVIEW_INV);
-	const GPUShaderInput *P_inv = GPU_shaderinterface_uniform_builtin(shaderface, GPU_UNIFORM_PROJECTION_INV);
+  const GPUShaderInput *N = GPU_shaderinterface_uniform_builtin(shaderface, GPU_UNIFORM_NORMAL);
+  const GPUShaderInput *MV_inv = GPU_shaderinterface_uniform_builtin(shaderface,
+                                                                     GPU_UNIFORM_MODELVIEW_INV);
+  const GPUShaderInput *P_inv = GPU_shaderinterface_uniform_builtin(shaderface,
+                                                                    GPU_UNIFORM_PROJECTION_INV);
 
-	if (MV) {
+  if (MV) {
 #if DEBUG_MATRIX_BIND
-		puts("setting MV matrix");
+    puts("setting MV matrix");
 #endif
 
-		glUniformMatrix4fv(MV->location, 1, GL_FALSE, (const float *)GPU_matrix_model_view_get(NULL));
-	}
+    glUniformMatrix4fv(MV->location, 1, GL_FALSE, (const float *)GPU_matrix_model_view_get(NULL));
+  }
 
-	if (P) {
+  if (P) {
 #if DEBUG_MATRIX_BIND
-		puts("setting P matrix");
+    puts("setting P matrix");
 #endif
 
-		glUniformMatrix4fv(P->location, 1, GL_FALSE, (const float *)GPU_matrix_projection_get(NULL));
-	}
+    glUniformMatrix4fv(P->location, 1, GL_FALSE, (const float *)GPU_matrix_projection_get(NULL));
+  }
 
-	if (MVP) {
+  if (MVP) {
 #if DEBUG_MATRIX_BIND
-		puts("setting MVP matrix");
+    puts("setting MVP matrix");
 #endif
 
-		glUniformMatrix4fv(MVP->location, 1, GL_FALSE, (const float *)GPU_matrix_model_view_projection_get(NULL));
-	}
+    glUniformMatrix4fv(
+        MVP->location, 1, GL_FALSE, (const float *)GPU_matrix_model_view_projection_get(NULL));
+  }
 
-	if (N) {
+  if (N) {
 #if DEBUG_MATRIX_BIND
-		puts("setting normal matrix");
+    puts("setting normal matrix");
 #endif
 
-		glUniformMatrix3fv(N->location, 1, GL_FALSE, (const float *)GPU_matrix_normal_get(NULL));
-	}
+    glUniformMatrix3fv(N->location, 1, GL_FALSE, (const float *)GPU_matrix_normal_get(NULL));
+  }
 
-	if (MV_inv) {
-		Mat4 m;
-		GPU_matrix_model_view_get(m);
-		invert_m4(m);
-		glUniformMatrix4fv(MV_inv->location, 1, GL_FALSE, (const float *)m);
-	}
+  if (MV_inv) {
+    Mat4 m;
+    GPU_matrix_model_view_get(m);
+    invert_m4(m);
+    glUniformMatrix4fv(MV_inv->location, 1, GL_FALSE, (const float *)m);
+  }
 
-	if (P_inv) {
-		Mat4 m;
-		GPU_matrix_projection_get(m);
-		invert_m4(m);
-		glUniformMatrix4fv(P_inv->location, 1, GL_FALSE, (const float *)m);
-	}
+  if (P_inv) {
+    Mat4 m;
+    GPU_matrix_projection_get(m);
+    invert_m4(m);
+    glUniformMatrix4fv(P_inv->location, 1, GL_FALSE, (const float *)m);
+  }
 
-	state.dirty = false;
+  state.dirty = false;
 }
 
 bool GPU_matrix_dirty_get(void)
 {
-	return state.dirty;
+  return state.dirty;
 }
 
-
 /* -------------------------------------------------------------------- */
 /** \name Python API Helpers
  * \{ */
@@ -650,12 +673,12 @@ BLI_STATIC_ASSERT(GPU_PY_MATRIX_STACK_LEN + 1 == MATRIX_STACK_DEPTH, "define mis
 
 int GPU_matrix_stack_level_get_model_view(void)
 {
-	return (int)state.model_view_stack.top;
+  return (int)state.model_view_stack.top;
 }
 
 int GPU_matrix_stack_level_get_projection(void)
 {
-	return (int)state.projection_stack.top;
+  return (int)state.projection_stack.top;
 }
 
 /** \} */