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

10 files changed, 308 insertions, 314 deletions

diff --git a/intern/eigen/CMakeLists.txt b/intern/eigen/CMakeLists.txt
index 650a1aa63c1..70088d080e1 100644
--- a/intern/eigen/CMakeLists.txt
+++ b/intern/eigen/CMakeLists.txt
@@ -19,25 +19,25 @@
 # ***** END GPL LICENSE BLOCK *****
 
 set(INC
-	.
+  .
 )
 
 set(INC_SYS
-	${EIGEN3_INCLUDE_DIRS}
+  ${EIGEN3_INCLUDE_DIRS}
 )
 
 set(SRC
-	eigen_capi.h
+  eigen_capi.h
 
-	intern/eigenvalues.cc
-	intern/linear_solver.cc
-	intern/matrix.cc
-	intern/svd.cc
+  intern/eigenvalues.cc
+  intern/linear_solver.cc
+  intern/matrix.cc
+  intern/svd.cc
 
-	intern/eigenvalues.h
-	intern/linear_solver.h
-	intern/matrix.h
-	intern/svd.h
+  intern/eigenvalues.h
+  intern/linear_solver.h
+  intern/matrix.h
+  intern/svd.h
 )
 
 set(LIB
diff --git a/intern/eigen/eigen_capi.h b/intern/eigen/eigen_capi.h
index 5660b28259f..52ec489159f 100644
--- a/intern/eigen/eigen_capi.h
+++ b/intern/eigen/eigen_capi.h
@@ -25,4 +25,4 @@
 #include "intern/matrix.h"
 #include "intern/svd.h"
 
-#endif  /* __EIGEN_C_API_H__ */
+#endif /* __EIGEN_C_API_H__ */
diff --git a/intern/eigen/intern/eigenvalues.cc b/intern/eigen/intern/eigenvalues.cc
index 3625df826d5..8a48ae5f17a 100644
--- a/intern/eigen/intern/eigenvalues.cc
+++ b/intern/eigen/intern/eigenvalues.cc
@@ -32,32 +32,35 @@
 
 using Eigen::SelfAdjointEigenSolver;
 
+using Eigen::Map;
 using Eigen::MatrixXf;
 using Eigen::VectorXf;
-using Eigen::Map;
 
 using Eigen::Success;
 
-bool EIG_self_adjoint_eigen_solve(const int size, const float *matrix, float *r_eigen_values, float *r_eigen_vectors)
+bool EIG_self_adjoint_eigen_solve(const int size,
+                                  const float *matrix,
+                                  float *r_eigen_values,
+                                  float *r_eigen_vectors)
 {
-	SelfAdjointEigenSolver<MatrixXf> eigen_solver;
+  SelfAdjointEigenSolver<MatrixXf> eigen_solver;
 
-	/* Blender and Eigen matrices are both column-major. */
-	eigen_solver.compute(Map<MatrixXf>((float *)matrix, size, size));
+  /* Blender and Eigen matrices are both column-major. */
+  eigen_solver.compute(Map<MatrixXf>((float *)matrix, size, size));
 
-	if (eigen_solver.info() != Success) {
-		return false;
-	}
+  if (eigen_solver.info() != Success) {
+    return false;
+  }
 
-	if (r_eigen_values) {
-		Map<VectorXf>(r_eigen_values, size) = eigen_solver.eigenvalues().transpose();
-	}
+  if (r_eigen_values) {
+    Map<VectorXf>(r_eigen_values, size) = eigen_solver.eigenvalues().transpose();
+  }
 
-	if (r_eigen_vectors) {
-		Map<MatrixXf>(r_eigen_vectors, size, size) = eigen_solver.eigenvectors();
-	}
+  if (r_eigen_vectors) {
+    Map<MatrixXf>(r_eigen_vectors, size, size) = eigen_solver.eigenvectors();
+  }
 
-	return true;
+  return true;
 }
 
-#endif  /* __EIGEN3_EIGENVALUES_C_API_CC__ */
+#endif /* __EIGEN3_EIGENVALUES_C_API_CC__ */
diff --git a/intern/eigen/intern/eigenvalues.h b/intern/eigen/intern/eigenvalues.h
index 76388365af7..fabbdd87207 100644
--- a/intern/eigen/intern/eigenvalues.h
+++ b/intern/eigen/intern/eigenvalues.h
@@ -24,10 +24,13 @@
 extern "C" {
 #endif
 
-bool EIG_self_adjoint_eigen_solve(const int size, const float *matrix, float *r_eigen_values, float *r_eigen_vectors);
+bool EIG_self_adjoint_eigen_solve(const int size,
+                                  const float *matrix,
+                                  float *r_eigen_values,
+                                  float *r_eigen_vectors);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif  /* __EIGEN3_EIGENVALUES_C_API_H__ */
+#endif /* __EIGEN3_EIGENVALUES_C_API_H__ */
diff --git a/intern/eigen/intern/linear_solver.cc b/intern/eigen/intern/linear_solver.cc
index 0fc4d39309b..bce5937409c 100644
--- a/intern/eigen/intern/linear_solver.cc
+++ b/intern/eigen/intern/linear_solver.cc
@@ -41,326 +41,318 @@ typedef Eigen::Triplet<double> EigenTriplet;
 
 /* Linear Solver data structure */
 
-struct LinearSolver
-{
-	struct Coeff
-	{
-		Coeff()
-		{
-			index = 0;
-			value = 0.0;
-		}
-
-		int index;
-		double value;
-	};
-
-	struct Variable
-	{
-		Variable()
-		{
-			memset(value, 0, sizeof(value));
-			locked = false;
-			index = 0;
-		}
-
-		double value[4];
-		bool locked;
-		int index;
-		std::vector<Coeff> a;
-	};
-
-	enum State
-	{
-		STATE_VARIABLES_CONSTRUCT,
-		STATE_MATRIX_CONSTRUCT,
-		STATE_MATRIX_SOLVED
-	};
-
-	LinearSolver(int num_rows_, int num_variables_, int num_rhs_, bool lsq_)
-	{
-		assert(num_variables_ > 0);
-		assert(num_rhs_ <= 4);
-
-		state = STATE_VARIABLES_CONSTRUCT;
-		m = 0;
-		n = 0;
-		sparseLU = NULL;
-		num_variables = num_variables_;
-		num_rhs = num_rhs_;
-		num_rows = num_rows_;
-		least_squares = lsq_;
-
-		variable.resize(num_variables);
-	}
-
-	~LinearSolver()
-	{
-		delete sparseLU;
-	}
-
-	State state;
-
-	int n;
-	int m;
-
-	std::vector<EigenTriplet> Mtriplets;
-	EigenSparseMatrix M;
-	EigenSparseMatrix MtM;
-	std::vector<EigenVectorX> b;
-	std::vector<EigenVectorX> x;
-
-	EigenSparseLU *sparseLU;
-
-	int num_variables;
-	std::vector<Variable> variable;
-
-	int num_rows;
-	int num_rhs;
-
-	bool least_squares;
+struct LinearSolver {
+  struct Coeff {
+    Coeff()
+    {
+      index = 0;
+      value = 0.0;
+    }
+
+    int index;
+    double value;
+  };
+
+  struct Variable {
+    Variable()
+    {
+      memset(value, 0, sizeof(value));
+      locked = false;
+      index = 0;
+    }
+
+    double value[4];
+    bool locked;
+    int index;
+    std::vector<Coeff> a;
+  };
+
+  enum State { STATE_VARIABLES_CONSTRUCT, STATE_MATRIX_CONSTRUCT, STATE_MATRIX_SOLVED };
+
+  LinearSolver(int num_rows_, int num_variables_, int num_rhs_, bool lsq_)
+  {
+    assert(num_variables_ > 0);
+    assert(num_rhs_ <= 4);
+
+    state = STATE_VARIABLES_CONSTRUCT;
+    m = 0;
+    n = 0;
+    sparseLU = NULL;
+    num_variables = num_variables_;
+    num_rhs = num_rhs_;
+    num_rows = num_rows_;
+    least_squares = lsq_;
+
+    variable.resize(num_variables);
+  }
+
+  ~LinearSolver()
+  {
+    delete sparseLU;
+  }
+
+  State state;
+
+  int n;
+  int m;
+
+  std::vector<EigenTriplet> Mtriplets;
+  EigenSparseMatrix M;
+  EigenSparseMatrix MtM;
+  std::vector<EigenVectorX> b;
+  std::vector<EigenVectorX> x;
+
+  EigenSparseLU *sparseLU;
+
+  int num_variables;
+  std::vector<Variable> variable;
+
+  int num_rows;
+  int num_rhs;
+
+  bool least_squares;
 };
 
 LinearSolver *EIG_linear_solver_new(int num_rows, int num_columns, int num_rhs)
 {
-	return new LinearSolver(num_rows, num_columns, num_rhs, false);
+  return new LinearSolver(num_rows, num_columns, num_rhs, false);
 }
 
 LinearSolver *EIG_linear_least_squares_solver_new(int num_rows, int num_columns, int num_rhs)
 {
-	return new LinearSolver(num_rows, num_columns, num_rhs, true);
+  return new LinearSolver(num_rows, num_columns, num_rhs, true);
 }
 
 void EIG_linear_solver_delete(LinearSolver *solver)
 {
-	delete solver;
+  delete solver;
 }
 
 /* Variables */
 
 void EIG_linear_solver_variable_set(LinearSolver *solver, int rhs, int index, double value)
 {
-	solver->variable[index].value[rhs] = value;
+  solver->variable[index].value[rhs] = value;
 }
 
 double EIG_linear_solver_variable_get(LinearSolver *solver, int rhs, int index)
 {
-	return solver->variable[index].value[rhs];
+  return solver->variable[index].value[rhs];
 }
 
 void EIG_linear_solver_variable_lock(LinearSolver *solver, int index)
 {
-	if (!solver->variable[index].locked) {
-		assert(solver->state == LinearSolver::STATE_VARIABLES_CONSTRUCT);
-		solver->variable[index].locked = true;
-	}
+  if (!solver->variable[index].locked) {
+    assert(solver->state == LinearSolver::STATE_VARIABLES_CONSTRUCT);
+    solver->variable[index].locked = true;
+  }
 }
 
 void EIG_linear_solver_variable_unlock(LinearSolver *solver, int index)
 {
-	if (solver->variable[index].locked) {
-		assert(solver->state == LinearSolver::STATE_VARIABLES_CONSTRUCT);
-		solver->variable[index].locked = false;
-	}
+  if (solver->variable[index].locked) {
+    assert(solver->state == LinearSolver::STATE_VARIABLES_CONSTRUCT);
+    solver->variable[index].locked = false;
+  }
 }
 
 static void linear_solver_variables_to_vector(LinearSolver *solver)
 {
-	int num_rhs = solver->num_rhs;
-
-	for (int i = 0; i < solver->num_variables; i++) {
-		LinearSolver::Variable* v = &solver->variable[i];
-		if (!v->locked) {
-			for (int j = 0; j < num_rhs; j++)
-				solver->x[j][v->index] = v->value[j];
-		}
-	}
+  int num_rhs = solver->num_rhs;
+
+  for (int i = 0; i < solver->num_variables; i++) {
+    LinearSolver::Variable *v = &solver->variable[i];
+    if (!v->locked) {
+      for (int j = 0; j < num_rhs; j++)
+        solver->x[j][v->index] = v->value[j];
+    }
+  }
 }
 
 static void linear_solver_vector_to_variables(LinearSolver *solver)
 {
-	int num_rhs = solver->num_rhs;
-
-	for (int i = 0; i < solver->num_variables; i++) {
-		LinearSolver::Variable* v = &solver->variable[i];
-		if (!v->locked) {
-			for (int j = 0; j < num_rhs; j++)
-				v->value[j] = solver->x[j][v->index];
-		}
-	}
+  int num_rhs = solver->num_rhs;
+
+  for (int i = 0; i < solver->num_variables; i++) {
+    LinearSolver::Variable *v = &solver->variable[i];
+    if (!v->locked) {
+      for (int j = 0; j < num_rhs; j++)
+        v->value[j] = solver->x[j][v->index];
+    }
+  }
 }
 
 /* Matrix */
 
 static void linear_solver_ensure_matrix_construct(LinearSolver *solver)
 {
-	/* transition to matrix construction if necessary */
-	if (solver->state == LinearSolver::STATE_VARIABLES_CONSTRUCT) {
-		int n = 0;
+  /* transition to matrix construction if necessary */
+  if (solver->state == LinearSolver::STATE_VARIABLES_CONSTRUCT) {
+    int n = 0;
 
-		for (int i = 0; i < solver->num_variables; i++) {
-			if (solver->variable[i].locked)
-				solver->variable[i].index = ~0;
-			else
-				solver->variable[i].index = n++;
-		}
+    for (int i = 0; i < solver->num_variables; i++) {
+      if (solver->variable[i].locked)
+        solver->variable[i].index = ~0;
+      else
+        solver->variable[i].index = n++;
+    }
 
-		int m = (solver->num_rows == 0)? n: solver->num_rows;
+    int m = (solver->num_rows == 0) ? n : solver->num_rows;
 
-		solver->m = m;
-		solver->n = n;
+    solver->m = m;
+    solver->n = n;
 
-		assert(solver->least_squares || m == n);
+    assert(solver->least_squares || m == n);
 
-		/* reserve reasonable estimate */
-		solver->Mtriplets.clear();
-		solver->Mtriplets.reserve(std::max(m, n)*3);
+    /* reserve reasonable estimate */
+    solver->Mtriplets.clear();
+    solver->Mtriplets.reserve(std::max(m, n) * 3);
 
-		solver->b.resize(solver->num_rhs);
-		solver->x.resize(solver->num_rhs);
+    solver->b.resize(solver->num_rhs);
+    solver->x.resize(solver->num_rhs);
 
-		for (int i = 0; i < solver->num_rhs; i++) {
-			solver->b[i].setZero(m);
-			solver->x[i].setZero(n);
-		}
+    for (int i = 0; i < solver->num_rhs; i++) {
+      solver->b[i].setZero(m);
+      solver->x[i].setZero(n);
+    }
 
-		linear_solver_variables_to_vector(solver);
+    linear_solver_variables_to_vector(solver);
 
-		solver->state = LinearSolver::STATE_MATRIX_CONSTRUCT;
-	}
+    solver->state = LinearSolver::STATE_MATRIX_CONSTRUCT;
+  }
 }
 
 void EIG_linear_solver_matrix_add(LinearSolver *solver, int row, int col, double value)
 {
-	if (solver->state == LinearSolver::STATE_MATRIX_SOLVED)
-		return;
-
-	linear_solver_ensure_matrix_construct(solver);
-
-	if (!solver->least_squares && solver->variable[row].locked);
-	else if (solver->variable[col].locked) {
-		if (!solver->least_squares)
-			row = solver->variable[row].index;
-
-		LinearSolver::Coeff coeff;
-		coeff.index = row;
-		coeff.value = value;
-		solver->variable[col].a.push_back(coeff);
-	}
-	else {
-		if (!solver->least_squares)
-			row = solver->variable[row].index;
-		col = solver->variable[col].index;
-
-		/* direct insert into matrix is too slow, so use triplets */
-		EigenTriplet triplet(row, col, value);
-		solver->Mtriplets.push_back(triplet);
-	}
+  if (solver->state == LinearSolver::STATE_MATRIX_SOLVED)
+    return;
+
+  linear_solver_ensure_matrix_construct(solver);
+
+  if (!solver->least_squares && solver->variable[row].locked)
+    ;
+  else if (solver->variable[col].locked) {
+    if (!solver->least_squares)
+      row = solver->variable[row].index;
+
+    LinearSolver::Coeff coeff;
+    coeff.index = row;
+    coeff.value = value;
+    solver->variable[col].a.push_back(coeff);
+  }
+  else {
+    if (!solver->least_squares)
+      row = solver->variable[row].index;
+    col = solver->variable[col].index;
+
+    /* direct insert into matrix is too slow, so use triplets */
+    EigenTriplet triplet(row, col, value);
+    solver->Mtriplets.push_back(triplet);
+  }
 }
 
 /* Right hand side */
 
 void EIG_linear_solver_right_hand_side_add(LinearSolver *solver, int rhs, int index, double value)
 {
-	linear_solver_ensure_matrix_construct(solver);
-
-	if (solver->least_squares) {
-		solver->b[rhs][index] += value;
-	}
-	else if (!solver->variable[index].locked) {
-		index = solver->variable[index].index;
-		solver->b[rhs][index] += value;
-	}
+  linear_solver_ensure_matrix_construct(solver);
+
+  if (solver->least_squares) {
+    solver->b[rhs][index] += value;
+  }
+  else if (!solver->variable[index].locked) {
+    index = solver->variable[index].index;
+    solver->b[rhs][index] += value;
+  }
 }
 
 /* Solve */
 
 bool EIG_linear_solver_solve(LinearSolver *solver)
 {
-	/* nothing to solve, perhaps all variables were locked */
-	if (solver->m == 0 || solver->n == 0)
-		return true;
-
-	bool result = true;
-
-	assert(solver->state != LinearSolver::STATE_VARIABLES_CONSTRUCT);
-
-	if (solver->state == LinearSolver::STATE_MATRIX_CONSTRUCT) {
-		/* create matrix from triplets */
-		solver->M.resize(solver->m, solver->n);
-		solver->M.setFromTriplets(solver->Mtriplets.begin(), solver->Mtriplets.end());
-		solver->Mtriplets.clear();
-
-		/* create least squares matrix */
-		if (solver->least_squares)
-			solver->MtM = solver->M.transpose() * solver->M;
-
-		/* convert M to compressed column format */
-		EigenSparseMatrix& M = (solver->least_squares)? solver->MtM: solver->M;
-		M.makeCompressed();
-
-		/* perform sparse LU factorization */
-		EigenSparseLU *sparseLU = new EigenSparseLU();
-		solver->sparseLU = sparseLU;
-
-		sparseLU->compute(M);
-		result = (sparseLU->info() == Eigen::Success);
-
-		solver->state = LinearSolver::STATE_MATRIX_SOLVED;
-	}
-
-	if (result) {
-		/* solve for each right hand side */
-		for (int rhs = 0; rhs < solver->num_rhs; rhs++) {
-			/* modify for locked variables */
-			EigenVectorX& b = solver->b[rhs];
-
-			for (int i = 0; i < solver->num_variables; i++) {
-				LinearSolver::Variable *variable = &solver->variable[i];
-
-				if (variable->locked) {
-					std::vector<LinearSolver::Coeff>& a = variable->a;
-
-					for (int j = 0; j < a.size(); j++)
-						b[a[j].index] -= a[j].value*variable->value[rhs];
-				}
-			}
-
-			/* solve */
-			if (solver->least_squares) {
-				EigenVectorX Mtb = solver->M.transpose() * b;
-				solver->x[rhs] = solver->sparseLU->solve(Mtb);
-			}
-			else {
-				EigenVectorX& b = solver->b[rhs];
-				solver->x[rhs] = solver->sparseLU->solve(b);
-			}
-
-			if (solver->sparseLU->info() != Eigen::Success)
-				result = false;
-		}
-
-		if (result)
-			linear_solver_vector_to_variables(solver);
-	}
-
-	/* clear for next solve */
-	for (int rhs = 0; rhs < solver->num_rhs; rhs++)
-		solver->b[rhs].setZero(solver->m);
-
-	return result;
+  /* nothing to solve, perhaps all variables were locked */
+  if (solver->m == 0 || solver->n == 0)
+    return true;
+
+  bool result = true;
+
+  assert(solver->state != LinearSolver::STATE_VARIABLES_CONSTRUCT);
+
+  if (solver->state == LinearSolver::STATE_MATRIX_CONSTRUCT) {
+    /* create matrix from triplets */
+    solver->M.resize(solver->m, solver->n);
+    solver->M.setFromTriplets(solver->Mtriplets.begin(), solver->Mtriplets.end());
+    solver->Mtriplets.clear();
+
+    /* create least squares matrix */
+    if (solver->least_squares)
+      solver->MtM = solver->M.transpose() * solver->M;
+
+    /* convert M to compressed column format */
+    EigenSparseMatrix &M = (solver->least_squares) ? solver->MtM : solver->M;
+    M.makeCompressed();
+
+    /* perform sparse LU factorization */
+    EigenSparseLU *sparseLU = new EigenSparseLU();
+    solver->sparseLU = sparseLU;
+
+    sparseLU->compute(M);
+    result = (sparseLU->info() == Eigen::Success);
+
+    solver->state = LinearSolver::STATE_MATRIX_SOLVED;
+  }
+
+  if (result) {
+    /* solve for each right hand side */
+    for (int rhs = 0; rhs < solver->num_rhs; rhs++) {
+      /* modify for locked variables */
+      EigenVectorX &b = solver->b[rhs];
+
+      for (int i = 0; i < solver->num_variables; i++) {
+        LinearSolver::Variable *variable = &solver->variable[i];
+
+        if (variable->locked) {
+          std::vector<LinearSolver::Coeff> &a = variable->a;
+
+          for (int j = 0; j < a.size(); j++)
+            b[a[j].index] -= a[j].value * variable->value[rhs];
+        }
+      }
+
+      /* solve */
+      if (solver->least_squares) {
+        EigenVectorX Mtb = solver->M.transpose() * b;
+        solver->x[rhs] = solver->sparseLU->solve(Mtb);
+      }
+      else {
+        EigenVectorX &b = solver->b[rhs];
+        solver->x[rhs] = solver->sparseLU->solve(b);
+      }
+
+      if (solver->sparseLU->info() != Eigen::Success)
+        result = false;
+    }
+
+    if (result)
+      linear_solver_vector_to_variables(solver);
+  }
+
+  /* clear for next solve */
+  for (int rhs = 0; rhs < solver->num_rhs; rhs++)
+    solver->b[rhs].setZero(solver->m);
+
+  return result;
 }
 
 /* Debugging */
 
 void EIG_linear_solver_print_matrix(LinearSolver *solver)
 {
-	std::cout << "A:" << solver->M << std::endl;
+  std::cout << "A:" << solver->M << std::endl;
 
-	for (int rhs = 0; rhs < solver->num_rhs; rhs++)
-		std::cout << "b " << rhs << ":" << solver->b[rhs] << std::endl;
+  for (int rhs = 0; rhs < solver->num_rhs; rhs++)
+    std::cout << "b " << rhs << ":" << solver->b[rhs] << std::endl;
 
-	if (solver->MtM.rows() && solver->MtM.cols())
-		std::cout << "AtA:" << solver->MtM << std::endl;
+  if (solver->MtM.rows() && solver->MtM.cols())
+    std::cout << "AtA:" << solver->MtM << std::endl;
 }
-
diff --git a/intern/eigen/intern/linear_solver.h b/intern/eigen/intern/linear_solver.h
index 8f07e24e9a6..4da1ec05cd0 100644
--- a/intern/eigen/intern/linear_solver.h
+++ b/intern/eigen/intern/linear_solver.h
@@ -34,15 +34,11 @@ extern "C" {
 
 typedef struct LinearSolver LinearSolver;
 
-LinearSolver *EIG_linear_solver_new(
-	int num_rows,
-	int num_columns,
-	int num_right_hand_sides);
+LinearSolver *EIG_linear_solver_new(int num_rows, int num_columns, int num_right_hand_sides);
 
-LinearSolver *EIG_linear_least_squares_solver_new(
-	int num_rows,
-	int num_columns,
-	int num_right_hand_sides);
+LinearSolver *EIG_linear_least_squares_solver_new(int num_rows,
+                                                  int num_columns,
+                                                  int num_right_hand_sides);
 
 void EIG_linear_solver_delete(LinearSolver *solver);
 
@@ -69,4 +65,3 @@ void EIG_linear_solver_print_matrix(LinearSolver *solver);
 #ifdef __cplusplus
 }
 #endif
-
diff --git a/intern/eigen/intern/matrix.cc b/intern/eigen/intern/matrix.cc
index 961afe7e2a4..2024a1ba59a 100644
--- a/intern/eigen/intern/matrix.cc
+++ b/intern/eigen/intern/matrix.cc
@@ -25,7 +25,7 @@
 #  pragma GCC diagnostic ignored "-Wlogical-op"
 #endif
 
-#ifdef __EIGEN3_MATRIX_C_API_CC__  /* quiet warning */
+#ifdef __EIGEN3_MATRIX_C_API_CC__ /* quiet warning */
 #endif
 
 #include <Eigen/Core>
@@ -38,15 +38,15 @@ using Eigen::Matrix4f;
 
 bool EIG_invert_m4_m4(float inverse[4][4], const float matrix[4][4])
 {
-	Map<Matrix4f> M = Map<Matrix4f>((float*)matrix);
-	Matrix4f R;
-	bool invertible = true;
-	M.computeInverseWithCheck(R, invertible, 0.0f);
-	if (!invertible) {
-		R = R.Zero();
-	}
-	memcpy(inverse, R.data(), sizeof(float)*4*4);
-	return invertible;
+  Map<Matrix4f> M = Map<Matrix4f>((float *)matrix);
+  Matrix4f R;
+  bool invertible = true;
+  M.computeInverseWithCheck(R, invertible, 0.0f);
+  if (!invertible) {
+    R = R.Zero();
+  }
+  memcpy(inverse, R.data(), sizeof(float) * 4 * 4);
+  return invertible;
 }
 
-#endif  /* __EIGEN3_MATRIX_C_API_CC__ */
+#endif /* __EIGEN3_MATRIX_C_API_CC__ */
diff --git a/intern/eigen/intern/matrix.h b/intern/eigen/intern/matrix.h
index 78eb09c7578..91ef5e0713d 100644
--- a/intern/eigen/intern/matrix.h
+++ b/intern/eigen/intern/matrix.h
@@ -30,4 +30,4 @@ bool EIG_invert_m4_m4(float inverse[4][4], const float matrix[4][4]);
 }
 #endif
 
-#endif  /* __EIGEN3_MATRIX_C_API_H__ */
+#endif /* __EIGEN3_MATRIX_C_API_H__ */
diff --git a/intern/eigen/intern/svd.cc b/intern/eigen/intern/svd.cc
index eeba4c6273e..945d1bdee14 100644
--- a/intern/eigen/intern/svd.cc
+++ b/intern/eigen/intern/svd.cc
@@ -25,7 +25,7 @@
 #  pragma GCC diagnostic ignored "-Wlogical-op"
 #endif
 
-#ifdef __EIGEN3_SVD_C_API_CC__  /* quiet warning */
+#ifdef __EIGEN3_SVD_C_API_CC__ /* quiet warning */
 #endif
 
 #include <Eigen/Core>
@@ -41,31 +41,31 @@ using Eigen::NoQRPreconditioner;
 using Eigen::ComputeThinU;
 using Eigen::ComputeThinV;
 
+using Eigen::Map;
 using Eigen::MatrixXf;
 using Eigen::VectorXf;
-using Eigen::Map;
 
 using Eigen::Matrix4f;
 
 void EIG_svd_square_matrix(const int size, const float *matrix, float *r_U, float *r_S, float *r_V)
 {
-	/* Since our matrix is squared, we can use thinU/V. */
-	unsigned int flags = (r_U ? ComputeThinU : 0) | (r_V ? ComputeThinV : 0);
+  /* Since our matrix is squared, we can use thinU/V. */
+  unsigned int flags = (r_U ? ComputeThinU : 0) | (r_V ? ComputeThinV : 0);
 
-	/* Blender and Eigen matrices are both column-major. */
-	JacobiSVD<MatrixXf, NoQRPreconditioner> svd(Map<MatrixXf>((float *)matrix, size, size), flags);
+  /* Blender and Eigen matrices are both column-major. */
+  JacobiSVD<MatrixXf, NoQRPreconditioner> svd(Map<MatrixXf>((float *)matrix, size, size), flags);
 
-	if (r_U) {
-		Map<MatrixXf>(r_U, size, size) = svd.matrixU();
-	}
+  if (r_U) {
+    Map<MatrixXf>(r_U, size, size) = svd.matrixU();
+  }
 
-	if (r_S) {
-		Map<VectorXf>(r_S, size) = svd.singularValues();
-	}
+  if (r_S) {
+    Map<VectorXf>(r_S, size) = svd.singularValues();
+  }
 
-	if (r_V) {
-		Map<MatrixXf>(r_V, size, size) = svd.matrixV();
-	}
+  if (r_V) {
+    Map<MatrixXf>(r_V, size, size) = svd.matrixV();
+  }
 }
 
-#endif  /* __EIGEN3_SVD_C_API_CC__ */
+#endif /* __EIGEN3_SVD_C_API_CC__ */
diff --git a/intern/eigen/intern/svd.h b/intern/eigen/intern/svd.h
index 4659fa7a4e2..80238621920 100644
--- a/intern/eigen/intern/svd.h
+++ b/intern/eigen/intern/svd.h
@@ -24,10 +24,11 @@
 extern "C" {
 #endif
 
-void EIG_svd_square_matrix(const int size, const float *matrix, float *r_U, float *r_S, float *r_V);
+void EIG_svd_square_matrix(
+    const int size, const float *matrix, float *r_U, float *r_S, float *r_V);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif  /* __EIGEN3_SVD_C_API_H__ */
+#endif /* __EIGEN3_SVD_C_API_H__ */