Cleanup: use post increment/decrement

When the result isn't used, prefer post increment/decrement
(already used nearly everywhere in Blender).

6 files changed, 94 insertions, 94 deletions

diff --git a/source/blender/physics/intern/BPH_mass_spring.cpp b/source/blender/physics/intern/BPH_mass_spring.cpp
index ce0dc1b49e0..c057e74b72b 100644
--- a/source/blender/physics/intern/BPH_mass_spring.cpp
+++ b/source/blender/physics/intern/BPH_mass_spring.cpp
@@ -231,9 +231,9 @@ static void cloth_setup_constraints(ClothModifierData *clmd,
     verts[v].impulse_count = 0;
   }
 
-  for (i = 0; i < totcolliders; ++i) {
+  for (i = 0; i < totcolliders; i++) {
     ColliderContacts *ct = &contacts[i];
-    for (j = 0; j < ct->totcollisions; ++j) {
+    for (j = 0; j < ct->totcollisions; j++) {
       CollPair *collpair = &ct->collisions[j];
       // float restitution = (1.0f - clmd->coll_parms->damping) * (1.0f - ct->ob->pd->pdef_sbdamp);
       float restitution = 0.0f;
@@ -867,8 +867,8 @@ static void cloth_continuum_step(ClothModifierData *clmd, float dt)
                           clmd->hair_grid_min[(axis + 2) % 3];
 
       BKE_sim_debug_data_clear_category(clmd->debug_data, "grid velocity");
-      for (j = 0; j < size; ++j) {
-        for (i = 0; i < size; ++i) {
+      for (j = 0; j < size; j++) {
+        for (i = 0; i < size; i++) {
           float x[3], v[3], gvel[3], gvel_smooth[3], gdensity;
 
           madd_v3_v3v3fl(x, offset, a, (float)i / (float)(size - 1));
diff --git a/source/blender/physics/intern/ConstrainedConjugateGradient.h b/source/blender/physics/intern/ConstrainedConjugateGradient.h
index 56151b714a6..c924490f97d 100644
--- a/source/blender/physics/intern/ConstrainedConjugateGradient.h
+++ b/source/blender/physics/intern/ConstrainedConjugateGradient.h
@@ -283,7 +283,7 @@ class ConstrainedConjugateGradient
     m_iterations = Base::maxIterations();
     m_error = Base::m_tolerance;
 
-    for (int j = 0; j < b.cols(); ++j) {
+    for (int j = 0; j < b.cols(); j++) {
       m_iterations = Base::maxIterations();
       m_error = Base::m_tolerance;
 
diff --git a/source/blender/physics/intern/eigen_utils.h b/source/blender/physics/intern/eigen_utils.h
index 273b13e096a..2b50da0d190 100644
--- a/source/blender/physics/intern/eigen_utils.h
+++ b/source/blender/physics/intern/eigen_utils.h
@@ -54,14 +54,14 @@ class Vector3 : public Eigen::Vector3f {
 
   Vector3(const ctype &v)
   {
-    for (int k = 0; k < 3; ++k) {
+    for (int k = 0; k < 3; k++) {
       coeffRef(k) = v[k];
     }
   }
 
   Vector3 &operator=(const ctype &v)
   {
-    for (int k = 0; k < 3; ++k) {
+    for (int k = 0; k < 3; k++) {
       coeffRef(k) = v[k];
     }
     return *this;
@@ -86,8 +86,8 @@ class Matrix3 : public Eigen::Matrix3f {
 
   Matrix3(const ctype &v)
   {
-    for (int k = 0; k < 3; ++k) {
-      for (int l = 0; l < 3; ++l) {
+    for (int k = 0; k < 3; k++) {
+      for (int l = 0; l < 3; l++) {
         coeffRef(l, k) = v[k][l];
       }
     }
@@ -95,8 +95,8 @@ class Matrix3 : public Eigen::Matrix3f {
 
   Matrix3 &operator=(const ctype &v)
   {
-    for (int k = 0; k < 3; ++k) {
-      for (int l = 0; l < 3; ++l) {
+    for (int k = 0; k < 3; k++) {
+      for (int l = 0; l < 3; l++) {
         coeffRef(l, k) = v[k][l];
       }
     }
@@ -170,8 +170,8 @@ struct lMatrix3fCtor {
   {
     i *= 3;
     j *= 3;
-    for (int k = 0; k < 3; ++k) {
-      for (int l = 0; l < 3; ++l) {
+    for (int k = 0; k < 3; k++) {
+      for (int l = 0; l < 3; l++) {
         m_trips.push_back(Triplet(i + k, j + l, m.coeff(l, k)));
       }
     }
@@ -181,8 +181,8 @@ struct lMatrix3fCtor {
   {
     i *= 3;
     j *= 3;
-    for (int k = 0; k < 3; ++k) {
-      for (int l = 0; l < 3; ++l) {
+    for (int k = 0; k < 3; k++) {
+      for (int l = 0; l < 3; l++) {
         m_trips.push_back(Triplet(i + k, j + l, -m.coeff(l, k)));
       }
     }
@@ -205,7 +205,7 @@ using Eigen::ComputationInfo;
 
 BLI_INLINE void print_lvector(const lVector3f &v)
 {
-  for (int i = 0; i < v.rows(); ++i) {
+  for (int i = 0; i < v.rows(); i++) {
     if (i > 0 && i % 3 == 0) {
       printf("\n");
     }
@@ -216,12 +216,12 @@ BLI_INLINE void print_lvector(const lVector3f &v)
 
 BLI_INLINE void print_lmatrix(const lMatrix &m)
 {
-  for (int j = 0; j < m.rows(); ++j) {
+  for (int j = 0; j < m.rows(); j++) {
     if (j > 0 && j % 3 == 0) {
       printf("\n");
     }
 
-    for (int i = 0; i < m.cols(); ++i) {
+    for (int i = 0; i < m.cols(); i++) {
       if (i > 0 && i % 3 == 0) {
         printf("  ");
       }
diff --git a/source/blender/physics/intern/hair_volume.cpp b/source/blender/physics/intern/hair_volume.cpp
index 33c65a0cf95..88913eef7df 100644
--- a/source/blender/physics/intern/hair_volume.cpp
+++ b/source/blender/physics/intern/hair_volume.cpp
@@ -160,7 +160,7 @@ BLI_INLINE void hair_grid_interpolate(const HairGridVert *grid,
 
   if (velocity) {
     int k;
-    for (k = 0; k < 3; ++k) {
+    for (k = 0; k < 3; k++) {
       velocity[k] = muvw[2] *
                         (muvw[1] * (muvw[0] * data[0].velocity[k] + uvw[0] * data[1].velocity[k]) +
                          uvw[1] * (muvw[0] * data[2].velocity[k] + uvw[0] * data[3].velocity[k])) +
@@ -172,7 +172,7 @@ BLI_INLINE void hair_grid_interpolate(const HairGridVert *grid,
 
   if (vel_smooth) {
     int k;
-    for (k = 0; k < 3; ++k) {
+    for (k = 0; k < 3; k++) {
       vel_smooth[k] = muvw[2] * (muvw[1] * (muvw[0] * data[0].velocity_smooth[k] +
                                             uvw[0] * data[1].velocity_smooth[k]) +
                                  uvw[1] * (muvw[0] * data[2].velocity_smooth[k] +
@@ -297,7 +297,7 @@ void BPH_hair_volume_grid_clear(HairGrid *grid)
 {
   const int size = hair_grid_size(grid->res);
   int i;
-  for (i = 0; i < size; ++i) {
+  for (i = 0; i < size; i++) {
     zero_v3(grid->verts[i].velocity);
     zero_v3(grid->verts[i].velocity_smooth);
     grid->verts[i].density = 0.0f;
@@ -321,7 +321,7 @@ BLI_INLINE float weights_sum(const float weights[8])
 {
   float totweight = 0.0f;
   int i;
-  for (i = 0; i < 8; ++i) {
+  for (i = 0; i < 8; i++) {
     totweight += weights[i];
   }
   return totweight;
@@ -377,9 +377,9 @@ void BPH_hair_volume_add_vertex(HairGrid *grid, const float x[3], const float v[
 
   offset = hair_grid_weights(res, grid->gmin, grid->inv_cellsize, x, weights);
 
-  for (di = 0; di < 2; ++di) {
-    for (dj = 0; dj < 2; ++dj) {
-      for (dk = 0; dk < 2; ++dk) {
+  for (di = 0; di < 2; di++) {
+    for (dj = 0; dj < 2; dj++) {
+      for (dk = 0; dk < 2; dk++) {
         int voffset = offset + di + (dj + dk * res[1]) * res[0];
         int iw = di + dj * 2 + dk * 4;
 
@@ -465,12 +465,12 @@ BLI_INLINE void hair_volume_add_segment_2D(HairGrid *grid,
   HairGridVert *vert_j = vert + jmin * stride_j;
   float loc_j[3] = {loc[0], loc[1], loc[2]};
   loc_j[axis_j] += (float)jmin;
-  for (j = jmin; j <= jmax; ++j, vert_j += stride_j, loc_j[axis_j] += 1.0f) {
+  for (j = jmin; j <= jmax; j++, vert_j += stride_j, loc_j[axis_j] += 1.0f) {
 
     HairGridVert *vert_k = vert_j + kmin * stride_k;
     float loc_k[3] = {loc_j[0], loc_j[1], loc_j[2]};
     loc_k[axis_k] += (float)kmin;
-    for (k = kmin; k <= kmax; ++k, vert_k += stride_k, loc_k[axis_k] += 1.0f) {
+    for (k = kmin; k <= kmax; k++, vert_k += stride_k, loc_k[axis_k] += 1.0f) {
 
       hair_volume_eval_grid_vertex(vert_k, loc_k, radius, dist_scale, x2, v2, x3, v3);
 
@@ -553,7 +553,7 @@ void BPH_hair_volume_add_segment(HairGrid *grid,
   int j0, k0, j0_prev, k0_prev;
   int i;
 
-  for (i = imin; i <= imax; ++i) {
+  for (i = imin; i <= imax; i++) {
     float shift1, shift2; /* fraction of a full cell shift [0.0, 1.0) */
     int jmin, jmax, kmin, kmax;
 
@@ -657,7 +657,7 @@ void BPH_hair_volume_add_segment(HairGrid *grid,
 
   int s;
 
-  for (s = 0; s < num_samples; ++s) {
+  for (s = 0; s < num_samples; s++) {
     float x[3], v[3];
     int i, j, k;
 
@@ -672,9 +672,9 @@ void BPH_hair_volume_add_segment(HairGrid *grid,
     int kmin = max_ii(floor_int(x[2]) - 2, 0);
     int kmax = min_ii(floor_int(x[2]) + 2, res[2] - 1);
 
-    for (k = kmin; k <= kmax; ++k) {
-      for (j = jmin; j <= jmax; ++j) {
-        for (i = imin; i <= imax; ++i) {
+    for (k = kmin; k <= kmax; k++) {
+      for (j = jmin; j <= jmax; j++) {
+        for (i = imin; i <= imax; i++) {
           float loc[3] = {(float)i, (float)j, (float)k};
           HairGridVert *vert = grid->verts + i * stride[0] + j * stride[1] + k * stride[2];
 
@@ -761,9 +761,9 @@ bool BPH_hair_volume_solve_divergence(HairGrid *grid,
 
   /* Calculate divergence */
   lVector B(num_cellsA);
-  for (k = 0; k < resA[2]; ++k) {
-    for (j = 0; j < resA[1]; ++j) {
-      for (i = 0; i < resA[0]; ++i) {
+  for (k = 0; k < resA[2]; k++) {
+    for (j = 0; j < resA[1]; j++) {
+      for (i = 0; i < resA[0]; i++) {
         int u = i * strideA0 + j * strideA1 + k * strideA2;
         bool is_margin = MARGIN_i0 || MARGIN_i1 || MARGIN_j0 || MARGIN_j1 || MARGIN_k0 ||
                          MARGIN_k1;
@@ -855,9 +855,9 @@ bool BPH_hair_volume_solve_divergence(HairGrid *grid,
    */
   A.reserve(Eigen::VectorXi::Constant(num_cellsA, 7));
 
-  for (k = 0; k < resA[2]; ++k) {
-    for (j = 0; j < resA[1]; ++j) {
-      for (i = 0; i < resA[0]; ++i) {
+  for (k = 0; k < resA[2]; k++) {
+    for (j = 0; j < resA[1]; j++) {
+      for (i = 0; i < resA[0]; i++) {
         int u = i * strideA0 + j * strideA1 + k * strideA2;
         bool is_margin = MARGIN_i0 || MARGIN_i1 || MARGIN_j0 || MARGIN_j1 || MARGIN_k0 ||
                          MARGIN_k1;
@@ -897,11 +897,11 @@ bool BPH_hair_volume_solve_divergence(HairGrid *grid,
           /*int liquid_neighbors = neighbors_lo + neighbors_hi;*/
           non_solid_neighbors = 6;
 
-          for (n = 0; n < neighbors_lo; ++n) {
+          for (n = 0; n < neighbors_lo; n++) {
             A.insert(neighbor_lo_index[n], u) = -1.0f;
           }
           A.insert(u, u) = (float)non_solid_neighbors;
-          for (n = 0; n < neighbors_hi; ++n) {
+          for (n = 0; n < neighbors_hi; n++) {
             A.insert(neighbor_hi_index[n], u) = -1.0f;
           }
         }
@@ -922,9 +922,9 @@ bool BPH_hair_volume_solve_divergence(HairGrid *grid,
 
   if (cg.info() == Eigen::Success) {
     /* Calculate velocity = grad(p) */
-    for (k = 0; k < resA[2]; ++k) {
-      for (j = 0; j < resA[1]; ++j) {
-        for (i = 0; i < resA[0]; ++i) {
+    for (k = 0; k < resA[2]; k++) {
+      for (j = 0; j < resA[1]; j++) {
+        for (i = 0; i < resA[0]; i++) {
           int u = i * strideA0 + j * strideA1 + k * strideA2;
           bool is_margin = MARGIN_i0 || MARGIN_i1 || MARGIN_j0 || MARGIN_j1 || MARGIN_k0 ||
                            MARGIN_k1;
@@ -965,9 +965,9 @@ bool BPH_hair_volume_solve_divergence(HairGrid *grid,
 
       int slice = (offset - grid->gmin[axis]) / grid->cellsize;
 
-      for (k = 0; k < resA[2]; ++k) {
-        for (j = 0; j < resA[1]; ++j) {
-          for (i = 0; i < resA[0]; ++i) {
+      for (k = 0; k < resA[2]; k++) {
+        for (j = 0; j < resA[1]; j++) {
+          for (i = 0; i < resA[0]; i++) {
             int u = i * strideA0 + j * strideA1 + k * strideA2;
             bool is_margin = MARGIN_i0 || MARGIN_i1 || MARGIN_j0 || MARGIN_j1 || MARGIN_k0 ||
                              MARGIN_k1;
@@ -1034,7 +1034,7 @@ bool BPH_hair_volume_solve_divergence(HairGrid *grid,
   }
   else {
     /* Clear result in case of error */
-    for (i = 0, vert = grid->verts; i < num_cells; ++i, ++vert) {
+    for (i = 0, vert = grid->verts; i < num_cells; i++, vert++) {
       zero_v3(vert->velocity_smooth);
     }
 
@@ -1066,9 +1066,9 @@ BLI_INLINE void hair_volume_filter_box_convolute(
   kernel_offset = minp + (minq + minr * res) * res;
   kernel_dq = res;
   kernel_dr = res * res;
-  for (r = minr; r <= maxr; ++r) {
-    for (q = minq; q <= maxq; ++q) {
-      for (p = minp; p <= maxp; ++p) {
+  for (r = minr; r <= maxr; r++) {
+    for (q = minq; q <= maxq; q++) {
+      for (p = minp; p <= maxp; p++) {
 
         madd_v3_v3fl(vel_smooth, verts[kernel_offset].velocity, invD);
 
@@ -1096,20 +1096,20 @@ void BPH_hair_volume_vertex_grid_filter_box(HairVertexGrid *grid, int kernel_siz
   invD = 1.0f / (float)(tot * tot * tot);
 
   /* clear values for convolution */
-  for (i = 0; i < size; ++i) {
+  for (i = 0; i < size; i++) {
     zero_v3(grid->verts[i].velocity_smooth);
   }
 
-  for (i = 0; i < grid->res; ++i) {
-    for (j = 0; j < grid->res; ++j) {
-      for (k = 0; k < grid->res; ++k) {
+  for (i = 0; i < grid->res; i++) {
+    for (j = 0; j < grid->res; j++) {
+      for (k = 0; k < grid->res; k++) {
         hair_volume_filter_box_convolute(grid, invD, kernel_sizev, i, j, k);
       }
     }
   }
 
   /* apply as new velocity */
-  for (i = 0; i < size; ++i) {
+  for (i = 0; i < size; i++) {
     copy_v3_v3(grid->verts[i].velocity, grid->verts[i].velocity_smooth);
   }
 }
@@ -1134,7 +1134,7 @@ HairGrid *BPH_hair_volume_create_vertex_grid(float cellsize,
   scale = 1.0f / cellsize;
 
   sub_v3_v3v3(extent, gmax, gmin);
-  for (i = 0; i < 3; ++i) {
+  for (i = 0; i < 3; i++) {
     resmin[i] = floor_int(gmin[i] * scale);
     resmax[i] = floor_int(gmax[i] * scale) + 1;
 
@@ -1221,7 +1221,7 @@ static HairGridVert *hair_volume_create_collision_grid(ClothModifierData *clmd,
   collgrid = MEM_mallocN(sizeof(HairGridVert) * size, "hair collider voxel data");
 
   /* initialize grid */
-  for (i = 0; i < size; ++i) {
+  for (i = 0; i < size; i++) {
     zero_v3(collgrid[i].velocity);
     collgrid[i].density = 0.0f;
   }
@@ -1247,9 +1247,9 @@ static HairGridVert *hair_volume_create_collision_grid(ClothModifierData *clmd,
 
         sub_v3_v3v3(vel, loc1->co, loc0->co);
 
-        for (di = 0; di < 2; ++di) {
-          for (dj = 0; dj < 2; ++dj) {
-            for (dk = 0; dk < 2; ++dk) {
+        for (di = 0; di < 2; di++) {
+          for (dj = 0; dj < 2; dj++) {
+            for (dk = 0; dk < 2; dk++) {
               int voffset = offset + di + (dj + dk * res) * res;
               int iw = di + dj * 2 + dk * 4;
 
diff --git a/source/blender/physics/intern/implicit_blender.c b/source/blender/physics/intern/implicit_blender.c
index c2eb7b465e1..d8b3f647591 100644
--- a/source/blender/physics/intern/implicit_blender.c
+++ b/source/blender/physics/intern/implicit_blender.c
@@ -300,7 +300,7 @@ static void print_sparse_matrix(fmatrix3x3 *m)
 static void print_lvector(lfVector *v, int numverts)
 {
   int i;
-  for (i = 0; i < numverts; ++i) {
+  for (i = 0; i < numverts; i++) {
     if (i > 0) {
       printf("\n");
     }
@@ -320,12 +320,12 @@ static void print_bfmatrix(fmatrix3x3 *m)
   float *t = MEM_callocN(sizeof(float) * size * size, "bfmatrix");
   int q, i, j;
 
-  for (q = 0; q < tot; ++q) {
+  for (q = 0; q < tot; q++) {
     int k = 3 * m[q].r;
     int l = 3 * m[q].c;
 
-    for (j = 0; j < 3; ++j) {
-      for (i = 0; i < 3; ++i) {
+    for (j = 0; j < 3; j++) {
+      for (i = 0; i < 3; i++) {
         //              if (t[k + i + (l + j) * size] != 0.0f) {
         //                  printf("warning: overwriting value at %d, %d\n", m[q].r, m[q].c);
         //              }
@@ -340,12 +340,12 @@ static void print_bfmatrix(fmatrix3x3 *m)
     }
   }
 
-  for (j = 0; j < size; ++j) {
+  for (j = 0; j < size; j++) {
     if (j > 0 && j % 3 == 0) {
       printf("\n");
     }
 
-    for (i = 0; i < size; ++i) {
+    for (i = 0; i < size; i++) {
       if (i > 0 && i % 3 == 0) {
         printf("  ");
       }
@@ -560,7 +560,7 @@ DO_INLINE fmatrix3x3 *create_bfmatrix(unsigned int verts, unsigned int springs)
   temp[0].scount = springs;
 
   /* vertex part of the matrix is diagonal blocks */
-  for (i = 0; i < verts; ++i) {
+  for (i = 0; i < verts; i++) {
     init_fmatrix(temp + i, i, i);
   }
 
@@ -1289,7 +1289,7 @@ static int BPH_mass_spring_add_block(Implicit_Data *data, int v1, int v2)
 void BPH_mass_spring_clear_constraints(Implicit_Data *data)
 {
   int i, numverts = data->S[0].vcount;
-  for (i = 0; i < numverts; ++i) {
+  for (i = 0; i < numverts; i++) {
     unit_m3(data->S[i].m);
     zero_v3(data->z[i]);
   }
@@ -2001,7 +2001,7 @@ BLI_INLINE void spring_hairbend_estimate_dfdx(Implicit_Data *data,
 
   /* XXX TODO offset targets to account for position dependency */
 
-  for (a = 0; a < 3; ++a) {
+  for (a = 0; a < 3; a++) {
     spring_hairbend_forces(
         data, i, j, k, goal, stiffness, damping, q, dvec_pos[a], dvec_null[a], f);
     copy_v3_v3(dfdx[a], f);
@@ -2010,7 +2010,7 @@ BLI_INLINE void spring_hairbend_estimate_dfdx(Implicit_Data *data,
         data, i, j, k, goal, stiffness, damping, q, dvec_neg[a], dvec_null[a], f);
     sub_v3_v3(dfdx[a], f);
 
-    for (b = 0; b < 3; ++b) {
+    for (b = 0; b < 3; b++) {
       dfdx[a][b] /= delta;
     }
   }
@@ -2040,7 +2040,7 @@ BLI_INLINE void spring_hairbend_estimate_dfdv(Implicit_Data *data,
 
   /* XXX TODO offset targets to account for position dependency */
 
-  for (a = 0; a < 3; ++a) {
+  for (a = 0; a < 3; a++) {
     spring_hairbend_forces(
         data, i, j, k, goal, stiffness, damping, q, dvec_null[a], dvec_pos[a], f);
     copy_v3_v3(dfdv[a], f);
@@ -2049,7 +2049,7 @@ BLI_INLINE void spring_hairbend_estimate_dfdv(Implicit_Data *data,
         data, i, j, k, goal, stiffness, damping, q, dvec_null[a], dvec_neg[a], f);
     sub_v3_v3(dfdv[a], f);
 
-    for (b = 0; b < 3; ++b) {
+    for (b = 0; b < 3; b++) {
       dfdv[a][b] /= delta;
     }
   }
diff --git a/source/blender/physics/intern/implicit_eigen.cpp b/source/blender/physics/intern/implicit_eigen.cpp
index 277b62fba7c..9e1c03638d7 100644
--- a/source/blender/physics/intern/implicit_eigen.cpp
+++ b/source/blender/physics/intern/implicit_eigen.cpp
@@ -98,14 +98,14 @@ class fVector : public Eigen::Vector3f {
 
   fVector(const ctype &v)
   {
-    for (int k = 0; k < 3; ++k) {
+    for (int k = 0; k < 3; k++) {
       coeffRef(k) = v[k];
     }
   }
 
   fVector &operator=(const ctype &v)
   {
-    for (int k = 0; k < 3; ++k) {
+    for (int k = 0; k < 3; k++) {
       coeffRef(k) = v[k];
     }
     return *this;
@@ -130,8 +130,8 @@ class fMatrix : public Eigen::Matrix3f {
 
   fMatrix(const ctype &v)
   {
-    for (int k = 0; k < 3; ++k) {
-      for (int l = 0; l < 3; ++l) {
+    for (int k = 0; k < 3; k++) {
+      for (int l = 0; l < 3; l++) {
         coeffRef(l, k) = v[k][l];
       }
     }
@@ -139,8 +139,8 @@ class fMatrix : public Eigen::Matrix3f {
 
   fMatrix &operator=(const ctype &v)
   {
-    for (int k = 0; k < 3; ++k) {
-      for (int l = 0; l < 3; ++l) {
+    for (int k = 0; k < 3; k++) {
+      for (int l = 0; l < 3; l++) {
         coeffRef(l, k) = v[k][l];
       }
     }
@@ -212,8 +212,8 @@ struct lMatrixCtor {
   {
     i *= 3;
     j *= 3;
-    for (int k = 0; k < 3; ++k) {
-      for (int l = 0; l < 3; ++l) {
+    for (int k = 0; k < 3; k++) {
+      for (int l = 0; l < 3; l++) {
         m_trips.push_back(Triplet(i + k, j + l, m.coeff(l, k)));
       }
     }
@@ -223,8 +223,8 @@ struct lMatrixCtor {
   {
     i *= 3;
     j *= 3;
-    for (int k = 0; k < 3; ++k) {
-      for (int l = 0; l < 3; ++l) {
+    for (int k = 0; k < 3; k++) {
+      for (int l = 0; l < 3; l++) {
         m_trips.push_back(Triplet(i + k, j + l, -m.coeff(l, k)));
       }
     }
@@ -255,7 +255,7 @@ using Eigen::ComputationInfo;
 
 static void print_lvector(const lVector &v)
 {
-  for (int i = 0; i < v.rows(); ++i) {
+  for (int i = 0; i < v.rows(); i++) {
     if (i > 0 && i % 3 == 0) {
       printf("\n");
     }
@@ -266,12 +266,12 @@ static void print_lvector(const lVector &v)
 
 static void print_lmatrix(const lMatrix &m)
 {
-  for (int j = 0; j < m.rows(); ++j) {
+  for (int j = 0; j < m.rows(); j++) {
     if (j > 0 && j % 3 == 0) {
       printf("\n");
     }
 
-    for (int i = 0; i < m.cols(); ++i) {
+    for (int i = 0; i < m.cols(); i++) {
       if (i > 0 && i % 3 == 0) {
         printf("  ");
       }
@@ -302,8 +302,8 @@ BLI_INLINE void triplets_m3(TripletList &tlist, float m[3][3], int i, int j)
 {
   i *= 3;
   j *= 3;
-  for (int l = 0; l < 3; ++l) {
-    for (int k = 0; k < 3; ++k) {
+  for (int l = 0; l < 3; l++) {
+    for (int k = 0; k < 3; k++) {
       tlist.push_back(Triplet(i + k, j + l, m[k][l]));
     }
   }
@@ -313,8 +313,8 @@ BLI_INLINE void triplets_m3fl(TripletList &tlist, float m[3][3], int i, int j, f
 {
   i *= 3;
   j *= 3;
-  for (int l = 0; l < 3; ++l) {
-    for (int k = 0; k < 3; ++k) {
+  for (int l = 0; l < 3; l++) {
+    for (int k = 0; k < 3; k++) {
       tlist.push_back(Triplet(i + k, j + l, m[k][l] * factor));
     }
   }
@@ -667,7 +667,7 @@ void BPH_mass_spring_set_new_velocity(Implicit_Data *data, int index, const floa
 void BPH_mass_spring_clear_constraints(Implicit_Data *data)
 {
   int numverts = data->numverts;
-  for (int i = 0; i < numverts; ++i) {
+  for (int i = 0; i < numverts; i++) {
     data->iS.add(i, i, I);
     zero_v3(data->z.v3(i));
   }
@@ -1236,7 +1236,7 @@ BLI_INLINE void spring_angbend_estimate_dfdx(Implicit_Data *data,
 
   /* XXX TODO offset targets to account for position dependency */
 
-  for (a = 0; a < 3; ++a) {
+  for (a = 0; a < 3; a++) {
     spring_angbend_forces(
         data, i, j, k, goal, stiffness, damping, q, dvec_pos[a], dvec_null[a], f);
     copy_v3_v3(dfdx[a], f);
@@ -1245,7 +1245,7 @@ BLI_INLINE void spring_angbend_estimate_dfdx(Implicit_Data *data,
         data, i, j, k, goal, stiffness, damping, q, dvec_neg[a], dvec_null[a], f);
     sub_v3_v3(dfdx[a], f);
 
-    for (b = 0; b < 3; ++b) {
+    for (b = 0; b < 3; b++) {
       dfdx[a][b] /= delta;
     }
   }
@@ -1275,7 +1275,7 @@ BLI_INLINE void spring_angbend_estimate_dfdv(Implicit_Data *data,
 
   /* XXX TODO offset targets to account for position dependency */
 
-  for (a = 0; a < 3; ++a) {
+  for (a = 0; a < 3; a++) {
     spring_angbend_forces(
         data, i, j, k, goal, stiffness, damping, q, dvec_null[a], dvec_pos[a], f);
     copy_v3_v3(dfdv[a], f);
@@ -1284,7 +1284,7 @@ BLI_INLINE void spring_angbend_estimate_dfdv(Implicit_Data *data,
         data, i, j, k, goal, stiffness, damping, q, dvec_null[a], dvec_neg[a], f);
     sub_v3_v3(dfdv[a], f);
 
-    for (b = 0; b < 3; ++b) {
+    for (b = 0; b < 3; b++) {
       dfdv[a][b] /= delta;
     }
   }