Cleanup: style, use braces for blenkernel
authorCampbell Barton <ideasman42@gmail.com>
Sun, 21 Apr 2019 23:39:35 +0000 (09:39 +1000)
committerCampbell Barton <ideasman42@gmail.com>
Mon, 22 Apr 2019 09:48:17 +0000 (19:48 +1000)
123 files changed:
source/blender/blenkernel/intern/CCGSubSurf.c
source/blender/blenkernel/intern/CCGSubSurf_inline.h
source/blender/blenkernel/intern/CCGSubSurf_legacy.c
source/blender/blenkernel/intern/CCGSubSurf_opensubdiv_converter.c
source/blender/blenkernel/intern/CCGSubSurf_util.c
source/blender/blenkernel/intern/DerivedMesh.c
source/blender/blenkernel/intern/action.c
source/blender/blenkernel/intern/anim.c
source/blender/blenkernel/intern/anim_sys.c
source/blender/blenkernel/intern/appdir.c
source/blender/blenkernel/intern/armature.c
source/blender/blenkernel/intern/armature_update.c
source/blender/blenkernel/intern/blender.c
source/blender/blenkernel/intern/blendfile.c
source/blender/blenkernel/intern/boids.c
source/blender/blenkernel/intern/bpath.c
source/blender/blenkernel/intern/brush.c
source/blender/blenkernel/intern/bvhutils.c
source/blender/blenkernel/intern/camera.c
source/blender/blenkernel/intern/cdderivedmesh.c
source/blender/blenkernel/intern/cloth.c
source/blender/blenkernel/intern/collection.c
source/blender/blenkernel/intern/collision.c
source/blender/blenkernel/intern/colorband.c
source/blender/blenkernel/intern/colortools.c
source/blender/blenkernel/intern/constraint.c
source/blender/blenkernel/intern/context.c
source/blender/blenkernel/intern/crazyspace.c
source/blender/blenkernel/intern/curve.c
source/blender/blenkernel/intern/customdata.c
source/blender/blenkernel/intern/customdata_file.c
source/blender/blenkernel/intern/data_transfer.c
source/blender/blenkernel/intern/deform.c
source/blender/blenkernel/intern/displist.c
source/blender/blenkernel/intern/dynamicpaint.c
source/blender/blenkernel/intern/editderivedmesh.c
source/blender/blenkernel/intern/editmesh.c
source/blender/blenkernel/intern/editmesh_bvh.c
source/blender/blenkernel/intern/editmesh_tangent.c
source/blender/blenkernel/intern/effect.c
source/blender/blenkernel/intern/fcurve.c
source/blender/blenkernel/intern/fmodifier.c
source/blender/blenkernel/intern/font.c
source/blender/blenkernel/intern/freestyle.c
source/blender/blenkernel/intern/gpencil.c
source/blender/blenkernel/intern/gpencil_modifier.c
source/blender/blenkernel/intern/icons.c
source/blender/blenkernel/intern/idcode.c
source/blender/blenkernel/intern/idprop.c
source/blender/blenkernel/intern/image.c
source/blender/blenkernel/intern/image_gen.c
source/blender/blenkernel/intern/ipo.c
source/blender/blenkernel/intern/key.c
source/blender/blenkernel/intern/lattice.c
source/blender/blenkernel/intern/layer.c
source/blender/blenkernel/intern/library.c
source/blender/blenkernel/intern/library_override.c
source/blender/blenkernel/intern/library_query.c
source/blender/blenkernel/intern/library_remap.c
source/blender/blenkernel/intern/light.c
source/blender/blenkernel/intern/linestyle.c
source/blender/blenkernel/intern/mask.c
source/blender/blenkernel/intern/mask_evaluate.c
source/blender/blenkernel/intern/mask_rasterize.c
source/blender/blenkernel/intern/material.c
source/blender/blenkernel/intern/mball.c
source/blender/blenkernel/intern/mball_tessellate.c
source/blender/blenkernel/intern/mesh.c
source/blender/blenkernel/intern/mesh_convert.c
source/blender/blenkernel/intern/mesh_evaluate.c
source/blender/blenkernel/intern/mesh_mapping.c
source/blender/blenkernel/intern/mesh_merge.c
source/blender/blenkernel/intern/mesh_runtime.c
source/blender/blenkernel/intern/mesh_tangent.c
source/blender/blenkernel/intern/mesh_validate.c
source/blender/blenkernel/intern/modifier.c
source/blender/blenkernel/intern/movieclip.c
source/blender/blenkernel/intern/multires.c
source/blender/blenkernel/intern/nla.c
source/blender/blenkernel/intern/node.c
source/blender/blenkernel/intern/object.c
source/blender/blenkernel/intern/object_deform.c
source/blender/blenkernel/intern/object_dupli.c
source/blender/blenkernel/intern/object_facemap.c
source/blender/blenkernel/intern/object_update.c
source/blender/blenkernel/intern/ocean.c
source/blender/blenkernel/intern/packedFile.c
source/blender/blenkernel/intern/paint.c
source/blender/blenkernel/intern/particle.c
source/blender/blenkernel/intern/particle_child.c
source/blender/blenkernel/intern/particle_distribute.c
source/blender/blenkernel/intern/particle_system.c
source/blender/blenkernel/intern/pbvh.c
source/blender/blenkernel/intern/pbvh_bmesh.c
source/blender/blenkernel/intern/pointcache.c
source/blender/blenkernel/intern/report.c
source/blender/blenkernel/intern/rigidbody.c
source/blender/blenkernel/intern/scene.c
source/blender/blenkernel/intern/screen.c
source/blender/blenkernel/intern/seqcache.c
source/blender/blenkernel/intern/seqeffects.c
source/blender/blenkernel/intern/seqmodifier.c
source/blender/blenkernel/intern/sequencer.c
source/blender/blenkernel/intern/shader_fx.c
source/blender/blenkernel/intern/shrinkwrap.c
source/blender/blenkernel/intern/smoke.c
source/blender/blenkernel/intern/softbody.c
source/blender/blenkernel/intern/sound.c
source/blender/blenkernel/intern/studiolight.c
source/blender/blenkernel/intern/subsurf_ccg.c
source/blender/blenkernel/intern/suggestions.c
source/blender/blenkernel/intern/text.c
source/blender/blenkernel/intern/texture.c
source/blender/blenkernel/intern/tracking.c
source/blender/blenkernel/intern/tracking_detect.c
source/blender/blenkernel/intern/tracking_region_tracker.c
source/blender/blenkernel/intern/tracking_solver.c
source/blender/blenkernel/intern/tracking_stabilize.c
source/blender/blenkernel/intern/tracking_util.c
source/blender/blenkernel/intern/unit.c
source/blender/blenkernel/intern/world.c
source/blender/blenkernel/intern/writeavi.c
source/blender/blenkernel/intern/writeffmpeg.c

index 2ab6eb3..49855de 100644 (file)
@@ -73,8 +73,9 @@ static CCGVert *_vert_new(CCGVertHDL vHDL, CCGSubSurf *ss)
 
   userData = ccgSubSurf_getVertUserData(ss, v);
   memset(userData, 0, ss->meshIFC.vertUserSize);
-  if (ss->useAgeCounts)
+  if (ss->useAgeCounts) {
     *((int *)&userData[ss->vertUserAgeOffset]) = ss->currentAge;
+  }
 
   return v;
 }
@@ -155,8 +156,9 @@ static CCGEdge *_edge_new(CCGEdgeHDL eHDL, CCGVert *v0, CCGVert *v1, float creas
 
   userData = ccgSubSurf_getEdgeUserData(ss, e);
   memset(userData, 0, ss->meshIFC.edgeUserSize);
-  if (ss->useAgeCounts)
+  if (ss->useAgeCounts) {
     *((int *)&userData[ss->edgeUserAgeOffset]) = ss->currentAge;
+  }
 
   return e;
 }
@@ -229,8 +231,9 @@ static CCGFace *_face_new(
 
   userData = ccgSubSurf_getFaceUserData(ss, f);
   memset(userData, 0, ss->meshIFC.faceUserSize);
-  if (ss->useAgeCounts)
+  if (ss->useAgeCounts) {
     *((int *)&userData[ss->faceUserAgeOffset]) = ss->currentAge;
+  }
 
   return f;
 }
@@ -354,8 +357,9 @@ void ccgSubSurf_free(CCGSubSurf *ss)
 
   CCGSUBSURF_free(ss, ss->r);
   CCGSUBSURF_free(ss, ss->q);
-  if (ss->defaultEdgeUserData)
+  if (ss->defaultEdgeUserData) {
     CCGSUBSURF_free(ss, ss->defaultEdgeUserData);
+  }
 
   ccg_ehash_free(ss->fMap, (EHEntryFreeFP)_face_free, ss);
   ccg_ehash_free(ss->eMap, (EHEntryFreeFP)_edge_free, ss);
@@ -395,13 +399,16 @@ void ccgSubSurf_getAllowEdgeCreation(CCGSubSurf *ss,
                                      float *defaultCreaseValue_r,
                                      void *defaultUserData_r)
 {
-  if (allowEdgeCreation_r)
+  if (allowEdgeCreation_r) {
     *allowEdgeCreation_r = ss->allowEdgeCreation;
+  }
   if (ss->allowEdgeCreation) {
-    if (defaultCreaseValue_r)
+    if (defaultCreaseValue_r) {
       *defaultCreaseValue_r = ss->defaultCreaseValue;
-    if (defaultUserData_r)
+    }
+    if (defaultUserData_r) {
       memcpy(defaultUserData_r, ss->defaultEdgeUserData, ss->meshIFC.edgeUserSize);
+    }
   }
 }
 
@@ -432,12 +439,15 @@ void ccgSubSurf_getUseAgeCounts(CCGSubSurf *ss,
 {
   *useAgeCounts_r = ss->useAgeCounts;
 
-  if (vertUserOffset_r)
+  if (vertUserOffset_r) {
     *vertUserOffset_r = ss->vertUserAgeOffset;
-  if (edgeUserOffset_r)
+  }
+  if (edgeUserOffset_r) {
     *edgeUserOffset_r = ss->edgeUserAgeOffset;
-  if (faceUserOffset_r)
+  }
+  if (faceUserOffset_r) {
     *faceUserOffset_r = ss->faceUserAgeOffset;
+  }
 }
 
 CCGError ccgSubSurf_setUseAgeCounts(
@@ -666,8 +676,9 @@ CCGError ccgSubSurf_syncVert(
 #endif
   }
 
-  if (v_r)
+  if (v_r) {
     *v_r = v;
+  }
   return eCCGError_None;
 }
 
@@ -731,8 +742,9 @@ CCGError ccgSubSurf_syncEdge(CCGSubSurf *ss,
     }
   }
 
-  if (e_r)
+  if (e_r) {
     *e_r = e;
+  }
   return eCCGError_None;
 }
 
@@ -783,8 +795,9 @@ CCGError ccgSubSurf_syncFace(
         ccg_ehash_insert(ss->fMap, (EHEntry *)fNew);
       }
 
-      for (k = 0; k < numVerts; k++)
+      for (k = 0; k < numVerts; k++) {
         FACE_getVerts(fNew)[k]->flags |= Vert_eEffected;
+      }
     }
   }
   else {
@@ -800,8 +813,9 @@ CCGError ccgSubSurf_syncFace(
     for (k = 0; k < numVerts; k++) {
       ss->tempVerts[k] = ccg_ehash_lookup(ss->vMap, vHDLs[k]);
 
-      if (!ss->tempVerts[k])
+      if (!ss->tempVerts[k]) {
         return eCCGError_InvalidValue;
+      }
     }
     for (k = 0; k < numVerts; k++) {
       ss->tempEdges[k] = _vert_findEdgeTo(ss->tempVerts[k], ss->tempVerts[(k + 1) % numVerts]);
@@ -841,8 +855,9 @@ CCGError ccgSubSurf_syncFace(
       ccg_ehash_insert(ss->fMap, (EHEntry *)f);
       ss->numGrids += numVerts;
 
-      for (k = 0; k < numVerts; k++)
+      for (k = 0; k < numVerts; k++) {
         FACE_getVerts(f)[k]->flags |= Vert_eEffected;
+      }
     }
     else {
       *prevp = f->next;
@@ -852,8 +867,9 @@ CCGError ccgSubSurf_syncFace(
 
       for (j = 0; j < f->numVerts; j++) {
         if (FACE_getVerts(f)[j]->flags & Vert_eChanged) {
-          for (k = 0; k < f->numVerts; k++)
+          for (k = 0; k < f->numVerts; k++) {
             FACE_getVerts(f)[k]->flags |= Vert_eEffected;
+          }
           break;
         }
       }
@@ -869,8 +885,9 @@ CCGError ccgSubSurf_syncFace(
 #endif
   }
 
-  if (f_r)
+  if (f_r) {
     *f_r = f;
+  }
   return eCCGError_None;
 }
 
@@ -929,8 +946,9 @@ void ccgSubSurf__allFaces(CCGSubSurf *ss, CCGFace ***faces, int *numFaces, int *
     for (i = 0; i < ss->fMap->curSize; i++) {
       CCGFace *f = (CCGFace *)ss->fMap->buckets[i];
 
-      for (; f; f = f->next)
+      for (; f; f = f->next) {
         array[num++] = f;
+      }
     }
 
     *faces = array;
@@ -967,9 +985,11 @@ void ccgSubSurf__effectedFaceNeighbours(CCGSubSurf *ss,
     CCGVert *v = (CCGVert *)ss->vMap->buckets[i];
 
     for (; v; v = v->next) {
-      for (j = 0; j < v->numFaces; j++)
-        if (!(v->faces[j]->flags & Face_eEffected))
+      for (j = 0; j < v->numFaces; j++) {
+        if (!(v->faces[j]->flags & Face_eEffected)) {
           break;
+        }
+      }
 
       if (j == v->numFaces) {
         arrayV[numV++] = v;
@@ -982,9 +1002,11 @@ void ccgSubSurf__effectedFaceNeighbours(CCGSubSurf *ss,
     CCGEdge *e = (CCGEdge *)ss->eMap->buckets[i];
 
     for (; e; e = e->next) {
-      for (j = 0; j < e->numFaces; j++)
-        if (!(e->faces[j]->flags & Face_eEffected))
+      for (j = 0; j < e->numFaces; j++) {
+        if (!(e->faces[j]->flags & Face_eEffected)) {
           break;
+        }
+      }
 
       if (j == e->numFaces) {
         e->flags |= Edge_eEffected;
@@ -1023,8 +1045,9 @@ CCGError ccgSubSurf_updateFromFaces(CCGSubSurf *ss, int lvl, CCGFace **effectedF
       VertDataCopy(
           VERT_getCo(FACE_getVerts(f)[S], lvl), FACE_getIFCo(f, lvl, S, cornerIdx, cornerIdx), ss);
 
-      for (x = 0; x < gridSize; x++)
+      for (x = 0; x < gridSize; x++) {
         VertDataCopy(FACE_getIECo(f, lvl, S, x), FACE_getIFCo(f, lvl, S, x, 0), ss);
+      }
 
       for (x = 0; x < gridSize; x++) {
         int eI = gridSize - 1 - x;
@@ -1038,8 +1061,9 @@ CCGError ccgSubSurf_updateFromFaces(CCGSubSurf *ss, int lvl, CCGFace **effectedF
     }
   }
 
-  if (freeF)
+  if (freeF) {
     MEM_freeN(effectedF);
+  }
 
   return eCCGError_None;
 }
@@ -1086,8 +1110,9 @@ CCGError ccgSubSurf_updateToFaces(CCGSubSurf *ss, int lvl, CCGFace **effectedF,
     }
   }
 
-  if (freeF)
+  if (freeF) {
     MEM_freeN(effectedF);
+  }
 
   return eCCGError_None;
 }
@@ -1115,16 +1140,19 @@ CCGError ccgSubSurf_stitchFaces(CCGSubSurf *ss, int lvl, CCGFace **effectedF, in
   /* zero */
   for (i = 0; i < numEffectedV; i++) {
     CCGVert *v = effectedV[i];
-    if (v->numFaces)
+    if (v->numFaces) {
       VertDataZero(VERT_getCo(v, lvl), ss);
+    }
   }
 
   for (i = 0; i < numEffectedE; i++) {
     CCGEdge *e = effectedE[i];
 
-    if (e->numFaces)
-      for (x = 0; x < edgeSize; x++)
+    if (e->numFaces) {
+      for (x = 0; x < edgeSize; x++) {
         VertDataZero(EDGE_getCo(e, lvl, x), ss);
+      }
+    }
   }
 
   /* add */
@@ -1133,9 +1161,11 @@ CCGError ccgSubSurf_stitchFaces(CCGSubSurf *ss, int lvl, CCGFace **effectedF, in
 
     VertDataZero((float *)FACE_getCenterData(f), ss);
 
-    for (S = 0; S < f->numVerts; S++)
-      for (x = 0; x < gridSize; x++)
+    for (S = 0; S < f->numVerts; S++) {
+      for (x = 0; x < gridSize; x++) {
         VertDataZero(FACE_getIECo(f, lvl, S, x), ss);
+      }
+    }
 
     for (S = 0; S < f->numVerts; S++) {
       int prevS = (S + f->numVerts - 1) % f->numVerts;
@@ -1143,10 +1173,11 @@ CCGError ccgSubSurf_stitchFaces(CCGSubSurf *ss, int lvl, CCGFace **effectedF, in
       CCGEdge *prevE = FACE_getEdges(f)[prevS];
 
       VertDataAdd((float *)FACE_getCenterData(f), FACE_getIFCo(f, lvl, S, 0, 0), ss);
-      if (FACE_getVerts(f)[S]->flags & Vert_eEffected)
+      if (FACE_getVerts(f)[S]->flags & Vert_eEffected) {
         VertDataAdd(VERT_getCo(FACE_getVerts(f)[S], lvl),
                     FACE_getIFCo(f, lvl, S, cornerIdx, cornerIdx),
                     ss);
+      }
 
       for (x = 1; x < gridSize - 1; x++) {
         VertDataAdd(FACE_getIECo(f, lvl, S, x), FACE_getIFCo(f, lvl, S, x, 0), ss);
@@ -1155,15 +1186,18 @@ CCGError ccgSubSurf_stitchFaces(CCGSubSurf *ss, int lvl, CCGFace **effectedF, in
 
       for (x = 0; x < gridSize - 1; x++) {
         int eI = gridSize - 1 - x;
-        if (FACE_getEdges(f)[S]->flags & Edge_eEffected)
+        if (FACE_getEdges(f)[S]->flags & Edge_eEffected) {
           VertDataAdd(_edge_getCoVert(e, FACE_getVerts(f)[S], lvl, eI, vertDataSize),
                       FACE_getIFCo(f, lvl, S, cornerIdx, x),
                       ss);
-        if (FACE_getEdges(f)[prevS]->flags & Edge_eEffected)
-          if (x != 0)
+        }
+        if (FACE_getEdges(f)[prevS]->flags & Edge_eEffected) {
+          if (x != 0) {
             VertDataAdd(_edge_getCoVert(prevE, FACE_getVerts(f)[S], lvl, eI, vertDataSize),
                         FACE_getIFCo(f, lvl, S, x, cornerIdx),
                         ss);
+          }
+        }
       }
     }
   }
@@ -1171,8 +1205,9 @@ CCGError ccgSubSurf_stitchFaces(CCGSubSurf *ss, int lvl, CCGFace **effectedF, in
   /* average */
   for (i = 0; i < numEffectedV; i++) {
     CCGVert *v = effectedV[i];
-    if (v->numFaces)
+    if (v->numFaces) {
       VertDataMulN(VERT_getCo(v, lvl), 1.0f / v->numFaces, ss);
+    }
   }
 
   for (i = 0; i < numEffectedE; i++) {
@@ -1181,9 +1216,11 @@ CCGError ccgSubSurf_stitchFaces(CCGSubSurf *ss, int lvl, CCGFace **effectedF, in
     VertDataCopy(EDGE_getCo(e, lvl, 0), VERT_getCo(e->v0, lvl), ss);
     VertDataCopy(EDGE_getCo(e, lvl, edgeSize - 1), VERT_getCo(e->v1, lvl), ss);
 
-    if (e->numFaces)
-      for (x = 1; x < edgeSize - 1; x++)
+    if (e->numFaces) {
+      for (x = 1; x < edgeSize - 1; x++) {
         VertDataMulN(EDGE_getCo(e, lvl, x), 1.0f / e->numFaces, ss);
+      }
+    }
   }
 
   /* copy */
@@ -1192,9 +1229,11 @@ CCGError ccgSubSurf_stitchFaces(CCGSubSurf *ss, int lvl, CCGFace **effectedF, in
 
     VertDataMulN((float *)FACE_getCenterData(f), 1.0f / f->numVerts, ss);
 
-    for (S = 0; S < f->numVerts; S++)
-      for (x = 1; x < gridSize - 1; x++)
+    for (S = 0; S < f->numVerts; S++) {
+      for (x = 1; x < gridSize - 1; x++) {
         VertDataMulN(FACE_getIECo(f, lvl, S, x), 0.5f, ss);
+      }
+    }
 
     for (S = 0; S < f->numVerts; S++) {
       int prevS = (S + f->numVerts - 1) % f->numVerts;
@@ -1227,17 +1266,21 @@ CCGError ccgSubSurf_stitchFaces(CCGSubSurf *ss, int lvl, CCGFace **effectedF, in
     }
   }
 
-  for (i = 0; i < numEffectedV; i++)
+  for (i = 0; i < numEffectedV; i++) {
     effectedV[i]->flags = 0;
-  for (i = 0; i < numEffectedE; i++)
+  }
+  for (i = 0; i < numEffectedE; i++) {
     effectedE[i]->flags = 0;
-  for (i = 0; i < numEffectedF; i++)
+  }
+  for (i = 0; i < numEffectedF; i++) {
     effectedF[i]->flags = 0;
+  }
 
   MEM_freeN(effectedE);
   MEM_freeN(effectedV);
-  if (freeF)
+  if (freeF) {
     MEM_freeN(effectedF);
+  }
 
   return eCCGError_None;
 }
@@ -1616,20 +1659,24 @@ void CCG_key(CCGKey *key, const CCGSubSurf *ss, int level)
 
   /* if normals are present, always the last three floats of an
    * element */
-  if (key->has_normals)
+  if (key->has_normals) {
     key->normal_offset = key->elem_size - sizeof(float) * 3;
-  else
+  }
+  else {
     key->normal_offset = -1;
+  }
 
   key->grid_size = ccgSubSurf_getGridLevelSize(ss, level);
   key->grid_area = key->grid_size * key->grid_size;
   key->grid_bytes = key->elem_size * key->grid_area;
 
   key->has_mask = ss->allocMask;
-  if (key->has_mask)
+  if (key->has_mask) {
     key->mask_offset = ss->maskDataOffset;
-  else
+  }
+  else {
     key->mask_offset = -1;
+  }
 }
 
 void CCG_key_top_level(CCGKey *key, const CCGSubSurf *ss)
index 44e27cb..86012bd 100644 (file)
@@ -144,18 +144,22 @@ BLI_INLINE float *ccg_face_getIFNo(
 BLI_INLINE int ccg_face_getVertIndex(CCGFace *f, CCGVert *v)
 {
   int i;
-  for (i = 0; i < f->numVerts; i++)
-    if (FACE_getVerts(f)[i] == v)
+  for (i = 0; i < f->numVerts; i++) {
+    if (FACE_getVerts(f)[i] == v) {
       return i;
+    }
+  }
   return -1;
 }
 
 BLI_INLINE int ccg_face_getEdgeIndex(CCGFace *f, CCGEdge *e)
 {
   int i;
-  for (i = 0; i < f->numVerts; i++)
-    if (FACE_getEdges(f)[i] == e)
+  for (i = 0; i < f->numVerts; i++) {
+    if (FACE_getEdges(f)[i] == e) {
       return i;
+    }
+  }
   return -1;
 }
 
@@ -214,8 +218,9 @@ BLI_INLINE int VertDataEqual(const float a[], const float b[], const CCGSubSurf
 {
   int i;
   for (i = 0; i < ss->meshIFC.numLayers; i++) {
-    if (a[i] != b[i])
+    if (a[i] != b[i]) {
       return 0;
+    }
   }
   return 1;
 }
@@ -228,29 +233,33 @@ BLI_INLINE void VertDataZero(float v[], const CCGSubSurf *ss)
 BLI_INLINE void VertDataCopy(float dst[], const float src[], const CCGSubSurf *ss)
 {
   int i;
-  for (i = 0; i < ss->meshIFC.numLayers; i++)
+  for (i = 0; i < ss->meshIFC.numLayers; i++) {
     dst[i] = src[i];
+  }
 }
 
 BLI_INLINE void VertDataAdd(float a[], const float b[], const CCGSubSurf *ss)
 {
   int i;
-  for (i = 0; i < ss->meshIFC.numLayers; i++)
+  for (i = 0; i < ss->meshIFC.numLayers; i++) {
     a[i] += b[i];
+  }
 }
 
 BLI_INLINE void VertDataSub(float a[], const float b[], const CCGSubSurf *ss)
 {
   int i;
-  for (i = 0; i < ss->meshIFC.numLayers; i++)
+  for (i = 0; i < ss->meshIFC.numLayers; i++) {
     a[i] -= b[i];
+  }
 }
 
 BLI_INLINE void VertDataMulN(float v[], float f, const CCGSubSurf *ss)
 {
   int i;
-  for (i = 0; i < ss->meshIFC.numLayers; i++)
+  for (i = 0; i < ss->meshIFC.numLayers; i++) {
     v[i] *= f;
+  }
 }
 
 BLI_INLINE void VertDataAvg4(float v[],
@@ -261,8 +270,9 @@ BLI_INLINE void VertDataAvg4(float v[],
                              const CCGSubSurf *ss)
 {
   int i;
-  for (i = 0; i < ss->meshIFC.numLayers; i++)
+  for (i = 0; i < ss->meshIFC.numLayers; i++) {
     v[i] = (a[i] + b[i] + c[i] + d[i]) * 0.25f;
+  }
 }
 
 #endif /* __CCGSUBSURF_INLINE_H__ */
index 430a8ef..720c828 100644 (file)
@@ -52,9 +52,11 @@ static int _edge_isBoundary(const CCGEdge *e)
 static int _vert_isBoundary(const CCGVert *v)
 {
   int i;
-  for (i = 0; i < v->numEdges; i++)
-    if (_edge_isBoundary(v->edges[i]))
+  for (i = 0; i < v->numEdges; i++) {
+    if (_edge_isBoundary(v->edges[i])) {
       return 1;
+    }
+  }
   return 0;
 }
 
@@ -106,14 +108,18 @@ static int VERT_seam(const CCGVert *v)
 
 static float EDGE_getSharpness(CCGEdge *e, int lvl)
 {
-  if (!lvl)
+  if (!lvl) {
     return e->crease;
-  else if (!e->crease)
+  }
+  else if (!e->crease) {
     return 0.0f;
-  else if (e->crease - lvl < 0.0f)
+  }
+  else if (e->crease - lvl < 0.0f) {
     return 0.0f;
-  else
+  }
+  else {
     return e->crease - lvl;
+  }
 }
 
 typedef struct CCGSubSurfCalcSubdivData {
@@ -181,10 +187,12 @@ static void ccgSubSurf__calcVertNormals_faces_accumulate_cb(
         FACE_calcIFNo(f, lvl, S, x, y, no);
 
         NormAdd(FACE_getIFNo(f, lvl, S, x + 0, y + 0), no);
-        if (xPlusOk)
+        if (xPlusOk) {
           NormAdd(FACE_getIFNo(f, lvl, S, x + 1, y + 0), no);
-        if (yPlusOk)
+        }
+        if (yPlusOk) {
           NormAdd(FACE_getIFNo(f, lvl, S, x + 0, y + 1), no);
+        }
         if (xPlusOk && yPlusOk) {
           if (x < gridSize - 2 || y < gridSize - 2 ||
               FACE_getVerts(f)[S]->flags & Vert_eEffected) {
@@ -195,10 +203,12 @@ static void ccgSubSurf__calcVertNormals_faces_accumulate_cb(
         if (x == 0 && y == 0) {
           int K;
 
-          if (!yLimitNext || 1 < gridSize - 1)
+          if (!yLimitNext || 1 < gridSize - 1) {
             NormAdd(FACE_getIFNo(f, lvl, (S + 1) % f->numVerts, 0, 1), no);
-          if (!xLimitPrev || 1 < gridSize - 1)
+          }
+          if (!xLimitPrev || 1 < gridSize - 1) {
             NormAdd(FACE_getIFNo(f, lvl, (S - 1 + f->numVerts) % f->numVerts, 1, 0), no);
+          }
 
           for (K = 0; K < f->numVerts; K++) {
             if (K != S) {
@@ -208,13 +218,15 @@ static void ccgSubSurf__calcVertNormals_faces_accumulate_cb(
         }
         else if (y == 0) {
           NormAdd(FACE_getIFNo(f, lvl, (S + 1) % f->numVerts, 0, x), no);
-          if (!yLimitNext || x < gridSize - 2)
+          if (!yLimitNext || x < gridSize - 2) {
             NormAdd(FACE_getIFNo(f, lvl, (S + 1) % f->numVerts, 0, x + 1), no);
+          }
         }
         else if (x == 0) {
           NormAdd(FACE_getIFNo(f, lvl, (S - 1 + f->numVerts) % f->numVerts, y, 0), no);
-          if (!xLimitPrev || y < gridSize - 2)
+          if (!xLimitPrev || y < gridSize - 2) {
             NormAdd(FACE_getIFNo(f, lvl, (S - 1 + f->numVerts) % f->numVerts, y + 1, 0), no);
+          }
         }
       }
     }
@@ -390,10 +402,11 @@ static void ccgSubSurf__calcVertNormals(CCGSubSurf *ss,
       int x;
       const int f_ed_idx = ccg_face_getEdgeIndex(f, e);
 
-      for (x = 0; x < edgeSize; x++)
+      for (x = 0; x < edgeSize; x++) {
         NormCopy(EDGE_getNo(e, lvl, x),
                  _face_getIFNoEdge(
                      f, e, f_ed_idx, lvl, x, 0, subdivLevels, vertDataSize, normalDataOffset));
+      }
     }
     else {
       /* set to zero here otherwise the normals are uninitialized memory
@@ -763,8 +776,9 @@ static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss,
       CCGEdge *e = v->edges[j];
       float sharpness = EDGE_getSharpness(e, curLvl);
 
-      if (seam && _edge_isBoundary(e))
+      if (seam && _edge_isBoundary(e)) {
         seamEdges++;
+      }
 
       if (sharpness != 0.0f) {
         sharpCount++;
@@ -782,8 +796,9 @@ static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss,
       }
     }
 
-    if (seamEdges < 2 || seamEdges != v->numEdges)
+    if (seamEdges < 2 || seamEdges != v->numEdges) {
       seam = 0;
+    }
 
     if (!v->numEdges || ss->meshIFC.simpleSubdiv) {
       VertDataCopy(nCo, co, ss);
@@ -846,8 +861,9 @@ static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss,
         float sharpness = EDGE_getSharpness(e, curLvl);
 
         if (seam) {
-          if (_edge_isBoundary(e))
+          if (_edge_isBoundary(e)) {
             VertDataAdd(q, _edge_getCoVert(e, v, curLvl, 1, vertDataSize), ss);
+          }
         }
         else if (sharpness != 0.0f) {
           VertDataAdd(q, _edge_getCoVert(e, v, curLvl, 1, vertDataSize), ss);
@@ -1104,8 +1120,9 @@ void ccgSubSurf__sync_legacy(CCGSubSurf *ss)
       CCGEdge *e = v->edges[i];
       float sharpness = EDGE_getSharpness(e, curLvl);
 
-      if (seam && _edge_isBoundary(e))
+      if (seam && _edge_isBoundary(e)) {
         seamEdges++;
+      }
 
       if (sharpness != 0.0f) {
         sharpCount++;
@@ -1123,8 +1140,9 @@ void ccgSubSurf__sync_legacy(CCGSubSurf *ss)
       }
     }
 
-    if (seamEdges < 2 || seamEdges != v->numEdges)
+    if (seamEdges < 2 || seamEdges != v->numEdges) {
       seam = 0;
+    }
 
     if (!v->numEdges || ss->meshIFC.simpleSubdiv) {
       VertDataCopy(nCo, co, ss);
@@ -1267,13 +1285,15 @@ void ccgSubSurf__sync_legacy(CCGSubSurf *ss)
     }
   }
 
-  for (curLvl = 1; curLvl < subdivLevels; curLvl++)
+  for (curLvl = 1; curLvl < subdivLevels; curLvl++) {
     ccgSubSurf__calcSubdivLevel(
         ss, effectedV, effectedE, effectedF, numEffectedV, numEffectedE, numEffectedF, curLvl);
+  }
 
-  if (ss->calcVertNormals)
+  if (ss->calcVertNormals) {
     ccgSubSurf__calcVertNormals(
         ss, effectedV, effectedE, effectedF, numEffectedV, numEffectedE, numEffectedF);
+  }
 
   for (ptrIdx = 0; ptrIdx < numEffectedV; ptrIdx++) {
     CCGVert *v = effectedV[ptrIdx];
@@ -1306,21 +1326,26 @@ CCGError ccgSubSurf_updateNormals(CCGSubSurf *ss, CCGFace **effectedF, int numEf
   ccgSubSurf__effectedFaceNeighbours(
       ss, effectedF, numEffectedF, &effectedV, &numEffectedV, &effectedE, &numEffectedE);
 
-  if (ss->calcVertNormals)
+  if (ss->calcVertNormals) {
     ccgSubSurf__calcVertNormals(
         ss, effectedV, effectedE, effectedF, numEffectedV, numEffectedE, numEffectedF);
+  }
 
-  for (i = 0; i < numEffectedV; i++)
+  for (i = 0; i < numEffectedV; i++) {
     effectedV[i]->flags = 0;
-  for (i = 0; i < numEffectedE; i++)
+  }
+  for (i = 0; i < numEffectedE; i++) {
     effectedE[i]->flags = 0;
-  for (i = 0; i < numEffectedF; i++)
+  }
+  for (i = 0; i < numEffectedF; i++) {
     effectedF[i]->flags = 0;
+  }
 
   MEM_freeN(effectedE);
   MEM_freeN(effectedV);
-  if (freeF)
+  if (freeF) {
     MEM_freeN(effectedF);
+  }
 
   return eCCGError_None;
 }
@@ -1344,17 +1369,21 @@ CCGError ccgSubSurf_updateLevels(CCGSubSurf *ss, int lvl, CCGFace **effectedF, i
         ss, effectedV, effectedE, effectedF, numEffectedV, numEffectedE, numEffectedF, curLvl);
   }
 
-  for (i = 0; i < numEffectedV; i++)
+  for (i = 0; i < numEffectedV; i++) {
     effectedV[i]->flags = 0;
-  for (i = 0; i < numEffectedE; i++)
+  }
+  for (i = 0; i < numEffectedE; i++) {
     effectedE[i]->flags = 0;
-  for (i = 0; i < numEffectedF; i++)
+  }
+  for (i = 0; i < numEffectedF; i++) {
     effectedF[i]->flags = 0;
+  }
 
   MEM_freeN(effectedE);
   MEM_freeN(effectedV);
-  if (freeF)
+  if (freeF) {
     MEM_freeN(effectedF);
+  }
 
   return eCCGError_None;
 }
index 53af82f..eb04d13 100644 (file)
@@ -69,10 +69,12 @@ typedef struct ConvDMStorage {
 static OpenSubdiv_SchemeType conv_dm_get_type(const OpenSubdiv_Converter *converter)
 {
   ConvDMStorage *storage = converter->user_data;
-  if (storage->ss->meshIFC.simpleSubdiv)
+  if (storage->ss->meshIFC.simpleSubdiv) {
     return OSD_SCHEME_BILINEAR;
-  else
+  }
+  else {
     return OSD_SCHEME_CATMARK;
+  }
 }
 
 static OpenSubdiv_VtxBoundaryInterpolation conv_dm_get_vtx_boundary_interpolation(
index 9ad1b0c..ebd4531 100644 (file)
@@ -51,8 +51,9 @@ EHash *ccg_ehash_new(int estimatedNumEntries,
   eh->allocator = allocator;
   eh->numEntries = 0;
   eh->curSizeIdx = 0;
-  while (kHashSizes[eh->curSizeIdx] < estimatedNumEntries)
+  while (kHashSizes[eh->curSizeIdx] < estimatedNumEntries) {
     eh->curSizeIdx++;
+  }
   eh->curSize = kHashSizes[eh->curSizeIdx];
   eh->buckets = EHASH_alloc(eh, eh->curSize * sizeof(*eh->buckets));
   memset(eh->buckets, 0, eh->curSize * sizeof(*eh->buckets));
@@ -133,8 +134,9 @@ void *ccg_ehash_lookup(EHash *eh, void *key)
   EHEntry *entry;
 
   for (entry = eh->buckets[hash]; entry; entry = entry->next) {
-    if (entry->key == key)
+    if (entry->key == key) {
       break;
+    }
   }
 
   return entry;
@@ -151,8 +153,9 @@ void ccg_ehashIterator_init(EHash *eh, EHashIterator *ehi)
 
   while (!ehi->curEntry) {
     ehi->curBucket++;
-    if (ehi->curBucket == ehi->eh->curSize)
+    if (ehi->curBucket == ehi->eh->curSize) {
       break;
+    }
     ehi->curEntry = ehi->eh->buckets[ehi->curBucket];
   }
 }
@@ -168,8 +171,9 @@ void ccg_ehashIterator_next(EHashIterator *ehi)
     ehi->curEntry = ehi->curEntry->next;
     while (!ehi->curEntry) {
       ehi->curBucket++;
-      if (ehi->curBucket == ehi->eh->curSize)
+      if (ehi->curBucket == ehi->eh->curSize) {
         break;
+      }
       ehi->curEntry = ehi->eh->buckets[ehi->curBucket];
     }
   }
index 2c22f74..e70fcfe 100644 (file)
@@ -175,8 +175,9 @@ static MVert *dm_dupVertArray(DerivedMesh *dm)
 {
   MVert *tmp = MEM_malloc_arrayN(dm->getNumVerts(dm), sizeof(*tmp), "dm_dupVertArray tmp");
 
-  if (tmp)
+  if (tmp) {
     dm->copyVertArray(dm, tmp);
+  }
 
   return tmp;
 }
@@ -185,8 +186,9 @@ static MEdge *dm_dupEdgeArray(DerivedMesh *dm)
 {
   MEdge *tmp = MEM_malloc_arrayN(dm->getNumEdges(dm), sizeof(*tmp), "dm_dupEdgeArray tmp");
 
-  if (tmp)
+  if (tmp) {
     dm->copyEdgeArray(dm, tmp);
+  }
 
   return tmp;
 }
@@ -195,8 +197,9 @@ static MFace *dm_dupFaceArray(DerivedMesh *dm)
 {
   MFace *tmp = MEM_malloc_arrayN(dm->getNumTessFaces(dm), sizeof(*tmp), "dm_dupFaceArray tmp");
 
-  if (tmp)
+  if (tmp) {
     dm->copyTessFaceArray(dm, tmp);
+  }
 
   return tmp;
 }
@@ -205,8 +208,9 @@ static MLoop *dm_dupLoopArray(DerivedMesh *dm)
 {
   MLoop *tmp = MEM_malloc_arrayN(dm->getNumLoops(dm), sizeof(*tmp), "dm_dupLoopArray tmp");
 
-  if (tmp)
+  if (tmp) {
     dm->copyLoopArray(dm, tmp);
+  }
 
   return tmp;
 }
@@ -215,8 +219,9 @@ static MPoly *dm_dupPolyArray(DerivedMesh *dm)
 {
   MPoly *tmp = MEM_malloc_arrayN(dm->getNumPolys(dm), sizeof(*tmp), "dm_dupPolyArray tmp");
 
-  if (tmp)
+  if (tmp) {
     dm->copyPolyArray(dm, tmp);
+  }
 
   return tmp;
 }
@@ -756,24 +761,27 @@ void *DM_get_poly_data(DerivedMesh *dm, int index, int type)
 
 void *DM_get_vert_data_layer(DerivedMesh *dm, int type)
 {
-  if (type == CD_MVERT)
+  if (type == CD_MVERT) {
     return dm->getVertArray(dm);
+  }
 
   return CustomData_get_layer(&dm->vertData, type);
 }
 
 void *DM_get_edge_data_layer(DerivedMesh *dm, int type)
 {
-  if (type == CD_MEDGE)
+  if (type == CD_MEDGE) {
     return dm->getEdgeArray(dm);
+  }
 
   return CustomData_get_layer(&dm->edgeData, type);
 }
 
 void *DM_get_tessface_data_layer(DerivedMesh *dm, int type)
 {
-  if (type == CD_MFACE)
+  if (type == CD_MFACE) {
     return dm->getTessFaceArray(dm);
+  }
 
   return CustomData_get_layer(&dm->faceData, type);
 }
@@ -814,8 +822,9 @@ DerivedMesh *mesh_create_derived(Mesh *me, float (*vertCos)[3])
 {
   DerivedMesh *dm = CDDM_from_mesh(me);
 
-  if (!dm)
+  if (!dm) {
     return NULL;
+  }
 
   if (vertCos) {
     CDDM_apply_vert_coords(dm, vertCos);
@@ -852,10 +861,12 @@ static float (*get_orco_coords(Object *ob, BMEditMesh *em, int layer, int *free)
     /* get original coordinates */
     *free = 1;
 
-    if (em)
+    if (em) {
       return get_editbmesh_orco_verts(em);
-    else
+    }
+    else {
       return BKE_mesh_orco_verts_get(ob);
+    }
   }
   else if (layer == CD_CLOTH_ORCO) {
     /* apply shape key for cloth, this should really be solved
@@ -893,8 +904,9 @@ static Mesh *create_orco_mesh(Object *ob, Mesh *me, BMEditMesh *em, int layer)
 
   if (orco) {
     BKE_mesh_apply_vert_coords(mesh, orco);
-    if (free)
+    if (free) {
       MEM_freeN(orco);
+    }
   }
 
   return mesh;
@@ -936,8 +948,9 @@ static void add_orco_mesh(Object *ob, BMEditMesh *em, Mesh *mesh, Mesh *mesh_orc
     }
 
     memcpy(layerorco, orco, sizeof(float) * 3 * totvert);
-    if (free)
+    if (free) {
       MEM_freeN(orco);
+    }
   }
 }
 
@@ -954,8 +967,9 @@ static void shapekey_layers_to_keyblocks(DerivedMesh *dm, Mesh *me, int actshape
   KeyBlock *kb;
   int i, j, tot;
 
-  if (!me->key)
+  if (!me->key) {
     return;
+  }
 
   tot = CustomData_number_of_layers(&dm->vertData, CD_SHAPEKEY);
   for (i = 0; i < tot; i++) {
@@ -964,8 +978,9 @@ static void shapekey_layers_to_keyblocks(DerivedMesh *dm, Mesh *me, int actshape
     float(*cos)[3], (*kbcos)[3];
 
     for (kb = me->key->block.first; kb; kb = kb->next) {
-      if (kb->uid == layer->uid)
+      if (kb->uid == layer->uid) {
         break;
+      }
     }
 
     if (!kb) {
@@ -973,8 +988,9 @@ static void shapekey_layers_to_keyblocks(DerivedMesh *dm, Mesh *me, int actshape
       kb->uid = layer->uid;
     }
 
-    if (kb->data)
+    if (kb->data) {
       MEM_freeN(kb->data);
+    }
 
     cos = CustomData_get_layer_n(&dm->vertData, CD_SHAPEKEY, i);
     kb->totelem = dm->numVertData;
@@ -996,8 +1012,9 @@ static void shapekey_layers_to_keyblocks(DerivedMesh *dm, Mesh *me, int actshape
 
   for (kb = me->key->block.first; kb; kb = kb->next) {
     if (kb->totelem != dm->numVertData) {
-      if (kb->data)
+      if (kb->data) {
         MEM_freeN(kb->data);
+      }
 
       kb->totelem = dm->numVertData;
       kb->data = MEM_calloc_arrayN(kb->totelem, 3 * sizeof(float), "kb->data derivedmesh.c");
@@ -1184,8 +1201,9 @@ static void mesh_calc_modifiers(struct Depsgraph *depsgraph,
       }
 
       /* grab modifiers until index i */
-      if ((index != -1) && (BLI_findindex(&ob->modifiers, md) >= index))
+      if ((index != -1) && (BLI_findindex(&ob->modifiers, md) >= index)) {
         break;
+      }
     }
 
     /* Result of all leading deforming modifiers is cached for
@@ -1227,19 +1245,23 @@ static void mesh_calc_modifiers(struct Depsgraph *depsgraph,
         }
       }
 
-      if (sculpt_dyntopo)
+      if (sculpt_dyntopo) {
         unsupported = true;
+      }
 
-      if (scene->toolsettings->sculpt->flags & SCULPT_ONLY_DEFORM)
+      if (scene->toolsettings->sculpt->flags & SCULPT_ONLY_DEFORM) {
         unsupported |= (mti->type != eModifierTypeType_OnlyDeform);
+      }
 
       unsupported |= multires_applied;
 
       if (unsupported) {
-        if (sculpt_dyntopo)
+        if (sculpt_dyntopo) {
           modifier_setError(md, "Not supported in dyntopo");
-        else
+        }
+        else {
           modifier_setError(md, "Not supported in sculpt mode");
+        }
         continue;
       }
       else {
@@ -1294,10 +1316,12 @@ static void mesh_calc_modifiers(struct Depsgraph *depsgraph,
     else {
       /* determine which data layers are needed by following modifiers */
       CustomData_MeshMasks nextmask;
-      if (md_datamask->next)
+      if (md_datamask->next) {
         nextmask = md_datamask->next->mask;
-      else
+      }
+      else {
         nextmask = *dataMask;
+      }
 
       /* apply vertex coordinates or build a Mesh as necessary */
       if (mesh_final) {
@@ -1456,8 +1480,9 @@ static void mesh_calc_modifiers(struct Depsgraph *depsgraph,
     isPrevDeform = (mti->type == eModifierTypeType_OnlyDeform);
 
     /* grab modifiers until index i */
-    if ((index != -1) && (BLI_findindex(&ob->modifiers, md) >= index))
+    if ((index != -1) && (BLI_findindex(&ob->modifiers, md) >= index)) {
       break;
+    }
 
     if (sculpt_mode && md->type == eModifierType_Multires) {
       multires_applied = true;
@@ -1466,8 +1491,9 @@ static void mesh_calc_modifiers(struct Depsgraph *depsgraph,
 
   BLI_linklist_free((LinkNode *)datamasks, NULL);
 
-  for (md = firstmd; md; md = md->next)
+  for (md = firstmd; md; md = md->next) {
     modifier_freeTemporaryData(md);
+  }
 
   /* Yay, we are done. If we have a Mesh and deformed vertices
    * need to apply these back onto the Mesh. If we have no
@@ -1485,8 +1511,9 @@ static void mesh_calc_modifiers(struct Depsgraph *depsgraph,
   if (dataMask->vmask & CD_MASK_ORCO) {
     add_orco_mesh(ob, NULL, mesh_final, mesh_orco, CD_ORCO);
 
-    if (mesh_deform)
+    if (mesh_deform) {
       add_orco_mesh(ob, NULL, mesh_deform, NULL, CD_ORCO);
+    }
   }
 
   if (mesh_orco) {
@@ -1687,11 +1714,13 @@ static void editbmesh_calc_modifiers(struct Depsgraph *depsgraph,
         BKE_mesh_apply_vert_coords(mesh_final, deformed_verts);
       }
 
-      if (mti->deformVertsEM)
+      if (mti->deformVertsEM) {
         modwrap_deformVertsEM(
             md, &mectx, em_input, mesh_final, deformed_verts, num_deformed_verts);
-      else
+      }
+      else {
         modwrap_deformVerts(md, &mectx, mesh_final, deformed_verts, num_deformed_verts);
+      }
     }
     else {
       /* apply vertex coordinates or build a DerivedMesh as necessary */
@@ -2052,8 +2081,9 @@ static void object_get_datamask(const Depsgraph *depsgraph,
       r_mask->vmask |= CD_MASK_MDEFORMVERT;
     }
 
-    if (ob->mode & OB_MODE_EDIT)
+    if (ob->mode & OB_MODE_EDIT) {
       r_mask->vmask |= CD_MASK_MVERT_SKIN;
+    }
   }
 }
 
@@ -2381,10 +2411,12 @@ static void mesh_init_origspace(Mesh *mesh)
         copy_v2_v2(vcos_2d[j], co);
 
         for (k = 0; k < 2; k++) {
-          if (co[k] > max[k])
+          if (co[k] > max[k]) {
             max[k] = co[k];
-          else if (co[k] < min[k])
+          }
+          else if (co[k] < min[k]) {
             min[k] = co[k];
+          }
         }
       }
 
@@ -2393,10 +2425,12 @@ static void mesh_init_origspace(Mesh *mesh)
 
       /* Scale will bring max to (1, 1). */
       sub_v2_v2v2(scale, max, min);
-      if (scale[0] == 0.0f)
+      if (scale[0] == 0.0f) {
         scale[0] = 1e-9f;
-      if (scale[1] == 0.0f)
+      }
+      if (scale[1] == 0.0f) {
         scale[1] = 1e-9f;
+      }
       invert_v2(scale);
 
       /* Finally, transform all vcos_2d into ((0, 0), (1, 1)) square and assign them as origspace. */
index 885ddc5..9ae8d27 100644 (file)
@@ -177,8 +177,9 @@ bActionGroup *get_active_actiongroup(bAction *act)
 
   if (act && act->groups.first) {
     for (agrp = act->groups.first; agrp; agrp = agrp->next) {
-      if (agrp->flag & AGRP_ACTIVE)
+      if (agrp->flag & AGRP_ACTIVE) {
         break;
+      }
     }
   }
 
@@ -191,15 +192,18 @@ void set_active_action_group(bAction *act, bActionGroup *agrp, short select)
   bActionGroup *grp;
 
   /* sanity checks */
-  if (act == NULL)
+  if (act == NULL) {
     return;
+  }
 
   /* Deactivate all others */
   for (grp = act->groups.first; grp; grp = grp->next) {
-    if ((grp == agrp) && (select))
+    if ((grp == agrp) && (select)) {
       grp->flag |= AGRP_ACTIVE;
-    else
+    }
+    else {
       grp->flag &= ~AGRP_ACTIVE;
+    }
   }
 }
 
@@ -240,8 +244,9 @@ bActionGroup *action_groups_add_new(bAction *act, const char name[])
   bActionGroup *agrp;
 
   /* sanity check: must have action and name */
-  if (ELEM(NULL, act, name))
+  if (ELEM(NULL, act, name)) {
     return NULL;
+  }
 
   /* allocate a new one */
   agrp = MEM_callocN(sizeof(bActionGroup), "bActionGroup");
@@ -266,8 +271,9 @@ bActionGroup *action_groups_add_new(bAction *act, const char name[])
 void action_groups_add_channel(bAction *act, bActionGroup *agrp, FCurve *fcurve)
 {
   /* sanity checks */
-  if (ELEM(NULL, act, agrp, fcurve))
+  if (ELEM(NULL, act, agrp, fcurve)) {
     return;
+  }
 
   /* if no channels anywhere, just add to two lists at the same time */
   if (BLI_listbase_is_empty(&act->curves)) {
@@ -285,8 +291,9 @@ void action_groups_add_channel(bAction *act, bActionGroup *agrp, FCurve *fcurve)
      * then set the F-Curve as the last for the action first so that
      * the lists will be in sync after linking
      */
-    if (agrp->channels.last == act->curves.last)
+    if (agrp->channels.last == act->curves.last) {
       act->curves.last = fcurve;
+    }
 
     /* link in the given F-Curve after the last F-Curve in the group,
      * which means that it should be able to fit in with the rest of the
@@ -320,8 +327,9 @@ void action_groups_add_channel(bAction *act, bActionGroup *agrp, FCurve *fcurve)
      * since group is (effectively) the first group. Thus, the existing first F-Curve becomes the
      * second in the chain, etc. etc.
      */
-    if (grp == NULL)
+    if (grp == NULL) {
       BLI_insertlinkbefore(&act->curves, act->curves.first, fcurve);
+    }
   }
 
   /* set the F-Curve's new group */
@@ -332,8 +340,9 @@ void action_groups_add_channel(bAction *act, bActionGroup *agrp, FCurve *fcurve)
 void action_groups_remove_channel(bAction *act, FCurve *fcu)
 {
   /* sanity checks */
-  if (ELEM(NULL, act, fcu))
+  if (ELEM(NULL, act, fcu)) {
     return;
+  }
 
   /* check if any group used this directly */
   if (fcu->grp) {
@@ -345,16 +354,20 @@ void action_groups_remove_channel(bAction *act, FCurve *fcu)
       }
     }
     else if (agrp->channels.first == fcu) {
-      if ((fcu->next) && (fcu->next->grp == agrp))
+      if ((fcu->next) && (fcu->next->grp == agrp)) {
         agrp->channels.first = fcu->next;
-      else
+      }
+      else {
         agrp->channels.first = NULL;
+      }
     }
     else if (agrp->channels.last == fcu) {
-      if ((fcu->prev) && (fcu->prev->grp == agrp))
+      if ((fcu->prev) && (fcu->prev->grp == agrp)) {
         agrp->channels.last = fcu->prev;
-      else
+      }
+      else {
         agrp->channels.last = NULL;
+      }
     }
 
     fcu->grp = NULL;
@@ -368,8 +381,9 @@ void action_groups_remove_channel(bAction *act, FCurve *fcu)
 bActionGroup *BKE_action_group_find_name(bAction *act, const char name[])
 {
   /* sanity checks */
-  if (ELEM(NULL, act, act->groups.first, name) || (name[0] == 0))
+  if (ELEM(NULL, act, act->groups.first, name) || (name[0] == 0)) {
     return NULL;
+  }
 
   /* do string comparisons */
   return BLI_findstring(&act->groups, name, offsetof(bActionGroup, name));
@@ -381,12 +395,14 @@ void action_groups_clear_tempflags(bAction *act)
   bActionGroup *agrp;
 
   /* sanity checks */
-  if (ELEM(NULL, act, act->groups.first))
+  if (ELEM(NULL, act, act->groups.first)) {
     return;
+  }
 
   /* flag clearing loop */
-  for (agrp = act->groups.first; agrp; agrp = agrp->next)
+  for (agrp = act->groups.first; agrp; agrp = agrp->next) {
     agrp->flag &= ~AGRP_TEMP;
+  }
 }
 
 /* *************** Pose channels *************** */
@@ -397,11 +413,13 @@ void action_groups_clear_tempflags(bAction *act)
  */
 bPoseChannel *BKE_pose_channel_find_name(const bPose *pose, const char *name)
 {
-  if (ELEM(NULL, pose, name) || (name[0] == '\0'))
+  if (ELEM(NULL, pose, name) || (name[0] == '\0')) {
     return NULL;
+  }
 
-  if (pose->chanhash)
+  if (pose->chanhash) {
     return BLI_ghash_lookup(pose->chanhash, (const void *)name);
+  }
 
   return BLI_findstring(&((const bPose *)pose)->chanbase, name, offsetof(bPoseChannel, name));
 }
@@ -418,8 +436,9 @@ bPoseChannel *BKE_pose_channel_verify(bPose *pose, const char *name)
 {
   bPoseChannel *chan;
 
-  if (pose == NULL)
+  if (pose == NULL) {
     return NULL;
+  }
 
   /* See if this channel exists */
   chan = BKE_pose_channel_find_name(pose, name);
@@ -490,8 +509,9 @@ bPoseChannel *BKE_pose_channel_active(Object *ob)
 
   /* find active */
   for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
-    if ((pchan->bone) && (pchan->bone == arm->act_bone) && (pchan->bone->layer & arm->layer))
+    if ((pchan->bone) && (pchan->bone == arm->act_bone) && (pchan->bone->layer & arm->layer)) {
       return pchan;
+    }
   }
 
   return NULL;
@@ -657,15 +677,17 @@ static bool pose_channel_in_IK_chain(Object *ob, bPoseChannel *pchan, int level)
     if (con->type == CONSTRAINT_TYPE_KINEMATIC) {
       bKinematicConstraint *data = con->data;
       if ((data->rootbone == 0) || (data->rootbone > level)) {
-        if ((data->flag & CONSTRAINT_IK_AUTO) == 0)
+        if ((data->flag & CONSTRAINT_IK_AUTO) == 0) {
           return true;
+        }
       }
     }
   }
   for (bone = pchan->bone->childbase.first; bone; bone = bone->next) {
     pchan = BKE_pose_channel_find_name(ob->pose, bone->name);
-    if (pchan && pose_channel_in_IK_chain(ob, pchan, level + 1))
+    if (pchan && pose_channel_in_IK_chain(ob, pchan, level + 1)) {
       return true;
+    }
   }
   return false;
 }
@@ -685,8 +707,9 @@ void BKE_pose_channels_hash_make(bPose *pose)
     bPoseChannel *pchan;
 
     pose->chanhash = BLI_ghash_str_new("make_pose_chan gh");
-    for (pchan = pose->chanbase.first; pchan; pchan = pchan->next)
+    for (pchan = pose->chanbase.first; pchan; pchan = pchan->next) {
       BLI_ghash_insert(pose->chanhash, pchan->name, pchan);
+    }
   }
 }
 
@@ -742,23 +765,27 @@ void BKE_pose_channels_remove(Object *ob,
               }
             }
 
-            if (cti->flush_constraint_targets)
+            if (cti->flush_constraint_targets) {
               cti->flush_constraint_targets(con, &targets, 0);
+            }
           }
         }
 
         if (pchan->bbone_prev) {
-          if (filter_fn(pchan->bbone_prev->name, user_data))
+          if (filter_fn(pchan->bbone_prev->name, user_data)) {
             pchan->bbone_prev = NULL;
+          }
         }
         if (pchan->bbone_next) {
-          if (filter_fn(pchan->bbone_next->name, user_data))
+          if (filter_fn(pchan->bbone_next->name, user_data)) {
             pchan->bbone_next = NULL;
+          }
         }
 
         if (pchan->custom_tx) {
-          if (filter_fn(pchan->custom_tx->name, user_data))
+          if (filter_fn(pchan->custom_tx->name, user_data)) {
             pchan->custom_tx = NULL;
+          }
         }
       }
     }
@@ -833,8 +860,9 @@ void BKE_pose_channels_free_ex(bPose *pose, bool do_id_user)
   bPoseChannel *pchan;
 
   if (pose->chanbase.first) {
-    for (pchan = pose->chanbase.first; pchan; pchan = pchan->next)
+    for (pchan = pose->chanbase.first; pchan; pchan = pchan->next) {
       BKE_pose_channel_free_ex(pchan, do_id_user);
+    }
 
     BLI_freelistN(&pose->chanbase);
   }
@@ -855,15 +883,17 @@ void BKE_pose_free_data_ex(bPose *pose, bool do_id_user)
   BKE_pose_channels_free_ex(pose, do_id_user);
 
   /* free pose-groups */
-  if (pose->agroups.first)
+  if (pose->agroups.first) {
     BLI_freelistN(&pose->agroups);
+  }
 
   /* free IK solver state */
   BIK_clear_data(pose);
 
   /* free IK solver param */
-  if (pose->ikparam)
+  if (pose->ikparam) {
     MEM_freeN(pose->ikparam);
+  }
 }
 
 void BKE_pose_free_data(bPose *pose)
@@ -965,22 +995,26 @@ void BKE_pose_update_constraint_flags(bPose *pose)
 
         pchan->constflag |= PCHAN_HAS_IK;
 
-        if (data->tar == NULL || (data->tar->type == OB_ARMATURE && data->subtarget[0] == 0))
+        if (data->tar == NULL || (data->tar->type == OB_ARMATURE && data->subtarget[0] == 0)) {
           pchan->constflag |= PCHAN_HAS_TARGET;
+        }
 
         /* negative rootbone = recalc rootbone index. used in do_versions */
         if (data->rootbone < 0) {
           data->rootbone = 0;
 
-          if (data->flag & CONSTRAINT_IK_TIP)
+          if (data->flag & CONSTRAINT_IK_TIP) {
             parchan = pchan;
-          else
+          }
+          else {
             parchan = pchan->parent;
+          }
 
           while (parchan) {
             data->rootbone++;
-            if ((parchan->bone->flag & BONE_CONNECTED) == 0)
+            if ((parchan->bone->flag & BONE_CONNECTED) == 0) {
               break;
+            }
             parchan = parchan->parent;
           }
         }
@@ -994,13 +1028,16 @@ void BKE_pose_update_constraint_flags(bPose *pose)
         /* if we have a valid target, make sure that this will get updated on frame-change
          * (needed for when there is no anim-data for this pose)
          */
-        if ((data->tar) && (data->tar->type == OB_CURVE))
+        if ((data->tar) && (data->tar->type == OB_CURVE)) {
           pose->flag |= POSE_CONSTRAINTS_TIMEDEPEND;
+        }
       }
-      else if (con->type == CONSTRAINT_TYPE_SPLINEIK)
+      else if (con->type == CONSTRAINT_TYPE_SPLINEIK) {
         pchan->constflag |= PCHAN_HAS_SPLINEIK;
-      else
+      }
+      else {
         pchan->constflag |= PCHAN_HAS_CONST;
+      }
     }
   }
   pose->flag &= ~POSE_CONSTRAINTS_NEED_UPDATE_FLAGS;
@@ -1027,8 +1064,9 @@ void framechange_poses_clear_unkeyed(Main *bmain)
     /* we only need to do this on objects with a pose */
     if ((pose = ob->pose)) {
       for (pchan = pose->chanbase.first; pchan; pchan = pchan->next) {
-        if (pchan->bone)
+        if (pchan->bone) {
           pchan->bone->flag &= ~BONE_UNKEYED;
+        }
       }
     }
   }
@@ -1073,10 +1111,12 @@ void BKE_pose_remove_group(bPose *pose, bActionGroup *grp, const int index)
    * - also, make sure that those after this item get corrected
    */
   for (pchan = pose->chanbase.first; pchan; pchan = pchan->next) {
-    if (pchan->agrp_index == idx)
+    if (pchan->agrp_index == idx) {
       pchan->agrp_index = 0;
-    else if (pchan->agrp_index > idx)
+    }
+    else if (pchan->agrp_index > idx) {
       pchan->agrp_index--;
+    }
   }
 
   /* now, remove it from the pose */
@@ -1115,8 +1155,9 @@ bool action_has_motion(const bAction *act)
   /* return on the first F-Curve that has some keyframes/samples defined */
   if (act) {
     for (fcu = act->curves.first; fcu; fcu = fcu->next) {
-      if (fcu->totvert)
+      if (fcu->totvert) {
         return true;
+      }
     }
   }
 
@@ -1176,10 +1217,12 @@ void calc_action_range(const bAction *act, float *start, float *end, short incl_
           {
             FMod_Cycles *fmd = (FMod_Cycles *)fcm->data;
 
-            if (fmd->before_mode != FCM_EXTRAPOLATE_NONE)
+            if (fmd->before_mode != FCM_EXTRAPOLATE_NONE) {
               min = MINAFRAMEF;
-            if (fmd->after_mode != FCM_EXTRAPOLATE_NONE)
+            }
+            if (fmd->after_mode != FCM_EXTRAPOLATE_NONE) {
               max = MAXFRAMEF;
+            }
             break;
           }
             /* TODO: function modifier may need some special limits */
@@ -1197,8 +1240,9 @@ void calc_action_range(const bAction *act, float *start, float *end, short incl_
 
   if (foundvert || foundmod) {
     /* ensure that action is at least 1 frame long (for NLA strips to have a valid length) */
-    if (min == max)
+    if (min == max) {
       max += 1.0f;
+    }
 
     *start = min;
     *end = max;
@@ -1220,17 +1264,21 @@ short action_get_item_transforms(bAction *act, Object *ob, bPoseChannel *pchan,
   short flags = 0;
 
   /* build PointerRNA from provided data to obtain the paths to use */
-  if (pchan)
+  if (pchan) {
     RNA_pointer_create((ID *)ob, &RNA_PoseBone, pchan, &ptr);
-  else if (ob)
+  }
+  else if (ob) {
     RNA_id_pointer_create((ID *)ob, &ptr);
-  else
+  }
+  else {
     return 0;
+  }
 
   /* get the basic path to the properties of interest */
   basePath = RNA_path_from_ID_to_struct(&ptr);
-  if (basePath == NULL)
+  if (basePath == NULL) {
     return 0;
+  }
 
   /* search F-Curves for the given properties
    * - we cannot use the groups, since they may not be grouped in that way...
@@ -1239,12 +1287,14 @@ short action_get_item_transforms(bAction *act, Object *ob, bPoseChannel *pchan,
     const char *bPtr = NULL, *pPtr = NULL;
 
     /* if enough flags have been found, we can stop checking unless we're also getting the curves */
-    if ((flags == ACT_TRANS_ALL) && (curves == NULL))
+    if ((flags == ACT_TRANS_ALL) && (curves == NULL)) {
       break;
+    }
 
     /* just in case... */
-    if (fcu->rna_path == NULL)
+    if (fcu->rna_path == NULL) {
       continue;
+    }
 
     /* step 1: check for matching base path */
     bPtr = strstr(fcu->rna_path, basePath);
@@ -1267,8 +1317,9 @@ short action_get_item_transforms(bAction *act, Object *ob, bPoseChannel *pchan,
         if (pPtr) {
           flags |= ACT_TRANS_LOC;
 
-          if (curves)
+          if (curves) {
             BLI_addtail(curves, BLI_genericNodeN(fcu));
+          }
           continue;
         }
       }
@@ -1278,8 +1329,9 @@ short action_get_item_transforms(bAction *act, Object *ob, bPoseChannel *pchan,
         if (pPtr) {
           flags |= ACT_TRANS_SCALE;
 
-          if (curves)
+          if (curves) {
             BLI_addtail(curves, BLI_genericNodeN(fcu));
+          }
           continue;
         }
       }
@@ -1289,8 +1341,9 @@ short action_get_item_transforms(bAction *act, Object *ob, bPoseChannel *pchan,
         if (pPtr) {
           flags |= ACT_TRANS_ROT;
 
-          if (curves)
+          if (curves) {
             BLI_addtail(curves, BLI_genericNodeN(fcu));
+          }
           continue;
         }
       }
@@ -1301,8 +1354,9 @@ short action_get_item_transforms(bAction *act, Object *ob, bPoseChannel *pchan,
         if (pPtr) {
           flags |= ACT_TRANS_BBONE;
 
-          if (curves)
+          if (curves) {
             BLI_addtail(curves, BLI_genericNodeN(fcu));
+          }
           continue;
         }
       }
@@ -1315,8 +1369,9 @@ short action_get_item_transforms(bAction *act, Object *ob, bPoseChannel *pchan,
         if (pPtr) {
           flags |= ACT_TRANS_PROP;
 
-          if (curves)
+          if (curves) {
             BLI_addtail(curves, BLI_genericNodeN(fcu));
+          }
           continue;
         }
       }
@@ -1337,8 +1392,9 @@ void BKE_pose_rest(bPose *pose)
 {
   bPoseChannel *pchan;
 
-  if (!pose)
+  if (!pose) {
     return;
+  }
 
   memset(pose->stride_offset, 0, sizeof(pose->stride_offset));
   memset(pose->cyclic_offset, 0, sizeof(pose->cyclic_offset));
index 0e7caca..e74af25 100644 (file)
@@ -67,8 +67,9 @@ static CLG_LogRef LOG = {"bke.anim"};
 void animviz_settings_init(bAnimVizSettings *avs)
 {
   /* sanity check */
-  if (avs == NULL)
+  if (avs == NULL) {
     return;
+  }
 
   /* path settings */
   avs->path_bc = avs->path_ac = 10;
@@ -89,12 +90,14 @@ void animviz_settings_init(bAnimVizSettings *avs)
 void animviz_free_motionpath_cache(bMotionPath *mpath)
 {
   /* sanity check */
-  if (mpath == NULL)
+  if (mpath == NULL) {
     return;
+  }
 
   /* free the path if necessary */
-  if (mpath->points)
+  if (mpath->points) {
     MEM_freeN(mpath->points);
+  }
 
   GPU_VERTBUF_DISCARD_SAFE(mpath->points_vbo);
   GPU_BATCH_DISCARD_SAFE(mpath->batch_line);
@@ -111,8 +114,9 @@ void animviz_free_motionpath_cache(bMotionPath *mpath)
 void animviz_free_motionpath(bMotionPath *mpath)
 {
   /* sanity check */
-  if (mpath == NULL)
+  if (mpath == NULL) {
     return;
+  }
 
   /* free the cache first */
   animviz_free_motionpath_cache(mpath);
@@ -128,8 +132,9 @@ bMotionPath *animviz_copy_motionpath(const bMotionPath *mpath_src)
 {
   bMotionPath *mpath_dst;
 
-  if (mpath_src == NULL)
+  if (mpath_src == NULL) {
     return NULL;
+  }
 
   mpath_dst = MEM_dupallocN(mpath_src);
   mpath_dst->points = MEM_dupallocN(mpath_src->points);
@@ -161,8 +166,9 @@ bMotionPath *animviz_verify_motionpaths(ReportList *reports,
   bMotionPath *mpath, **dst;
 
   /* sanity checks */
-  if (ELEM(NULL, scene, ob))
+  if (ELEM(NULL, scene, ob)) {
     return NULL;
+  }
 
   /* get destination data */
   if (pchan) {
@@ -221,10 +227,12 @@ bMotionPath *animviz_verify_motionpaths(ReportList *reports,
 
   mpath->length = mpath->end_frame - mpath->start_frame;
 
-  if (avs->path_bakeflag & MOTIONPATH_BAKE_HEADS)
+  if (avs->path_bakeflag & MOTIONPATH_BAKE_HEADS) {
     mpath->flag |= MOTIONPATH_FLAG_BHEAD;
-  else
+  }
+  else {
     mpath->flag &= ~MOTIONPATH_FLAG_BHEAD;
+  }
 
   /* set default custom values */
   mpath->color[0] = 1.0; /* Red */
@@ -253,8 +261,9 @@ bMotionPath *animviz_verify_motionpaths(ReportList *reports,
  */
 void free_path(Path *path)
 {
-  if (path->data)
+  if (path->data) {
     MEM_freeN(path->data);
+  }
   MEM_freeN(path);
 }
 
@@ -279,8 +288,9 @@ void calc_curvepath(Object *ob, ListBase *nurbs)
     return;
   }
 
-  if (ob->runtime.curve_cache->path)
+  if (ob->runtime.curve_cache->path) {
     free_path(ob->runtime.curve_cache->path);
+  }
   ob->runtime.curve_cache->path = NULL;
 
   /* weak! can only use first curve */
@@ -312,10 +322,12 @@ void calc_curvepath(Object *ob, ListBase *nurbs)
   *fp = 0.0f;
   for (a = 0; a < tot; a++) {
     fp++;
-    if (cycl && a == tot - 1)
+    if (cycl && a == tot - 1) {
       sub_v3_v3v3(xyz, bevpfirst->vec, bevp->vec);
-    else
+    }
+    else {
       sub_v3_v3v3(xyz, (bevp + 1)->vec, bevp->vec);
+    }
 
     *fp = *(fp - 1) + len_v3(xyz);
     bevp++;
@@ -346,8 +358,9 @@ void calc_curvepath(Object *ob, ListBase *nurbs)
     if (LIKELY(tot > 0)) {
       while ((fp < maxdist) && (d >= *fp)) {
         fp++;
-        if (bevp < bevplast)
+        if (bevp < bevplast) {
           bevp++;
+        }
         bevpn = bevp + 1;
         if (UNLIKELY(bevpn > bevplast)) {
           bevpn = cycl ? bevpfirst : bevplast;
@@ -381,10 +394,12 @@ static int interval_test(const int min, const int max, int p1, const int cycl)
     p1 = mod_i(p1 - min, (max - min + 1)) + min;
   }
   else {
-    if (p1 < min)
+    if (p1 < min) {
       p1 = min;
-    else if (p1 > max)
+    }
+    else if (p1 > max) {
       p1 = max;
+    }
   }
   return p1;
 }
@@ -414,8 +429,9 @@ int where_on_path(Object *ob,
   int cycl = 0, s0, s1, s2, s3;
   ListBase *nurbs;
 
-  if (ob == NULL || ob->type != OB_CURVE)
+  if (ob == NULL || ob->type != OB_CURVE) {
     return 0;
+  }
   cu = ob->data;
   if (ob->runtime.curve_cache == NULL || ob->runtime.curve_cache->path == NULL ||
       ob->runtime.curve_cache->path->data == NULL) {
@@ -427,12 +443,15 @@ int where_on_path(Object *ob,
 
   /* test for cyclic */
   bl = ob->runtime.curve_cache->bev.first;
-  if (!bl)
+  if (!bl) {
     return 0;
-  if (!bl->nr)
+  }
+  if (!bl->nr) {
     return 0;
-  if (bl->poly > -1)
+  }
+  if (bl->poly > -1) {
     cycl = 1;
+  }
 
   /* values below zero for non-cyclic curves give strange results */
   BLI_assert(cycl || ctime >= 0.0f);
@@ -470,19 +489,24 @@ int where_on_path(Object *ob,
   //}
 
   nurbs = BKE_curve_editNurbs_get(cu);
-  if (!nurbs)
+  if (!nurbs) {
     nurbs = &cu->nurb;
+  }
   nu = nurbs->first;
 
   /* make sure that first and last frame are included in the vectors here  */
-  if (nu->type == CU_POLY)
+  if (nu->type == CU_POLY) {
     key_curve_position_weights(1.0f - fac, data, KEY_LINEAR);
-  else if (nu->type == CU_BEZIER)
+  }
+  else if (nu->type == CU_BEZIER) {
     key_curve_position_weights(1.0f - fac, data, KEY_LINEAR);
-  else if (s0 == s1 || p2 == p3)
+  }
+  else if (s0 == s1 || p2 == p3) {
     key_curve_position_weights(1.0f - fac, data, KEY_CARDINAL);
-  else
+  }
+  else {
     key_curve_position_weights(1.0f - fac, data, KEY_BSPLINE);
+  }
 
   vec[0] = data[0] * p0->vec[0] + data[1] * p1->vec[0] + data[2] * p2->vec[0] +
            data[3] * p3->vec[0]; /* X */
@@ -497,31 +521,39 @@ int where_on_path(Object *ob,
     float totfac, q1[4], q2[4];
 
     totfac = data[0] + data[3];
-    if (totfac > FLT_EPSILON)
+    if (totfac > FLT_EPSILON) {
       interp_qt_qtqt(q1, p0->quat, p3->quat, data[3] / totfac);
-    else
+    }
+    else {
       copy_qt_qt(q1, p1->quat);
+    }
 
     totfac = data[1] + data[2];
-    if (totfac > FLT_EPSILON)
+    if (totfac > FLT_EPSILON) {
       interp_qt_qtqt(q2, p1->quat, p2->quat, data[2] / totfac);
-    else
+    }
+    else {
       copy_qt_qt(q2, p3->quat);
+    }
 
     totfac = data[0] + data[1] + data[2] + data[3];
-    if (totfac > FLT_EPSILON)
+    if (totfac > FLT_EPSILON) {
       interp_qt_qtqt(quat, q1, q2, (data[1] + data[2]) / totfac);
-    else
+    }
+    else {
       copy_qt_qt(quat, q2);
+    }
   }
 
-  if (radius)
+  if (radius) {
     *radius = data[0] * p0->radius + data[1] * p1->radius + data[2] * p2->radius +
               data[3] * p3->radius;
+  }
 
-  if (weight)
+  if (weight) {
     *weight = data[0] * p0->weight + data[1] * p1->weight + data[2] * p2->weight +
               data[3] * p3->weight;
+  }
 
   return 1;
 }
index b4b699f..e8bcb66 100644 (file)
@@ -120,8 +120,9 @@ bool id_type_can_have_animdata(const short id_type)
 bool id_can_have_animdata(const ID *id)
 {
   /* sanity check */
-  if (id == NULL)
+  if (id == NULL) {
     return false;
+  }
 
   return id_type_can_have_animdata(GS(id->name));
 }
@@ -140,8 +141,9 @@ AnimData *BKE_animdata_from_id(ID *id)
     IdAdtTemplate *iat = (IdAdtTemplate *)id;
     return iat->adt;
   }
-  else
+  else {
     return NULL;
+  }
 }
 
 /* Add AnimData to the given ID-block. In order for this to work, we assume that
@@ -170,8 +172,9 @@ AnimData *BKE_animdata_add_id(ID *id)
 
     return iat->adt;
   }
-  else
+  else {
     return NULL;
+  }
 }
 
 /* Action Setter --------------------------------------- */
@@ -198,8 +201,9 @@ bool BKE_animdata_set_action(ReportList *reports, ID *id, bAction *act)
   }
 
   /* manage usercount for current action */
-  if (adt->action)
+  if (adt->action) {
     id_us_min((ID *)adt->action);
+  }
 
   /* assume that AnimData's action can in fact be edited... */
   if (act) {
@@ -247,11 +251,13 @@ void BKE_animdata_free(ID *id, const bool do_id_user)
     if (adt) {
       if (do_id_user) {
         /* unlink action (don't free, as it's in its own list) */
-        if (adt->action)
+        if (adt->action) {
           id_us_min(&adt->action->id);
+        }
         /* same goes for the temporarily displaced action */
-        if (adt->tmpact)
+        if (adt->tmpact) {
           id_us_min(&adt->tmpact->id);
+        }
       }
 
       /* free nla data */
@@ -288,8 +294,9 @@ AnimData *BKE_animdata_copy(Main *bmain, AnimData *adt, const int flag)
   const bool do_id_user = (flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0;
 
   /* sanity check before duplicating struct */
-  if (adt == NULL)
+  if (adt == NULL) {
     return NULL;
+  }
   dadt = MEM_dupallocN(adt);
 
   /* make a copy of action - at worst, user has to delete copies... */
@@ -325,8 +332,9 @@ bool BKE_animdata_copy_id(Main *bmain, ID *id_to, ID *id_from, const int flag)
 {
   AnimData *adt;
 
-  if ((id_to && id_from) && (GS(id_to->name) != GS(id_from->name)))
+  if ((id_to && id_from) && (GS(id_to->name) != GS(id_from->name))) {
     return false;
+  }
 
   BKE_animdata_free(id_to, (flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0);
 
@@ -364,8 +372,9 @@ void BKE_animdata_merge_copy(
   AnimData *dst = BKE_animdata_from_id(dst_id);
 
   /* sanity checks */
-  if (ELEM(NULL, dst, src))
+  if (ELEM(NULL, dst, src)) {
     return;
+  }
 
   // TODO: we must unset all "tweakmode" flags
   if ((src->flag & ADT_NLA_EDIT_ON) || (dst->flag & ADT_NLA_EDIT_ON)) {
@@ -501,10 +510,12 @@ void action_move_fcurves_by_basepath(bAction *srcAct, bAction *dstAct, const cha
       /* perform the migration now */
       action_groups_remove_channel(srcAct, fcu);
 
-      if (agrp)
+      if (agrp) {
         action_groups_add_channel(dstAct, agrp, fcu);
-      else
+      }
+      else {
         BLI_addtail(&dstAct->curves, fcu);
+      }
     }
   }
 
@@ -520,10 +531,12 @@ void action_move_fcurves_by_basepath(bAction *srcAct, bAction *dstAct, const cha
         /* if group is empty and tagged, then we can remove as this operation
          * moved out all the channels that were formerly here
          */
-        if (BLI_listbase_is_empty(&agrp->channels))
+        if (BLI_listbase_is_empty(&agrp->channels)) {
           BLI_freelinkN(&srcAct->groups, agrp);
-        else
+        }
+        else {
           agrp->flag &= ~AGRP_TEMP;
+        }
       }
     }
   }
@@ -540,8 +553,9 @@ void BKE_animdata_separate_by_basepath(Main *bmain, ID *srcID, ID *dstID, ListBa
 
   /* sanity checks */
   if (ELEM(NULL, srcID, dstID)) {
-    if (G.debug & G_DEBUG)
+    if (G.debug & G_DEBUG) {
       CLOG_ERROR(&LOG, "no source or destination ID to separate AnimData with");
+    }
     return;
   }
 
@@ -550,8 +564,9 @@ void BKE_animdata_separate_by_basepath(Main *bmain, ID *srcID, ID *dstID, ListBa
   dstAdt = BKE_animdata_add_id(dstID);
 
   if (ELEM(NULL, srcAdt, dstAdt)) {
-    if (G.debug & G_DEBUG)
+    if (G.debug & G_DEBUG) {
       CLOG_ERROR(&LOG, "no AnimData for this pair of ID's");
+    }
     return;
   }
 
@@ -868,8 +883,9 @@ char *BKE_animsys_fix_rna_path_rename(ID *owner_id,
 
   /* if no action, no need to proceed */
   if (ELEM(NULL, owner_id, old_path)) {
-    if (G.debug & G_DEBUG)
+    if (G.debug & G_DEBUG) {
       CLOG_WARN(&LOG, "early abort");
+    }
     return old_path;
   }
 
@@ -892,11 +908,13 @@ char *BKE_animsys_fix_rna_path_rename(ID *owner_id,
   }
 
   /* fix given path */
-  if (G.debug & G_DEBUG)
+  if (G.debug & G_DEBUG) {
     printf("%s | %s  | oldpath = %p ", oldN, newN, old_path);
+  }
   result = rna_path_rename_fix(owner_id, prefix, oldN, newN, old_path, verify_paths);
-  if (G.debug & G_DEBUG)
+  if (G.debug & G_DEBUG) {
     printf("path rename result = %p\n", result);
+  }
 
   /* free the temp names */
   MEM_freeN(oldN);
@@ -926,8 +944,9 @@ void BKE_action_fix_paths_rename(ID *owner_id,
   char *oldN, *newN;
 
   /* if no action, no need to proceed */
-  if (ELEM(NULL, owner_id, act))
+  if (ELEM(NULL, owner_id, act)) {
     return;
+  }
 
   /* Name sanitation logic - copied from BKE_animdata_fix_paths_rename() */
   if ((oldName != NULL) && (newName != NULL)) {
@@ -1031,8 +1050,9 @@ static bool fcurves_path_remove_fix(const char *prefix, ListBase *curves)
 {
   FCurve *fcu, *fcn;
   bool any_removed = false;
-  if (!prefix)
+  if (!prefix) {
     return any_removed;
+  }
 
   /* we need to check every curve... */
   for (fcu = curves->first; fcu; fcu = fcn) {
@@ -1394,8 +1414,9 @@ KS_Path *BKE_keyingset_find_path(KeyingSet *ks,
   KS_Path *ksp;
 
   /* sanity checks */
-  if (ELEM(NULL, ks, rna_path, id))
+  if (ELEM(NULL, ks, rna_path, id)) {
     return NULL;
+  }
 
   /* loop over paths in the current KeyingSet, finding the first one where all settings match
    * (i.e. the first one where none of the checks fail and equal 0)
@@ -1404,16 +1425,19 @@ KS_Path *BKE_keyingset_find_path(KeyingSet *ks,
     short eq_id = 1, eq_path = 1, eq_index = 1, eq_group = 1;
 
     /* id */
-    if (id != ksp->id)
+    if (id != ksp->id) {
       eq_id = 0;
+    }
 
     /* path */
-    if ((ksp->rna_path == NULL) || !STREQ(rna_path, ksp->rna_path))
+    if ((ksp->rna_path == NULL) || !STREQ(rna_path, ksp->rna_path)) {
       eq_path = 0;
+    }
 
     /* index - need to compare whole-array setting too... */
-    if (ksp->array_index != array_index)
+    if (ksp->array_index != array_index) {
       eq_index = 0;
+    }
 
     /* group */
     if (group_name) {
@@ -1421,8 +1445,9 @@ KS_Path *BKE_keyingset_find_path(KeyingSet *ks,
     }
 
     /* if all aspects are ok, return */
-    if (eq_id && eq_path && eq_index && eq_group)
+    if (eq_id && eq_path && eq_index && eq_group) {
       return ksp;
+    }
   }
 
   /* none found */
@@ -1490,8 +1515,9 @@ KS_Path *BKE_keyingset_add_path(KeyingSet *ks,
 
   /* don't add if there is already a matching KS_Path in the KeyingSet */
   if (BKE_keyingset_find_path(ks, id, group_name, rna_path, array_index, groupmode)) {
-    if (G.debug & G_DEBUG)
+    if (G.debug & G_DEBUG) {
       CLOG_ERROR(&LOG, "destination already exists in Keying Set");
+    }
     return NULL;
   }
 
@@ -1500,14 +1526,17 @@ KS_Path *BKE_keyingset_add_path(KeyingSet *ks,
 
   /* just store absolute info */
   ksp->id = id;
-  if (group_name)
+  if (group_name) {
     BLI_strncpy(ksp->group, group_name, sizeof(ksp->group));
-  else
+  }
+  else {
     ksp->group[0] = '\0';
+  }
 
   /* store additional info for relative paths (just in case user makes the set relative) */
-  if (id)
+  if (id) {
     ksp->idtype = GS(id->name);
+  }
 
   /* just copy path info */
   /* TODO: should array index be checked too? */
@@ -1529,12 +1558,14 @@ KS_Path *BKE_keyingset_add_path(KeyingSet *ks,
 void BKE_keyingset_free_path(KeyingSet *ks, KS_Path *ksp)
 {
   /* sanity check */
-  if (ELEM(NULL, ks, ksp))
+  if (ELEM(NULL, ks, ksp)) {
     return;
+  }
 
   /* free RNA-path info */
-  if (ksp->rna_path)
+  if (ksp->rna_path) {
     MEM_freeN(ksp->rna_path);
+  }
 
   /* free path itself */
   BLI_freelinkN(&ks->paths, ksp);
@@ -1551,8 +1582,9 @@ void BKE_keyingsets_copy(ListBase *newlist, const ListBase *list)
   for (ksn = newlist->first; ksn; ksn = ksn->next) {
     BLI_duplicatelist(&ksn->paths, &ksn->paths);
 
-    for (kspn = ksn->paths.first; kspn; kspn = kspn->next)
+    for (kspn = ksn->paths.first; kspn; kspn = kspn->next) {
       kspn->rna_path = MEM_dupallocN(kspn->rna_path);
+    }
   }
 }
 
@@ -1564,8 +1596,9 @@ void BKE_keyingset_free(KeyingSet *ks)
   KS_Path *ksp, *kspn;
 
   /* sanity check */
-  if (ks == NULL)
+  if (ks == NULL) {
     return;
+  }
 
   /* free each path as we go to avoid looping twice */
   for (ksp = ks->paths.first; ksp; ksp = kspn) {
@@ -1580,8 +1613,9 @@ void BKE_keyingsets_free(ListBase *list)
   KeyingSet *ks, *ksn;
 
   /* sanity check */
-  if (list == NULL)
+  if (list == NULL) {
     return;
+  }
 
   /* loop over KeyingSets freeing them
    * - BKE_keyingset_free() doesn't free the set itself, but it frees its sub-data
@@ -1874,8 +1908,9 @@ static void animsys_evaluate_drivers(PointerRNA *ptr, AnimData *adt, float ctime
         }
 
         /* set error-flag if evaluation failed */
-        if (ok == 0)
+        if (ok == 0) {
           driver->flag |= DRIVER_FLAG_INVALID;
+        }
       }
     }
   }
@@ -1893,10 +1928,12 @@ static void action_idcode_patch_check(ID *id, bAction *act)
   int idcode = 0;
 
   /* just in case */
-  if (ELEM(NULL, id, act))
+  if (ELEM(NULL, id, act)) {
     return;
-  else
+  }
+  else {
     idcode = GS(id->name);
+  }
 
   /* the actual checks... hopefully not too much of a performance hit in the long run... */
   if (act->idroot == 0) {
@@ -1927,14 +1964,16 @@ void animsys_evaluate_action_group(PointerRNA *ptr, bAction *act, bActionGroup *
   FCurve *fcu;
 
   /* check if mapper is appropriate for use here (we set to NULL if it's inappropriate) */
-  if (ELEM(NULL, act, agrp))
+  if (ELEM(NULL, act, agrp)) {
     return;
+  }
 
   action_idcode_patch_check(ptr->id.data, act);
 
   /* if group is muted, don't evaluated any of the F-Curve */
-  if (agrp->flag & AGRP_MUTED)
+  if (agrp->flag & AGRP_MUTED) {
     return;
+  }
 
   /* calculate then execute each curve */
   for (fcu = agrp->channels.first; (fcu) && (fcu->grp == agrp); fcu = fcu->next) {
@@ -1956,8 +1995,9 @@ static void animsys_evaluate_action_ex(Depsgraph *depsgraph,
                                        float ctime)
 {
   /* check if mapper is appropriate for use here (we set to NULL if it's inappropriate) */
-  if (act == NULL)
+  if (act == NULL) {
     return;
+  }
 
   action_idcode_patch_check(ptr->id.data, act);
 
@@ -2013,8 +2053,9 @@ static void nlastrip_evaluate_controls(Depsgraph *depsgraph, NlaStrip *strip, fl
    * - we do this after the F-Curves have been evaluated to override the effects of those
    *   in case the override has been turned off.
    */
-  if ((strip->flag & NLASTRIP_FLAG_USR_INFLUENCE) == 0)
+  if ((strip->flag & NLASTRIP_FLAG_USR_INFLUENCE) == 0) {
     strip->influence = nlastrip_get_influence(strip, ctime);
+  }
 
   /* Bypass evaluation time computation if time mapping is disabled. */
   if ((strip->flag & NLASTRIP_FLAG_NO_TIME_MAP) != 0) {
@@ -2022,16 +2063,18 @@ static void nlastrip_evaluate_controls(Depsgraph *depsgraph, NlaStrip *strip, fl
     return;
   }
 
-  if ((strip->flag & NLASTRIP_FLAG_USR_TIME) == 0)
+  if ((strip->flag & NLASTRIP_FLAG_USR_TIME) == 0) {
     strip->strip_time = nlastrip_get_frame(strip, ctime, NLATIME_CONVERT_EVAL);
+  }
 
   /* if user can control the evaluation time (using F-Curves), consider the option which allows this time to be clamped
    * to lie within extents of the action-clip, so that a steady changing rate of progress through several cycles of the clip
    * can be achieved easily
    */
   /* NOTE: if we add any more of these special cases, we better group them up nicely... */
-  if ((strip->flag & NLASTRIP_FLAG_USR_TIME) && (strip->flag & NLASTRIP_FLAG_USR_TIME_CYCLIC))
+  if ((strip->flag & NLASTRIP_FLAG_USR_TIME) && (strip->flag & NLASTRIP_FLAG_USR_TIME_CYCLIC)) {
     strip->strip_time = fmod(strip->strip_time - strip->actstart, strip->actend - strip->actstart);
+  }
 }
 
 /* gets the strip active at the current time for a list of strips for evaluation purposes */
@@ -2057,8 +2100,9 @@ NlaEvalStrip *nlastrips_ctime_get_strip(
     if (ctime < strip->start) {
       if (strip == strips->first) {
         /* before first strip - only try to use it if it extends backwards in time too */
-        if (strip->extendmode == NLASTRIP_EXTEND_HOLD)
+        if (strip->extendmode == NLASTRIP_EXTEND_HOLD) {
           estrip = strip;
+        }
 
         /* side is 'before' regardless of whether there's a useful strip */
         side = NES_TIME_BEFORE;
@@ -2071,8 +2115,9 @@ NlaEvalStrip *nlastrips_ctime_get_strip(
          */
         strip = strip->prev;
 
-        if (strip->extendmode != NLASTRIP_EXTEND_NOTHING)
+        if (strip->extendmode != NLASTRIP_EXTEND_NOTHING) {
           estrip = strip;
+        }
         side = NES_TIME_AFTER;
       }
       break;
@@ -2082,8 +2127,9 @@ NlaEvalStrip *nlastrips_ctime_get_strip(
     if (ctime > strip->end) {
       /* only if this is the last strip should we do anything, and only if that is being held */
       if (strip == strips->last) {
-        if (strip->extendmode != NLASTRIP_EXTEND_NOTHING)
+        if (strip->extendmode != NLASTRIP_EXTEND_NOTHING) {
           estrip = strip;
+        }
 
         side = NES_TIME_AFTER;
         break;
@@ -2096,8 +2142,9 @@ NlaEvalStrip *nlastrips_ctime_get_strip(
   /* check if a valid strip was found
    * - must not be muted (i.e. will have contribution
    */
-  if ((estrip == NULL) || (estrip->flag & NLASTRIP_FLAG_MUTED))
+  if ((estrip == NULL) || (estrip->flag & NLASTRIP_FLAG_MUTED)) {
     return NULL;
+  }
 
   /* if ctime was not within the boundaries of the strip, clamp! */
   switch (side) {
@@ -2115,8 +2162,9 @@ NlaEvalStrip *nlastrips_ctime_get_strip(
    */
   /* TODO: this sounds a bit hacky having a few isolated F-Curves stuck on some data it operates on... */
   nlastrip_evaluate_controls(depsgraph, estrip, ctime);
-  if (estrip->influence <= 0.0f)
+  if (estrip->influence <= 0.0f) {
     return NULL;
+  }
 
   /* check if strip has valid data to evaluate,
    * and/or perform any additional type-specific actions
@@ -2124,13 +2172,15 @@ NlaEvalStrip *nlastrips_ctime_get_strip(
   switch (estrip->type) {
     case NLASTRIP_TYPE_CLIP:
       /* clip must have some action to evaluate */
-      if (estrip->act == NULL)
+      if (estrip->act == NULL) {
         return NULL;
+      }
       break;
     case NLASTRIP_TYPE_TRANSITION:
       /* there must be strips to transition from and to (i.e. prev and next required) */
-      if (ELEM(NULL, estrip->prev, estrip->next))
+      if (ELEM(NULL, estrip->prev, estrip->next)) {
         return NULL;
+      }
 
       /* evaluate controls for the relevant extents of the bordering strips... */
       nlastrip_evaluate_controls(depsgraph, estrip->prev, estrip->start);
@@ -2146,8 +2196,9 @@ NlaEvalStrip *nlastrips_ctime_get_strip(
   nes->track_index = index;
   nes->strip_time = estrip->strip_time;
 
-  if (list)
+  if (list) {
     BLI_addtail(list, nes);
+  }
 
   return nes;
 }
@@ -2948,10 +2999,12 @@ static void nlaeval_fmodifiers_split_stacks(ListBase *list1, ListBase *list2)
   FModifier *fcm1, *fcm2;
 
   /* if list1/2 is invalid... just skip */
-  if (ELEM(NULL, list1, list2))
+  if (ELEM(NULL, list1, list2)) {
     return;
-  if (ELEM(NULL, list1->first, list2->first))
+  }
+  if (ELEM(NULL, list1->first, list2->first)) {
     return;
+  }
 
   /* get endpoints */
   fcm1 = list1->last;
@@ -2977,8 +3030,9 @@ static void nlastrip_evaluate_actionclip(PointerRNA *ptr,
   float evaltime;
 
   /* sanity checks for action */
-  if (strip == NULL)
+  if (strip == NULL) {
     return;
+  }
 
   if (strip->act == NULL) {
     CLOG_ERROR(&LOG, "NLA-Strip Eval Error: Strip '%s' has no Action", strip->name);
@@ -3009,10 +3063,12 @@ static void nlastrip_evaluate_actionclip(PointerRNA *ptr,
     float value = 0.0f;
 
     /* check if this curve should be skipped */
-    if (fcu->flag & (FCURVE_MUTED | FCURVE_DISABLED))
+    if (fcu->flag & (FCURVE_MUTED | FCURVE_DISABLED)) {
       continue;
-    if ((fcu->grp) && (fcu->grp->flag & AGRP_MUTED))
+    }
+    if ((fcu->grp) && (fcu->grp->flag & AGRP_MUTED)) {
       continue;
+    }
 
     /* evaluate the F-Curve's value for the time given in the strip
      * NOTE: we use the modified time here, since strip's F-Curve Modifiers are applied on top of this
@@ -3156,8 +3212,9 @@ void nlastrip_evaluate(Depsgraph *depsgraph,
    * several levels deep inside it), we tag the current strip as being evaluated, and clear this when we leave
    */
   /* TODO: be careful with this flag, since some edit tools may be running and have set this while animplayback was running */
-  if (strip->flag & NLASTRIP_FLAG_EDIT_TOUCHED)
+  if (strip->flag & NLASTRIP_FLAG_EDIT_TOUCHED) {
     return;
+  }
   strip->flag |= NLASTRIP_FLAG_EDIT_TOUCHED;
 
   /* actions to take depend on the type of strip */
@@ -3187,8 +3244,9 @@ void nladata_flush_channels(Depsgraph *depsgraph,
                             NlaEvalSnapshot *snapshot)
 {
   /* sanity checks */
-  if (channels == NULL)
+  if (channels == NULL) {
     return;
+  }
 
   const bool is_active_depsgraph = DEG_is_active(depsgraph);
 
@@ -3226,10 +3284,12 @@ static void nla_eval_domain_action(PointerRNA *ptr,
 
   for (FCurve *fcu = act->curves.first; fcu; fcu = fcu->next) {
     /* check if this curve should be skipped */
-    if (fcu->flag & (FCURVE_MUTED | FCURVE_DISABLED))
+    if (fcu->flag & (FCURVE_MUTED | FCURVE_DISABLED)) {
       continue;
-    if ((fcu->grp) && (fcu->grp->flag & AGRP_MUTED))
+    }
+    if ((fcu->grp) && (fcu->grp->flag & AGRP_MUTED)) {
       continue;
+    }
 
     NlaEvalChannel *nec = nlaevalchan_verify(ptr, channels, fcu->rna_path);
 
@@ -3282,14 +3342,16 @@ static void animsys_evaluate_nla_domain(PointerRNA *ptr, NlaEvalData *channels,
     /* solo and muting are mutually exclusive... */
     if (adt->flag & ADT_NLA_SOLO_TRACK) {
       /* skip if there is a solo track, but this isn't it */
-      if ((nlt->flag & NLATRACK_SOLO) == 0)
+      if ((nlt->flag & NLATRACK_SOLO) == 0) {
         continue;
+      }
       /* else - mute doesn't matter */
     }
     else {
       /* no solo tracks - skip track if muted */
-      if (nlt->flag & NLATRACK_MUTED)
+      if (nlt->flag & NLATRACK_MUTED) {
         continue;
+      }
     }
 
     nla_eval_domain_strips(ptr, channels, &nlt->strips, touched_actions);
@@ -3330,32 +3392,37 @@ static bool animsys_evaluate_nla(Depsgraph *depsgraph,
   /* 1. get the stack of strips to evaluate at current time (influence calculated here) */
   for (nlt = adt->nla_tracks.first; nlt; nlt = nlt->next, track_index++) {
     /* stop here if tweaking is on and this strip is the tweaking track (it will be the first one that's 'disabled')... */
-    if ((adt->flag & ADT_NLA_EDIT_ON) && (nlt->flag & NLATRACK_DISABLED))
+    if ((adt->flag & ADT_NLA_EDIT_ON) && (nlt->flag & NLATRACK_DISABLED)) {
       break;
+    }
 
     /* solo and muting are mutually exclusive... */
     if (adt->flag & ADT_NLA_SOLO_TRACK) {
       /* skip if there is a solo track, but this isn't it */
-      if ((nlt->flag & NLATRACK_SOLO) == 0)
+      if ((nlt->flag & NLATRACK_SOLO) == 0) {
         continue;
+      }
       /* else - mute doesn't matter */
     }
     else {
       /* no solo tracks - skip track if muted */
-      if (nlt->flag & NLATRACK_MUTED)
+      if (nlt->flag & NLATRACK_MUTED) {
         continue;
+      }
     }
 
     /* if this track has strips (but maybe they won't be suitable), set has_strips
      * - used for mainly for still allowing normal action evaluation...
      */
-    if (nlt->strips.first)
+    if (nlt->strips.first) {
       has_strips = true;
+    }
 
     /* otherwise, get strip to evaluate for this channel */
     nes = nlastrips_ctime_get_strip(depsgraph, &estrips, &nlt->strips, track_index, ctime);
-    if (nes)
+    if (nes) {
       nes->track = nlt;
+    }
   }
 
   /* add 'active' Action (may be tweaking track) as last strip to evaluate in NLA stack
@@ -3442,12 +3509,14 @@ static bool animsys_evaluate_nla(Depsgraph *depsgraph,
   }
 
   /* only continue if there are strips to evaluate */
-  if (BLI_listbase_is_empty(&estrips))
+  if (BLI_listbase_is_empty(&estrips)) {
     return true;
+  }
 
   /* 2. for each strip, evaluate then accumulate on top of existing channels, but don't set values yet */
-  for (nes = estrips.first; nes; nes = nes->next)
+  for (nes = estrips.first; nes; nes = nes->next) {
     nlastrip_evaluate(depsgraph, ptr, echannels, NULL, nes, &echannels->eval_snapshot);
+  }
 
   /* 3. free temporary evaluation data that's not used elsewhere */
   BLI_freelistN(&estrips);
@@ -3478,8 +3547,9 @@ static void animsys_calculate_nla(Depsgraph *depsgraph,
   else {
     /* special case - evaluate as if there isn't any NLA data */
     /* TODO: this is really just a stop-gap measure... */
-    if (G.debug & G_DEBUG)
+    if (G.debug & G_DEBUG) {
       CLOG_WARN(&LOG, "NLA Eval: Stopgap for active action on NLA Stack - no strips case");
+    }
 
     animsys_evaluate_action(depsgraph, ptr, adt->action, ctime);
   }
@@ -3716,8 +3786,9 @@ void BKE_animsys_evaluate_animdata(
   PointerRNA id_ptr;
 
   /* sanity checks */
-  if (ELEM(NULL, id, adt))
+  if (ELEM(NULL, id, adt)) {
     return;
+  }
 
   /* get pointer to ID-block for RNA to use */
   RNA_id_pointer_create(id, &id_ptr);
@@ -3736,8 +3807,9 @@ void BKE_animsys_evaluate_animdata(
       animsys_calculate_nla(depsgraph, &id_ptr, adt, ctime);
     }
     /* evaluate Active Action only */
-    else if (adt->action)
+    else if (adt->action) {
       animsys_evaluate_action_ex(depsgraph, &id_ptr, adt->action, ctime);
+    }
   }
 
   /* recalculate drivers
@@ -3779,10 +3851,11 @@ void BKE_animsys_evaluate_all_animation(Main *main,
 {
   ID *id;
 
-  if (G.debug & G_DEBUG)
+  if (G.debug & G_DEBUG) {
     printf("Evaluate all animation - %f\n", ctime);
+  }
 
-    /* macros for less typing
+  /* macros for less typing
      * - only evaluate animation data for id if it has users (and not just fake ones)
      * - whether animdata exists is checked for by the evaluation function, though taking
      *   this outside of the function may make things slightly faster?
@@ -3796,7 +3869,7 @@ void BKE_animsys_evaluate_all_animation(Main *main,
   } \
   (void)0
 
-    /* another macro for the "embedded" nodetree cases
+  /* another macro for the "embedded" nodetree cases
      * - this is like EVAL_ANIM_IDS, but this handles the case "embedded nodetrees"
      *   (i.e. scene/material/texture->nodetree) which we need a special exception
      *   for, otherwise they'd get skipped
@@ -3826,8 +3899,9 @@ void BKE_animsys_evaluate_all_animation(Main *main,
    * set correctly, so this optimization must be skipped in that case...
    */
   if (BLI_listbase_is_empty(&main->actions) && BLI_listbase_is_empty(&main->curves)) {
-    if (G.debug & G_DEBUG)
+    if (G.debug & G_DEBUG) {
       printf("\tNo Actions, so no animation needs to be evaluated...\n");
+    }
 
     return;
   }
index 5383138..0986596 100644 (file)
@@ -73,8 +73,9 @@ const char *BKE_appdir_folder_default(void)
 #ifndef WIN32
   const char *const xdg_documents_dir = BLI_getenv("XDG_DOCUMENTS_DIR");
 
-  if (xdg_documents_dir)
+  if (xdg_documents_dir) {
     return xdg_documents_dir;
+  }
 
   return BLI_getenv("HOME");
 #else  /* Windows */
@@ -83,8 +84,9 @@ const char *BKE_appdir_folder_default(void)
 
   /* Check for %HOME% env var */
   if (uput_getenv("HOME", documentfolder, MAXPATHLEN)) {
-    if (BLI_is_dir(documentfolder))
+    if (BLI_is_dir(documentfolder)) {
       return documentfolder;
+    }
   }
 
   /* add user profile support for WIN 2K / NT.
@@ -95,8 +97,9 @@ const char *BKE_appdir_folder_default(void)
   hResult = SHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, SHGFP_TYPE_CURRENT, documentfolder);
 
   if (hResult == S_OK) {
-    if (BLI_is_dir(documentfolder))
+    if (BLI_is_dir(documentfolder)) {
       return documentfolder;
+    }
   }
 
   return NULL;
@@ -165,8 +168,9 @@ static bool test_path(char *targetpath,
 static bool test_env_path(char *path, const char *envvar)
 {
   const char *env = envvar ? BLI_getenv(envvar) : NULL;
-  if (!env)
+  if (!env) {
     return false;
+  }
 
   if (BLI_is_dir(env)) {
     BLI_strncpy(path, env, FILE_MAX);
@@ -324,11 +328,13 @@ static bool get_path_user(char *targetpath,
   user_path[0] = '\0';
 
   user_base_path = (const char *)GHOST_getUserDir(ver, blender_version_decimal(ver));
-  if (user_base_path)
+  if (user_base_path) {
     BLI_strncpy(user_path, user_base_path, FILE_MAX);
+  }
 
-  if (!user_path[0])
+  if (!user_path[0]) {
     return false;
+  }
 
 #ifdef PATH_DEBUG
   printf("%s: %s\n", __func__, user_path);
@@ -375,11 +381,13 @@ static bool get_path_system(char *targetpath,
 
   system_path[0] = '\0';
   system_base_path = (const char *)GHOST_getSystemDir(ver, blender_version_decimal(ver));
-  if (system_base_path)
+  if (system_base_path) {
     BLI_strncpy(system_path, system_base_path, FILE_MAX);
+  }
 
-  if (!system_path[0])
+  if (!system_path[0]) {
     return false;
+  }
 
 #ifdef PATH_DEBUG
   printf("%s: %s\n", __func__, system_path);
@@ -411,71 +419,93 @@ const char *BKE_appdir_folder_id_ex(const int folder_id,
 
   switch (folder_id) {
     case BLENDER_DATAFILES: /* general case */
-      if (get_path_environment(path, path_len, subfolder, "BLENDER_USER_DATAFILES"))
+      if (get_path_environment(path, path_len, subfolder, "BLENDER_USER_DATAFILES")) {
         break;
-      if (get_path_user(path, path_len, "datafiles", subfolder, ver))
+      }
+      if (get_path_user(path, path_len, "datafiles", subfolder, ver)) {
         break;
-      if (get_path_environment(path, path_len, subfolder, "BLENDER_SYSTEM_DATAFILES"))
+      }
+      if (get_path_environment(path, path_len, subfolder, "BLENDER_SYSTEM_DATAFILES")) {
         break;
-      if (get_path_local(path, path_len, "datafiles", subfolder, ver))
+      }
+      if (get_path_local(path, path_len, "datafiles", subfolder, ver)) {
         break;
-      if (get_path_system(path, path_len, "datafiles", subfolder, ver))
+      }
+      if (get_path_system(path, path_len, "datafiles", subfolder, ver)) {
         break;
+      }
       return NULL;
 
     case BLENDER_USER_DATAFILES:
-      if (get_path_environment(path, path_len, subfolder, "BLENDER_USER_DATAFILES"))
+      if (get_path_environment(path, path_len, subfolder, "BLENDER_USER_DATAFILES")) {
         break;
-      if (get_path_user(path, path_len, "datafiles", subfolder, ver))
+      }
+      if (get_path_user(path, path_len, "datafiles", subfolder, ver)) {
         break;
+      }
       return NULL;
 
     case BLENDER_SYSTEM_DATAFILES:
-      if (get_path_environment(path, path_len, subfolder, "BLENDER_SYSTEM_DATAFILES"))
+      if (get_path_environment(path, path_len, subfolder, "BLENDER_SYSTEM_DATAFILES")) {
         break;
-      if (get_path_system(path, path_len, "datafiles", subfolder, ver))
+      }
+      if (get_path_system(path, path_len, "datafiles", subfolder, ver)) {
         break;
-      if (get_path_local(path, path_len, "datafiles", subfolder, ver))
+      }
+      if (get_path_local(path, path_len, "datafiles", subfolder, ver)) {
         break;
+      }
       return NULL;
 
     case BLENDER_USER_AUTOSAVE:
-      if (get_path_environment(path, path_len, subfolder, "BLENDER_USER_DATAFILES"))
+      if (get_path_environment(path, path_len, subfolder, "BLENDER_USER_DATAFILES")) {
         break;
-      if (get_path_user(path, path_len, "autosave", subfolder, ver))
+      }
+      if (get_path_user(path, path_len, "autosave", subfolder, ver)) {
         break;
+      }
       return NULL;
 
     case BLENDER_USER_CONFIG:
-      if (get_path_environment(path, path_len, subfolder, "BLENDER_USER_CONFIG"))
+      if (get_path_environment(path, path_len, subfolder, "BLENDER_USER_CONFIG")) {
         break;
-      if (get_path_user(path, path_len, "config", subfolder, ver))
+      }
+      if (get_path_user(path, path_len, "config", subfolder, ver)) {
         break;
+      }
       return NULL;
 
     case BLENDER_USER_SCRIPTS:
-      if (get_path_environment(path, path_len, subfolder, "BLENDER_USER_SCRIPTS"))
+      if (get_path_environment(path, path_len, subfolder, "BLENDER_USER_SCRIPTS")) {
         break;
-      if (get_path_user(path, path_len, "scripts", subfolder, ver))
+      }
+      if (get_path_user(path, path_len, "scripts", subfolder, ver)) {
         break;
+      }
       return NULL;
 
     case BLENDER_SYSTEM_SCRIPTS:
-      if (get_path_environment(path, path_len, subfolder, "BLENDER_SYSTEM_SCRIPTS"))
+      if (get_path_environment(path, path_len, subfolder, "BLENDER_SYSTEM_SCRIPTS")) {
         break;
-      if (get_path_system(path, path_len, "scripts", subfolder, ver))
+      }
+      if (get_path_system(path, path_len, "scripts", subfolder, ver)) {
         break;
-      if (get_path_local(path, path_len, "scripts", subfolder, ver))
+      }
+      if (get_path_local(path, path_len, "scripts", subfolder, ver)) {
         break;
+      }
       return NULL;
 
     case BLENDER_SYSTEM_PYTHON:
-      if (get_path_environment(path, path_len, subfolder, "BLENDER_SYSTEM_PYTHON"))
+      if (get_path_environment(path, path_len, subfolder, "BLENDER_SYSTEM_PYTHON")) {
         break;
-      if (get_path_system(path, path_len, "python", subfolder, ver))
+      }
+      if (get_path_system(path, path_len, "python", subfolder, ver)) {
         break;
-      if (get_path_local(path, path_len, "python", subfolder, ver))
+      }
+      if (get_path_local(path, path_len, "python", subfolder, ver)) {
         break;
+      }
       return NULL;
 
     default:
@@ -502,23 +532,27 @@ const char *BKE_appdir_folder_id_user_notest(const int folder_id, const char *su
 
   switch (folder_id) {
     case BLENDER_USER_DATAFILES:
-      if (get_path_environment_notest(path, sizeof(path), subfolder, "BLENDER_USER_DATAFILES"))
+      if (get_path_environment_notest(path, sizeof(path), subfolder, "BLENDER_USER_DATAFILES")) {
         break;
+      }
       get_path_user(path, sizeof(path), "datafiles", subfolder, ver);
       break;
     case BLENDER_USER_CONFIG:
-      if (get_path_environment_notest(path, sizeof(path), subfolder, "BLENDER_USER_CONFIG"))
+      if (get_path_environment_notest(path, sizeof(path), subfolder, "BLENDER_USER_CONFIG")) {
         break;
+      }
       get_path_user(path, sizeof(path), "config", subfolder, ver);
       break;
     case BLENDER_USER_AUTOSAVE:
-      if (get_path_environment_notest(path, sizeof(path), subfolder, "BLENDER_USER_AUTOSAVE"))
+      if (get_path_environment_notest(path, sizeof(path), subfolder, "BLENDER_USER_AUTOSAVE")) {
         break;
+      }
       get_path_user(path, sizeof(path), "autosave", subfolder, ver);
       break;
     case BLENDER_USER_SCRIPTS:
-      if (get_path_environment_notest(path, sizeof(path), subfolder, "BLENDER_USER_SCRIPTS"))
+      if (get_path_environment_notest(path, sizeof(path), subfolder, "BLENDER_USER_SCRIPTS")) {
         break;
+      }
       get_path_user(path, sizeof(path), "scripts", subfolder, ver);
       break;
     default:
@@ -544,15 +578,17 @@ const char *BKE_appdir_folder_id_create(const int folder_id, const char *subfold
             BLENDER_USER_DATAFILES,
             BLENDER_USER_CONFIG,
             BLENDER_USER_SCRIPTS,
-            BLENDER_USER_AUTOSAVE))
+            BLENDER_USER_AUTOSAVE)) {
     return NULL;
+  }
 
   path = BKE_appdir_folder_id(folder_id, subfolder);
 
   if (!path) {
     path = BKE_appdir_folder_id_user_notest(folder_id, subfolder);
-    if (path)
+    if (path) {
       BLI_dir_create_recursive(path);
+    }
   }
 
   return path;
index 6cbc990..b726ea6 100644 (file)
@@ -89,8 +89,9 @@ bArmature *BKE_armature_add(Main *bmain, const char *name)
 
 bArmature *BKE_armature_from_object(Object *ob)
 {
-  if (ob->type == OB_ARMATURE)
+  if (ob->type == OB_ARMATURE) {
     return (bArmature *)ob->data;
+  }
   return NULL;
 }
 
@@ -215,12 +216,14 @@ static Bone *get_named_bone_bonechildren(ListBase *lb, const char *name)
   Bone *curBone, *rbone;
 
   for (curBone = lb->first; curBone; curBone = curBone->next) {
-    if (STREQ(curBone->name, name))
+    if (STREQ(curBone->name, name)) {
       return curBone;
+    }
 
     rbone = get_named_bone_bonechildren(&curBone->childbase, name);
-    if (rbone)
+    if (rbone) {
       return rbone;
+    }
   }
 
   return NULL;
@@ -232,8 +235,9 @@ static Bone *get_named_bone_bonechildren(ListBase *lb, const char *name)
  */
 Bone *BKE_armature_find_bone_name(bArmature *arm, const char *name)
 {
-  if (!arm)
+  if (!arm) {
     return NULL;
+  }
 
   return get_named_bone_bonechildren(&arm->bonebase, name);
 }
@@ -285,8 +289,9 @@ int bone_autoside_name(
   char extension[5] = "";
 
   len = strlen(name);
-  if (len == 0)
+  if (len == 0) {
     return 0;
+  }
   BLI_strncpy(basename, name, sizeof(basename));
 
   /* Figure out extension to append:
@@ -300,47 +305,59 @@ int bone_autoside_name(
   if (axis == 2) {
     /* z-axis - vertical (top/bottom) */
     if (IS_EQF(head, 0.0f)) {
-      if (tail < 0)
+      if (tail < 0) {
         strcpy(extension, "Bot");
-      else if (tail > 0)
+      }
+      else if (tail > 0) {
         strcpy(extension, "Top");
+      }
     }
     else {
-      if (head < 0)
+      if (head < 0) {
         strcpy(extension, "Bot");
-      else
+      }
+      else {
         strcpy(extension, "Top");
+      }
     }
   }
   else if (axis == 1) {
     /* y-axis - depth (front/back) */
     if (IS_EQF(head, 0.0f)) {
-      if (tail < 0)
+      if (tail < 0) {
         strcpy(extension, "Fr");
-      else if (tail > 0)
+      }
+      else if (tail > 0) {
         strcpy(extension, "Bk");
+      }
     }
     else {
-      if (head < 0)
+      if (head < 0) {
         strcpy(extension, "Fr");
-      else
+      }
+      else {
         strcpy(extension, "Bk");
+      }
     }
   }
   else {
     /* x-axis - horizontal (left/right) */
     if (IS_EQF(head, 0.0f)) {
-      if (tail < 0)
+      if (tail < 0) {
         strcpy(extension, "R");
-      else if (tail > 0)
+      }
+      else if (tail > 0) {
         strcpy(extension, "L");
+      }
     }
     else {
-      if (head < 0)
+      if (head < 0) {
         strcpy(extension, "R");
-      /* XXX Shouldn't this be simple else, as for z and y axes? */
-      else if (head > 0)
+        /* XXX Shouldn't this be simple else, as for z and y axes? */
+      }
+      else if (head > 0) {
         strcpy(extension, "L");
+      }
     }
   }
 
@@ -391,8 +408,9 @@ int bone_autoside_name(
     return 1;
   }
 
-  else
+  else {
     return 0;
+  }
 }
 
 /* ************* B-Bone support ******************* */
@@ -420,8 +438,9 @@ static void equalize_cubic_bezier(const float control[4][3],
   /* Calculate the length of the polyline at each point. */
   pdist[0] = 0.0f;
 
-  for (int i = 0; i < temp_segments; i++)
+  for (int i = 0; i < temp_segments; i++) {
     pdist[i + 1] = pdist[i] + len_v3v3(coords[i], coords[i + 1]);
+  }
 
   /* Go over distances and calculate new parameter values. */
   float dist_step = pdist[temp_segments] / final_segments;
@@ -432,8 +451,9 @@ static void equalize_cubic_bezier(const float control[4][3],
     float dist = i * dist_step;
 
     /* We're looking for location (distance) 'dist' in the array. */
-    while ((nr < temp_segments) && (dist >= pdist[nr]))
+    while ((nr < temp_segments) && (dist >= pdist[nr])) {
       nr++;
+    }
 
     float fac = (pdist[nr] - dist) / (pdist[nr] - pdist[nr - 1]);
 
@@ -713,8 +733,9 @@ void BKE_pchan_bbone_handles_compute(const BBoneSplineParameters *param,
       h1[1] -= length;
     }
 
-    if (normalize_v3(h1) < epsilon)
+    if (normalize_v3(h1) < epsilon) {
       copy_v3_fl3(h1, 0.0f, -1.0f, 0.0f);
+    }
 
     negate_v3(h1);
 
@@ -741,8 +762,9 @@ void BKE_pchan_bbone_handles_compute(const BBoneSplineParameters *param,
       h2[1] -= length;
     }
 
-    if (normalize_v3(h2) < epsilon)
+    if (normalize_v3(h2) < epsilon) {
       copy_v3_fl3(h2, 0.0f, 1.0f, 0.0f);
+    }
 
     /* Find the next roll to interpolate as well. */
     copy_m3_m4(mat3, param->next_mat);
@@ -1058,8 +1080,9 @@ static void pchan_deform_accumulate(const DualQuat *deform_dq,
                                     DualQuat *dq_accum,
                                     float mat_accum[3][3])
 {
-  if (weight == 0.0f)
+  if (weight == 0.0f) {
     return;
+  }
 
   if (dq_accum) {
     BLI_assert(!co_accum);
@@ -1141,18 +1164,21 @@ float distfactor_to_bone(
       rad = a / l;
       rad = rad * rad2 + (1.0f - rad) * rad1;
     }
-    else
+    else {
       rad = rad1;
+    }
   }
 
   a = rad * rad;
-  if (dist_sq < a)
+  if (dist_sq < a) {
     return 1.0f;
+  }
   else {
     l = rad + rdist;
     l *= l;
-    if (rdist == 0.0f || dist_sq >= l)
+    if (rdist == 0.0f || dist_sq >= l) {
       return 0.0f;
+    }
     else {
       a = sqrtf(dist_sq) - rad;
       return 1.0f - (a * a) / (rdist * rdist);
@@ -1166,8 +1192,9 @@ static float dist_bone_deform(
   Bone *bone = pchan->bone;
   float fac, contrib = 0.0;
 
-  if (bone == NULL)
+  if (bone == NULL) {
     return 0.0f;
+  }
 
   fac = distfactor_to_bone(
       co, bone->arm_head, bone->arm_tail, bone->rad_head, bone->rad_tail, bone->dist);
@@ -1176,11 +1203,13 @@ static float dist_bone_deform(
     fac *= bone->weight;
     contrib = fac;
     if (contrib > 0.0f) {
-      if (bone->segments > 1 && pchan->runtime.bbone_segments == bone->segments)
+      if (bone->segments > 1 && pchan->runtime.bbone_segments == bone->segments) {
         b_bone_deform(pchan, co, fac, vec, dq, mat);
-      else
+      }
+      else {
         pchan_deform_accumulate(
             &pchan->runtime.deform_dual_quat, pchan->chan_mat, co, fac, vec, dq, mat);
+      }
     }
   }
 
@@ -1197,14 +1226,17 @@ static void pchan_bone_deform(bPoseChannel *pchan,
 {
   Bone *bone = pchan->bone;
 
-  if (!weight)
+  if (!weight) {
     return;
+  }
 
-  if (bone->segments > 1 && pchan->runtime.bbone_segments == bone->segments)
+  if (bone->segments > 1 && pchan->runtime.bbone_segments == bone->segments) {
     b_bone_deform(pchan, co, weight, vec, dq, mat);
-  else
+  }
+  else {
     pchan_deform_accumulate(
         &pchan->runtime.deform_dual_quat, pchan->chan_mat, co, weight, vec, dq, mat);
+  }
 
   (*contrib) += weight;
 }
@@ -1259,19 +1291,22 @@ void armature_deform_verts(Object *armOb,
     if (target->type == OB_MESH) {
       Mesh *me = target->data;
       dverts = me->dvert;
-      if (dverts)
+      if (dverts) {
         target_totvert = me->totvert;
+      }
     }
     else if (target->type == OB_LATTICE) {
       Lattice *lt = target->data;
       dverts = lt->dvert;
-      if (dverts)
+      if (dverts) {
         target_totvert = lt->pntsu * lt->pntsv * lt->pntsw;
+      }
     }
     else if (target->type == OB_GPENCIL) {
       dverts = gps->dvert;
-      if (dverts)
+      if (dverts) {
         target_totvert = gps->totpoints;
+      }
     }
   }
 
@@ -1334,19 +1369,23 @@ void armature_deform_verts(Object *armOb,
         BLI_assert(i < mesh->totvert);
         dvert = mesh->dvert + i;
       }
-      else if (dverts && i < target_totvert)
+      else if (dverts && i < target_totvert) {
         dvert = dverts + i;
-      else
+      }
+      else {
         dvert = NULL;
+      }
     }
-    else
+    else {
       dvert = NULL;
+    }
 
     if (armature_def_nr != -1 && dvert) {
       armature_weight = defvert_find_weight(dvert, armature_def_nr);
 
-      if (invert_vgroup)
+      if (invert_vgroup) {
         armature_weight = 1.0f - armature_weight;
+      }
 
       /* hackish: the blending factor can be used for blending with prevCos too */
       if (prevCos) {
@@ -1356,8 +1395,9 @@ void armature_deform_verts(Object *armOb,
     }
 
     /* check if there's any  point in calculating for this vert */
-    if (armature_weight == 0.0f)
+    if (armature_weight == 0.0f) {
       continue;
+    }
 
     /* get the coord we work on */
     co = prevCos ? prevCos[i] : vertexCos[i];
@@ -1403,15 +1443,17 @@ void armature_deform_verts(Object *armOb,
        * (like for softbody groups) */
       if (deformed == 0 && use_envelope) {
         for (pchan = armOb->pose->chanbase.first; pchan; pchan = pchan->next) {
-          if (!(pchan->bone->flag & BONE_NO_DEFORM))
+          if (!(pchan->bone->flag & BONE_NO_DEFORM)) {
             contrib += dist_bone_deform(pchan, vec, dq, smat, co);
+          }
         }
       }
     }
     else if (use_envelope) {
       for (pchan = armOb->pose->chanbase.first; pchan; pchan = pchan->next) {
-        if (!(pchan->bone->flag & BONE_NO_DEFORM))
+        if (!(pchan->bone->flag & BONE_NO_DEFORM)) {
           contrib += dist_bone_deform(pchan, vec, dq, smat, co);
+        }
       }
     }
 
@@ -1427,8 +1469,9 @@ void armature_deform_verts(Object *armOb,
           mul_v3_fl(dco, armature_weight);
           add_v3_v3(co, dco);
         }
-        else
+        else {
           mul_v3m3_dq(co, (defMats) ? summat : NULL, dq);
+        }
 
         smat = summat;
       }
@@ -1444,8 +1487,9 @@ void armature_deform_verts(Object *armOb,
         copy_m3_m4(post, postmat);
         copy_m3_m3(tmpmat, defMats[i]);
 
-        if (!use_quaternion) /* quaternion already is scale corrected */
+        if (!use_quaternion) /* quaternion already is scale corrected */
           mul_m3_fl(smat, armature_weight / contrib);
+        }
 
         mul_m3_series(defMats[i], post, smat, pre, tmpmat);
       }
@@ -1463,8 +1507,9 @@ void armature_deform_verts(Object *armOb,
     }
   }
 
-  if (defnrToPC)
+  if (defnrToPC) {
     MEM_freeN(defnrToPC);
+  }
 }
 
 /* ************ END Armature Deform ******************* */
@@ -1485,8 +1530,9 @@ void BKE_armature_mat_world_to_pose(Object *ob, float inmat[4][4], float outmat[
   float obmat[4][4];
 
   /* prevent crashes */
-  if (ob == NULL)
+  if (ob == NULL) {
     return;
+  }
 
   /* get inverse of (armature) object's matrix  */
   invert_m4_m4(obmat, ob->obmat);
@@ -1607,8 +1653,9 @@ void BKE_bone_parent_transform_calc_from_matrices(int bone_flag,
       normalize_m4(tmat);
       mul_m4_m4m4(r_bpt->rotscale_mat, tmat, offs_bone);
     }
-    else
+    else {
       mul_m4_m4m4(r_bpt->rotscale_mat, parent_pose_mat, offs_bone);
+    }
 
     /* Compose the loc matrix for this bone. */
     /* NOTE: That version does not modify bone's loc when HINGE/NO_SCALE options are set. */
@@ -1635,8 +1682,9 @@ void BKE_bone_parent_transform_calc_from_matrices(int bone_flag,
       mul_m4_m4m4(r_bpt->loc_mat, parent_pose_mat, offs_bone);
     }
     /* Else (i.e. default, usual case), just use the same matrix for rotation/scaling, and location. */
-    else
+    else {
       copy_m4_m4(r_bpt->loc_mat, r_bpt->rotscale_mat);
+    }
   }
   /* Root bones. */
   else {
@@ -1648,8 +1696,9 @@ void BKE_bone_parent_transform_calc_from_matrices(int bone_flag,
       unit_m4(r_bpt->loc_mat);
       copy_v3_v3(r_bpt->loc_mat[3], offs_bone[3]);
     }
-    else
+    else {
       copy_m4_m4(r_bpt->loc_mat, r_bpt->rotscale_mat);
+    }
   }
 }
 
@@ -1759,10 +1808,12 @@ void BKE_pchan_mat3_to_rot(bPoseChannel *pchan, float mat[3][3], bool use_compat
       mat3_normalized_to_axis_angle(pchan->rotAxis, &pchan->rotAngle, mat);
       break;
     default: /* euler */
-      if (use_compat)
+      if (use_compat) {
         mat3_normalized_to_compatible_eulO(pchan->eul, pchan->eul, pchan->rotmode, mat);
-      else
+      }
+      else {
         mat3_normalized_to_eulO(pchan->eul, pchan->rotmode, mat);
+      }
       break;
   }
 }
@@ -2066,8 +2117,9 @@ static void pose_proxy_synchronize(Object *ob, Object *from, int layer_protected
   bConstraint *con;
   int error = 0;
 
-  if (frompose == NULL)
+  if (frompose == NULL) {
     return;
+  }
 
   /* in some cases when rigs change, we cant synchronize
    * to avoid crashing check for possible errors here */
@@ -2083,8 +2135,9 @@ static void pose_proxy_synchronize(Object *ob, Object *from, int layer_protected
     }
   }
 
-  if (error)
+  if (error) {
     return;
+  }
 
   /* clear all transformation values from library */
   BKE_pose_rest(frompose);
@@ -2155,12 +2208,14 @@ static void pose_proxy_synchronize(Object *ob, Object *from, int layer_protected
           cti->get_constraint_targets(con, &targets);
 
           for (ct = targets.first; ct; ct = ct->next) {
-            if (ct->tar == from)
+            if (ct->tar == from) {
               ct->tar = ob;
+            }
           }
 
-          if (cti->flush_constraint_targets)
+          if (cti->flush_constraint_targets) {
             cti->flush_constraint_targets(con, &targets, 0);
+          }
         }
       }
 
@@ -2179,8 +2234,9 @@ static void pose_proxy_synchronize(Object *ob, Object *from, int layer_protected
       if (pchan->custom) {
         id_us_plus(&pchan->custom->id);
       }
-      if (pchanp->custom_tx)
+      if (pchanp->custom_tx) {
         pchan->custom_tx = BKE_pose_channel_find_name(pose, pchanp->custom_tx->name);
+      }
 
       /* ID-Property Syncing */
       {
@@ -2216,8 +2272,9 @@ static int rebuild_pose_bone(bPose *pose, Bone *bone, bPoseChannel *parchan, int
   for (bone = bone->childbase.first; bone; bone = bone->next) {
     counter = rebuild_pose_bone(pose, bone, pchan, counter);
     /* for quick detecting of next bone in chain, only b-bone uses it now */
-    if (bone->flag & BONE_CONNECTED)
+    if (bone->flag & BONE_CONNECTED) {
       pchan->child = BKE_pose_channel_find_name(pose, bone->name);
+    }
   }
 
   return counter;
@@ -2403,10 +2460,12 @@ void BKE_pose_where_is_bone(struct Depsgraph *depsgraph,
                             bool do_extra)
 {
   /* This gives a chan_mat with actions (ipos) results. */
-  if (do_extra)
+  if (do_extra) {
     BKE_pchan_calc_mat(pchan);
-  else
+  }
+  else {
     unit_m4(pchan->chan_mat);
+  }
 
   /* Construct the posemat based on PoseChannels, that we do before applying constraints. */
   /* pose_mat(b) = pose_mat(b-1) * yoffs(b-1) * d_root(b) * bone_mat(b) * chan_mat(b) */
@@ -2415,8 +2474,9 @@ void BKE_pose_where_is_bone(struct Depsgraph *depsgraph,
   /* Only rootbones get the cyclic offset (unless user doesn't want that). */
   /* XXX That could be a problem for snapping and other "reverse transform" features... */
   if (!pchan->parent) {
-    if ((pchan->bone->flag & BONE_NO_CYCLICOFFSET) == 0)
+    if ((pchan->bone->flag & BONE_NO_CYCLICOFFSET) == 0) {
       add_v3_v3(pchan->pose_mat[3], ob->pose->cyclic_offset);
+    }
   }
 
   if (do_extra) {
@@ -2465,12 +2525,14 @@ void BKE_pose_where_is(struct Depsgraph *depsgraph, Scene *scene, Object *ob)
   float imat[4][4];
   float ctime;
 
-  if (ob->type != OB_ARMATURE)
+  if (ob->type != OB_ARMATURE) {
     return;
+  }
   arm = ob->data;
 
-  if (ELEM(NULL, arm, scene))
+  if (ELEM(NULL, arm, scene)) {
     return;
+  }
   if ((ob->pose == NULL) || (ob->pose->flag & POSE_RECALC)) {
     /* WARNING! passing NULL bmain here means we won't tag depsgraph's as dirty - hopefully this is OK. */
     BKE_pose_rebuild(NULL, ob, arm, true);
index 0f1ebc7..5af818b 100644 (file)
@@ -88,18 +88,21 @@ static void splineik_init_tree_from_pchan(Scene *UNUSED(scene),
       ikData = con->data;
 
       /* target can only be curve */
-      if ((ikData->tar == NULL) || (ikData->tar->type != OB_CURVE))
+      if ((ikData->tar == NULL) || (ikData->tar->type != OB_CURVE)) {
         continue;
+      }
       /* skip if disabled */
-      if ((con->enforce == 0.0f) || (con->flag & (CONSTRAINT_DISABLE | CONSTRAINT_OFF)))
+      if ((con->enforce == 0.0f) || (con->flag & (CONSTRAINT_DISABLE | CONSTRAINT_OFF))) {
         continue;
+      }
 
       /* otherwise, constraint is ok... */
       break;
     }
   }
-  if (con == NULL)
+  if (con == NULL) {
     return;
+  }
 
   /* find the root bone and the chain of bones from the root to the tip
    * NOTE: this assumes that the bones are connected, but that may not be true... */
@@ -113,10 +116,12 @@ static void splineik_init_tree_from_pchan(Scene *UNUSED(scene),
     totLength += boneLengths[segcount];
   }
 
-  if (segcount == 0)
+  if (segcount == 0) {
     return;
-  else
+  }
+  else {
     pchanRoot = pchanChain[segcount - 1];
+  }
 
   /* perform binding step if required */
   if ((ikData->flag & CONSTRAINT_SPLINEIK_BOUND) == 0) {
@@ -124,8 +129,9 @@ static void splineik_init_tree_from_pchan(Scene *UNUSED(scene),
     int i;
 
     /* setup new empty array for the points list */
-    if (ikData->points)
+    if (ikData->points) {
       MEM_freeN(ikData->points);
+    }
     ikData->numpoints = ikData->chainlen + 1;
     ikData->points = MEM_mallocN(sizeof(float) * ikData->numpoints, "Spline IK Binding");
 
@@ -195,8 +201,9 @@ static void splineik_init_tree(Scene *scene, Object *ob, float UNUSED(ctime))
 
   /* find the tips of Spline IK chains, which are simply the bones which have been tagged as such */
   for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
-    if (pchan->constflag & PCHAN_HAS_SPLINEIK)
+    if (pchan->constflag & PCHAN_HAS_SPLINEIK) {
       splineik_init_tree_from_pchan(scene, ob, pchan);
+    }
   }
 }
 
@@ -293,8 +300,9 @@ static void splineik_evaluate_bone(
       /* apply curve's object-mode transforms to the position
        * unless the option to allow curve to be positioned elsewhere is activated (i.e. no root)
        */
-      if ((ikData->flag & CONSTRAINT_SPLINEIK_NO_ROOT) == 0)
+      if ((ikData->flag & CONSTRAINT_SPLINEIK_NO_ROOT) == 0) {
         mul_m4_v3(ikData->tar->obmat, vec);
+      }
 
       /* convert the position to pose-space, then store it */
       mul_m4_v3(ob->imat, vec);
@@ -309,8 +317,9 @@ static void splineik_evaluate_bone(
       /* apply curve's object-mode transforms to the position
        * unless the option to allow curve to be positioned elsewhere is activated (i.e. no root)
        */
-      if ((ikData->flag & CONSTRAINT_SPLINEIK_NO_ROOT) == 0)
+      if ((ikData->flag & CONSTRAINT_SPLINEIK_NO_ROOT) == 0) {
         mul_m4_v3(ikData->tar->obmat, vec);
+      }
 
       /* store the position, and convert it to pose space */
       mul_m4_v3(ob->imat, vec);
@@ -412,8 +421,9 @@ static void splineik_evaluate_bone(
           /* NOTE: these should be fine for now, but should get sanitised in future */
           CLAMP(scale, 0.0001f, 100000.0f);
         }
-        else
+        else {
           scale = 1.0f;
+        }
 
         /* apply the scaling */
         mul_v3_fl(poseMat[0], scale);
@@ -549,8 +559,9 @@ static void splineik_execute_tree(
     }
 
     /* free the tree info specific to SplineIK trees now */
-    if (tree->chain)
+    if (tree->chain) {
       MEM_freeN(tree->chain);
+    }
 
     /* free this tree */
     BLI_freelinkN(&pchan_root->siktree, tree);
index cf32abb..789d7a6 100644 (file)
@@ -156,8 +156,9 @@ static void keymap_item_free(wmKeyMapItem *kmi)
     IDP_FreeProperty(kmi->properties);
     MEM_freeN(kmi->properties);
   }
-  if (kmi->ptr)
+  if (kmi->ptr) {
     MEM_freeN(kmi->ptr);
+  }
 }
 
 void BKE_blender_userdef_data_swap(UserDef *userdef_a, UserDef *userdef_b)
index 98e7eea..383d8e6 100644 (file)
@@ -278,8 +278,9 @@ static void setup_app_data(bContext *C,
     wmWindow *win = CTX_wm_window(C);
 
     /* in case we don't even have a local scene, add one */
-    if (!bmain->scenes.first)
+    if (!bmain->scenes.first) {
       BKE_scene_add(bmain, "Empty");
+    }
 
     CTX_data_scene_set(C, bmain->scenes.first);
     win->scene = CTX_data_scene(C);
@@ -304,8 +305,9 @@ static void setup_app_data(bContext *C,
 
   /* FIXME: this version patching should really be part of the file-reading code,
    * but we still get too many unrelated data-corruption crashes otherwise... */
-  if (bmain->versionfile < 250)
+  if (bmain->versionfile < 250) {
     do_versions_ipos_to_animato(bmain);
+  }
 
   bmain->recovered = 0;
 
@@ -320,8 +322,9 @@ static void setup_app_data(bContext *C,
     bmain->recovered = 1;
 
     /* these are the same at times, should never copy to the same location */
-    if (bmain->name != filepath)
+    if (bmain->name != filepath) {
       BLI_strncpy(bmain->name, filepath, FILE_MAX);
+    }
   }
 
   /* baseflags, groups, make depsgraph, etc */
@@ -399,8 +402,9 @@ int BKE_blendfile_read(bContext *C,
       setup_app_data(C, bfd, filepath, params->is_startup, reports);
     }
   }
-  else
+  else {
     BKE_reports_prependf(reports, "Loading '%s' failed: ", filepath);
+  }
 
   return (bfd ? retval : BKE_BLENDFILE_READ_FAIL);
 }
@@ -416,8 +420,9 @@ bool BKE_blendfile_read_from_memory(bContext *C,
 
   bfd = BLO_read_from_memory(filebuf, filelength, params->skip_flags, reports);
   if (bfd) {
-    if (update_defaults)
+    if (update_defaults) {
       BLO_update_defaults_startup_blend(bfd->main, NULL);
+    }
     setup_app_data(C, bfd, "<memory2>", params->is_startup, reports);
   }
   else {
@@ -440,10 +445,12 @@ bool BKE_blendfile_read_from_memfile(bContext *C,
       bmain, BKE_main_blendfile_path(bmain), memfile, params->skip_flags, reports);
   if (bfd) {
     /* remove the unused screens and wm */
-    while (bfd->main->wm.first)
+    while (bfd->main->wm.first) {
       BKE_id_free(bfd->main, bfd->main->wm.first);
-    while (bfd->main->screens.first)
+    }
+    while (bfd->main->screens.first) {
       BKE_id_free(bfd->main, bfd->main->screens.first);
+    }
 
     setup_app_data(C, bfd, "<memory1>", params->is_startup, reports);
   }
@@ -636,11 +643,13 @@ static void blendfile_write_partial_cb(void *UNUSED(handle), Main *UNUSED(bmain)
   if (vid) {
     ID *id = vid;
     /* only tag for need-expand if not done, prevents eternal loops */
-    if ((id->tag & LIB_TAG_DOIT) == 0)
+    if ((id->tag & LIB_TAG_DOIT) == 0) {
       id->tag |= LIB_TAG_NEED_EXPAND | LIB_TAG_DOIT;
+    }
 
-    if (id->lib && (id->lib->id.tag & LIB_TAG_DOIT) == 0)
+    if (id->lib && (id->lib->id.tag & LIB_TAG_DOIT) == 0) {
       id->lib->id.tag |= LIB_TAG_DOIT;
+    }
   }
 }
 
index b31a283..fc3e12a 100644 (file)
@@ -99,7 +99,7 @@ static int rule_goal_avoid(BoidRule *rule, BoidBrainData *bbd, BoidValues *val,
   pd_point_from_particle(bbd->sim, pa, &pa->state, &epoint);
 
   /* first find out goal/predator with highest priority */
-  if (effectors)
+  if (effectors) {
     for (cur = effectors->first; cur; cur = cur->next) {
       Object *eob = cur->ob;
       PartDeflect *pd = cur->pd;
@@ -108,11 +108,13 @@ static int rule_goal_avoid(BoidRule *rule, BoidBrainData *bbd, BoidValues *val,
         if (gabr->ob == eob) {
           /* TODO: effectors with multiple points */
           if (get_effector_data(cur, &efd, &epoint, 0)) {
-            if (cur->pd && cur->pd->forcefield == PFIELD_BOID)
+            if (cur->pd && cur->pd->forcefield == PFIELD_BOID) {
               priority = mul * pd->f_strength *
                          effector_falloff(cur, &efd, &epoint, bbd->part->effector_weights);
-            else
+            }
+            else {
               priority = 1.0;
+            }
 
             eff = cur;
           }
@@ -144,6 +146,7 @@ static int rule_goal_avoid(BoidRule *rule, BoidBrainData *bbd, BoidValues *val,
         }
       }
     }
+  }
 
   /* if the object doesn't have effector data we have to fake it */
   if (eff == NULL && gabr->ob) {
@@ -246,8 +249,9 @@ static int rule_avoid_collision(BoidRule *rule,
     /* find out closest deflector object */
     for (coll = bbd->sim->colliders->first; coll; coll = coll->next) {
       /* don't check with current ground object */
-      if (coll->ob == bpa->ground)
+      if (coll->ob == bpa->ground) {
         continue;
+      }
 
       col.current = coll->ob;
       col.md = coll->collmd;
@@ -297,7 +301,7 @@ static int rule_avoid_collision(BoidRule *rule,
                                                                    len_v3(pa->prev_state.vel),
                                                                len_squared_v3v3_with_normal_bias,
                                                                pa->prev_state.ave);
-    if (neighbors > 1)
+    if (neighbors > 1) {
       for (n = 1; n < neighbors; n++) {
         copy_v3_v3(co1, pa->prev_state.co);
         copy_v3_v3(vel1, pa->prev_state.vel);
@@ -335,6 +339,7 @@ static int rule_avoid_collision(BoidRule *rule,
           }
         }
       }
+    }
   }
   if (ptn) {
     MEM_freeN(ptn);
@@ -355,7 +360,7 @@ static int rule_avoid_collision(BoidRule *rule,
                                                                  len_squared_v3v3_with_normal_bias,
                                                                  pa->prev_state.ave);
 
-      if (neighbors > 0)
+      if (neighbors > 0) {
         for (n = 0; n < neighbors; n++) {
           copy_v3_v3(co1, pa->prev_state.co);
           copy_v3_v3(vel1, pa->prev_state.vel);
@@ -393,6 +398,7 @@ static int rule_avoid_collision(BoidRule *rule,
             }
           }
         }
+      }
 
       if (ptn) {
         MEM_freeN(ptn);
@@ -401,8 +407,9 @@ static int rule_avoid_collision(BoidRule *rule,
     }
   }
 
-  if (ptn && nearest == 0)
+  if (ptn && nearest == 0) {
     MEM_freeN(ptn);
+  }
 
   return ret;
 }
@@ -608,8 +615,9 @@ static int rule_follow_leader(BoidRule *rule,
       }
     }
 
-    if (ret)
+    if (ret) {
       return 1;
+    }
 
     /* not blocking so try to follow leader */
     if (flbr->options & BRULE_LEADER_IN_LINE) {
@@ -737,10 +745,12 @@ static int rule_fight(BoidRule *rule, BoidBrainData *bbd, BoidValues *val, Parti
           enemy_pa = epars + ptn[n].index;
         }
       }
-      if (pt->mode == PTARGET_MODE_ENEMY)
+      if (pt->mode == PTARGET_MODE_ENEMY) {
         e_strength += epsys->part->boids->strength * health;
-      else if (pt->mode == PTARGET_MODE_FRIEND)
+      }
+      else if (pt->mode == PTARGET_MODE_FRIEND) {
         f_strength += epsys->part->boids->strength * health;
+      }
 
       if (ptn) {
         MEM_freeN(ptn);
@@ -869,8 +879,9 @@ static Object *boid_find_ground(BoidBrainData *bbd,
     BVHTreeRayHit hit;
     float radius = 0.0f, t, ray_dir[3];
 
-    if (!bbd->sim->colliders)
+    if (!bbd->sim->colliders) {
       return NULL;
+    }
 
     memset(&col, 0, sizeof(ParticleCollision));
 
@@ -951,14 +962,18 @@ static int boid_rule_applies(ParticleData *pa, BoidSettings *UNUSED(boids), Boid
 {
   BoidParticle *bpa = pa->boid;
 
-  if (rule == NULL)
+  if (rule == NULL) {
     return 0;
+  }
 
-  if (ELEM(bpa->data.mode, eBoidMode_OnLand, eBoidMode_Climbing) && rule->flag & BOIDRULE_ON_LAND)
+  if (ELEM(bpa->data.mode, eBoidMode_OnLand, eBoidMode_Climbing) &&
+      rule->flag & BOIDRULE_ON_LAND) {
     return 1;
+  }
 
-  if (bpa->data.mode == eBoidMode_InAir && rule->flag & BOIDRULE_IN_AIR)
+  if (bpa->data.mode == eBoidMode_InAir && rule->flag & BOIDRULE_IN_AIR) {
     return 1;
+  }
 
   return 0;
 }
@@ -1014,21 +1029,26 @@ static float boid_goal_signed_dist(float *boid_co, float *goal_co, float *goal_n
 static int apply_boid_rule(
     BoidBrainData *bbd, BoidRule *rule, BoidValues *val, ParticleData *pa, float fuzziness)
 {
-  if (rule == NULL)
+  if (rule == NULL) {
     return 0;
+  }
 
-  if (boid_rule_applies(pa, bbd->part->boids, rule) == 0)
+  if (boid_rule_applies(pa, bbd->part->boids, rule) == 0) {
     return 0;
+  }
 
-  if (boid_rules[rule->type](rule, bbd, val, pa) == 0)
+  if (boid_rules[rule->type](rule, bbd, val, pa) == 0) {
     return 0;
+  }
 
   if (fuzziness < 0.0f || compare_len_v3v3(bbd->wanted_co,
                                            pa->prev_state.vel,
-                                           fuzziness * len_v3(pa->prev_state.vel)) == 0)
+                                           fuzziness * len_v3(pa->prev_state.vel)) == 0) {
     return 1;
-  else
+  }
+  else {
     return 0;
+  }
 }
 static BoidState *get_boid_state(BoidSettings *boids, ParticleData *pa)
 {
@@ -1036,14 +1056,16 @@ static BoidState *get_boid_state(BoidSettings *boids, ParticleData *pa)
   BoidParticle *bpa = pa->boid;
 
   for (; state; state = state->next) {
-    if (state->id == bpa->data.state_id)
+    if (state->id == bpa->data.state_id) {
       return state;
+    }
   }
 
   /* for some reason particle isn't at a valid state */
   state = boids->states.first;
-  if (state)
+  if (state) {
     bpa->data.state_id = state->id;
+  }
 
   return state;
 }
@@ -1094,8 +1116,9 @@ void boid_brain(BoidBrainData *bbd, int p, ParticleData *pa)
   switch (state->ruleset_type) {
     case eBoidRulesetType_Fuzzy: {
       for (rule = state->rules.first; rule; rule = rule->next) {
-        if (apply_boid_rule(bbd, rule, &val, pa, state->rule_fuzziness))
+        if (apply_boid_rule(bbd, rule, &val, pa, state->rule_fuzziness)) {
           break; /* only first nonzero rule that comes through fuzzy rule is applied */
+        }
       }
       break;
     }
@@ -1146,8 +1169,9 @@ void boid_brain(BoidBrainData *bbd, int p, ParticleData *pa)
       copy_v3_v3(cvel, bbd->wanted_co);
       normalize_v2(cvel);
 
-      if (dot_v2v2(cvel, dir) > 0.95f / mul)
+      if (dot_v2v2(cvel, dir) > 0.95f / mul) {
         bpa->data.mode = eBoidMode_Liftoff;
+      }
     }
     else if (val.jump_speed > 0.0f) {
       float jump_v[3];
@@ -1229,14 +1253,16 @@ void boid_body(BoidBrainData *bbd, ParticleData *pa)
   /* make sure there's something in new velocity, location & rotation */
   copy_particle_key(&pa->state, &pa->prev_state, 0);
 
-  if (bbd->part->flag & PART_SIZEMASS)
+  if (bbd->part->flag & PART_SIZEMASS) {
     pa_mass *= pa->size;
+  }
 
   /* if boids can't fly they fall to the ground */
   if ((boids->options & BOID_ALLOW_FLIGHT) == 0 &&
       ELEM(bpa->data.mode, eBoidMode_OnLand, eBoidMode_Climbing) == 0 &&
-      psys_uses_gravity(bbd->sim))
+      psys_uses_gravity(bbd->sim)) {
     bpa->data.mode = eBoidMode_Falling;
+  }
 
   if (bpa->data.mode == eBoidMode_Falling) {
     /* Falling boids are only effected by gravity. */
@@ -1318,10 +1344,12 @@ void boid_body(BoidBrainData *bbd, ParticleData *pa)
     /* constrain speed with maximum acceleration */
     old_speed = len_v3(pa->prev_state.vel);
 
-    if (bbd->wanted_speed < old_speed)
+    if (bbd->wanted_speed < old_speed) {
       new_speed = MAX2(bbd->wanted_speed, old_speed - val.max_acc);
-    else
+    }
+    else {
       new_speed = MIN2(bbd->wanted_speed, old_speed + val.max_acc);
+    }
 
     /* combine direction and speed */
     copy_v3_v3(new_vel, new_dir);
@@ -1467,11 +1495,13 @@ void boid_body(BoidBrainData *bbd, ParticleData *pa)
           bpa->data.mode = eBoidMode_OnLand;
         }
         /* if we're falling, can fly and want to go upwards lets fly */
-        else if (boids->options & BOID_ALLOW_FLIGHT && bbd->wanted_co[2] > 0.0f)
+        else if (boids->options & BOID_ALLOW_FLIGHT && bbd->wanted_co[2] > 0.0f) {
           bpa->data.mode = eBoidMode_InAir;
+        }
       }
-      else
+      else {
         bpa->data.mode = eBoidMode_InAir;
+      }
       break;
     }
     case eBoidMode_Climbing: {
@@ -1502,8 +1532,9 @@ void boid_body(BoidBrainData *bbd, ParticleData *pa)
         boid_climb(boids, pa, ground_co, ground_nor);
       }
       /* ground is too far away so boid falls */
-      else if (pa->state.co[2] - ground_co[2] > 1.1f * pa->size * boids->height)
+      else if (pa->state.co[2] - ground_co[2] > 1.1f * pa->size * boids->height) {
         bpa->data.mode = eBoidMode_Falling;
+      }
       else {
         /* constrain to surface */
         pa->state.co[2] = ground_co[2] + pa->size * boids->height;
@@ -1541,8 +1572,9 @@ void boid_body(BoidBrainData *bbd, ParticleData *pa)
   }
 
   /* apply damping */
-  if (ELEM(bpa->data.mode, eBoidMode_OnLand, eBoidMode_Climbing))
+  if (ELEM(bpa->data.mode, eBoidMode_OnLand, eBoidMode_Climbing)) {
     mul_v3_fl(pa->state.vel, 1.0f - 0.2f * bbd->part->dampfac);
+  }
 
   /* calculate rotation matrix based on forward & down vectors */
   if (bpa->data.mode == eBoidMode_InAir) {
@@ -1570,8 +1602,9 @@ void boid_body(BoidBrainData *bbd, ParticleData *pa)
 BoidRule *boid_new_rule(int type)
 {
   BoidRule *rule = NULL;
-  if (type <= 0)
+  if (type <= 0) {
     return NULL;
+  }
 
   switch (type) {
     case eBoidRuleType_Goal:
@@ -1637,10 +1670,12 @@ BoidState *boid_new_state(BoidSettings *boids)
   BoidState *state = MEM_callocN(sizeof(BoidState), "BoidState");
 
   state->id = boids->last_state_id++;
-  if (state->id)
+  if (state->id) {
     BLI_snprintf(state->name, sizeof(state->name), "State %i", state->id);
-  else
+  }
+  else {
     strcpy(state->name, "State");
+  }
 
   state->rule_fuzziness = 0.5;
   state->volume = 1.0f;
@@ -1705,8 +1740,9 @@ BoidState *boid_get_current_state(BoidSettings *boids)
   BoidState *state = boids->states.first;
 
   for (; state; state = state->next) {
-    if (state->flag & BOIDSTATE_CURRENT)
+    if (state->flag & BOIDSTATE_CURRENT) {
       break;
+    }
   }
 
   return state;
index 25f886b..6f0c189 100644 (file)
@@ -233,21 +233,25 @@ static bool missing_files_find__recursive(char *filename_new,
 
   dir = opendir(dirname);
 
-  if (dir == NULL)
+  if (dir == NULL) {
     return found;
+  }
 
-  if (*r_filesize == -1)
+  if (*r_filesize == -1) {
     *r_filesize = 0; /* dir opened fine */
+  }
 
   while ((de = readdir(dir)) != NULL) {
 
-    if (FILENAME_IS_CURRPAR(de->d_name))
+    if (FILENAME_IS_CURRPAR(de->d_name)) {
       continue;
+    }
 
     BLI_join_dirfile(path, sizeof(path), dirname, de->d_name);
 
-    if (BLI_stat(path, &status) == -1)
+    if (BLI_stat(path, &status) == -1) {
       continue; /* cant stat, don't bother with this file, could print debug info here */
+    }
 
     if (S_ISREG(status.st_mode)) {                              /* is file */
       if (BLI_path_ncmp(filename, de->d_name, FILE_MAX) == 0) { /* name matches */
@@ -321,8 +325,9 @@ static bool missing_files_find__visit_cb(void *userdata, char *path_dst, const c
     BLI_strncpy(path_dst, filename_new, FILE_MAX);
 
     /* keep path relative if the previous one was relative */
-    if (was_relative)
+    if (was_relative) {
       BLI_path_rel(path_dst, data->basedir);
+    }
 
     return true;
   }
index 56a6de6..4ee3abc 100644 (file)
@@ -212,8 +212,9 @@ typedef enum eGPCurveMappingPreset {
 
 static void brush_gpencil_curvemap_reset(CurveMap *cuma, int tot, int preset)
 {
-  if (cuma->curve)
+  if (cuma->curve) {
     MEM_freeN(cuma->curve);
+  }
 
   cuma->totpoint = tot;
   cuma->curve = MEM_callocN(cuma->totpoint * sizeof(CurveMapPoint), __func__);
@@ -572,8 +573,9 @@ struct Brush *BKE_brush_first_search(struct Main *bmain, const eObjectMode ob_mo
   Brush *brush;
 
   for (brush = bmain->brushes.first; brush; brush = brush->id.next) {
-    if (brush->ob_mode & ob_mode)
+    if (brush->ob_mode & ob_mode) {
       return brush;
+    }
   }
   return NULL;
 }
@@ -869,8 +871,9 @@ void BKE_brush_curve_preset(Brush *b, eCurveMappingPreset preset)
 {
   CurveMap *cm = NULL;
 
-  if (!b->curve)
+  if (!b->curve) {
     b->curve = curvemapping_add(1, 0, 0, 1, 1);
+  }
 
   cm = b->curve->cm;
   cm->flag &= ~CUMA_EXTEND_EXTRAPOLATE;
@@ -1156,10 +1159,12 @@ void BKE_brush_color_set(struct Scene *scene, struct Brush *brush, const float c
 {
   UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
 
-  if (ups->flag & UNIFIED_PAINT_COLOR)
+  if (ups->flag & UNIFIED_PAINT_COLOR) {
     copy_v3_v3(ups->rgb, color);
-  else
+  }
+  else {
     copy_v3_v3(brush->rgb, color);
+  }
 }
 
 void BKE_brush_size_set(Scene *scene, Brush *brush, int size)
@@ -1169,10 +1174,12 @@ void BKE_brush_size_set(Scene *scene, Brush *brush, int size)
   /* make sure range is sane */
   CLAMP(size, 1, MAX_BRUSH_PIXEL_RADIUS);
 
-  if (ups->flag & UNIFIED_PAINT_SIZE)
+  if (ups->flag & UNIFIED_PAINT_SIZE) {
     ups->size = size;
-  else
+  }
+  else {
     brush->size = size;
+  }
 }
 
 int BKE_brush_size_get(const Scene *scene, const Brush *brush)
@@ -1228,10 +1235,12 @@ void BKE_brush_unprojected_radius_set(Scene *scene, Brush *brush, float unprojec
 {
   UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
 
-  if (ups->flag & UNIFIED_PAINT_SIZE)
+  if (ups->flag & UNIFIED_PAINT_SIZE) {
     ups->unprojected_radius = unprojected_radius;
-  else
+  }
+  else {
     brush->unprojected_radius = unprojected_radius;
+  }
 }
 
 float BKE_brush_unprojected_radius_get(const Scene *scene, const Brush *brush)
@@ -1245,10 +1254,12 @@ void BKE_brush_alpha_set(Scene *scene, Brush *brush, float alpha)
 {
   UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
 
-  if (ups->flag & UNIFIED_PAINT_ALPHA)
+  if (ups->flag & UNIFIED_PAINT_ALPHA) {
     ups->alpha = alpha;
-  else
+  }
+  else {
     brush->alpha = alpha;
+  }
 }
 
 float BKE_brush_alpha_get(const Scene *scene, const Brush *brush)
@@ -1269,10 +1280,12 @@ void BKE_brush_weight_set(const Scene *scene, Brush *brush, float value)
 {
   UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
 
-  if (ups->flag & UNIFIED_PAINT_WEIGHT)
+  if (ups->flag & UNIFIED_PAINT_WEIGHT) {
     ups->weight = value;
-  else
+  }
+  else {
     brush->weight = value;
+  }
 }
 
 /* scale unprojected radius to reflect a change in the brush's 2D size */
@@ -1282,8 +1295,9 @@ void BKE_brush_scale_unprojected_radius(float *unprojected_radius,
 {
   float scale = new_brush_size;
   /* avoid division by zero */
-  if (old_brush_size != 0)
+  if (old_brush_size != 0) {
     scale /= (float)old_brush_size;
+  }
   (*unprojected_radius) *= scale;
 }
 
@@ -1294,8 +1308,9 @@ void BKE_brush_scale_size(int *r_brush_size,
 {
   float scale = new_unprojected_radius;
   /* avoid division by zero */
-  if (old_unprojected_radius != 0)
+  if (old_unprojected_radius != 0) {
     scale /= new_unprojected_radius;
+  }
   (*r_brush_size) = (int)((float)(*r_brush_size) * scale);
 }
 
@@ -1342,10 +1357,12 @@ float BKE_brush_curve_strength(const Brush *br, float p, const float len)
 {
   float strength;
 
-  if (p >= len)
+  if (p >= len) {
     return 0;
-  else
+  }
+  else {
     p = p / len;
+  }
 
   strength = curvemapping_evaluateF(br->curve, 0, p);
 
index 1c17408..ab7baf6 100644 (file)
@@ -204,10 +204,12 @@ static void mesh_faces_spherecast(void *userdata,
 
   do {
     float dist;
-    if (ray->radius == 0.0f)
+    if (ray->radius == 0.0f) {
       dist = bvhtree_ray_tri_intersection(ray, hit->dist, t0, t1, t2);
-    else
+    }
+    else {
       dist = bvhtree_sphereray_tri_intersection(ray, ray->radius, hit->dist, t0, t1, t2);
+    }
 
     if (dist >= 0 && dist < hit->dist) {
       hit->index = index;
@@ -239,10 +241,12 @@ static void mesh_looptri_spherecast(void *userdata,
   };
   float dist;
 
-  if (ray->radius == 0.0f)
+  if (ray->radius == 0.0f) {
     dist = bvhtree_ray_tri_intersection(ray, hit->dist, UNPACK3(vtri_co));
-  else
+  }
+  else {
     dist = bvhtree_sphereray_tri_intersection(ray, ray->radius, hit->dist, UNPACK3(vtri_co));
+  }
 
   if (dist >= 0 && dist < hit->dist) {
     hit->index = index;
@@ -269,10 +273,12 @@ static void editmesh_looptri_spherecast(void *userdata,
 
   {
     float dist;
-    if (ray->radius == 0.0f)
+    if (ray->radius == 0.0f) {
       dist = bvhtree_ray_tri_intersection(ray, hit->dist, t0, t1, t2);
-    else
+    }
+    else {
       dist = bvhtree_sphereray_tri_intersection(ray, ray->radius, hit->dist, t0, t1, t2);
+    }
 
     if (dist >= 0 && dist < hit->dist) {
       hit->index = index;
@@ -816,8 +822,9 @@ static BVHTree *bvhtree_from_mesh_faces_create_tree(float epsilon,
           copy_v3_v3(co[0], vert[face[i].v1].co);
           copy_v3_v3(co[1], vert[face[i].v2].co);
           copy_v3_v3(co[2], vert[face[i].v3].co);
-          if (face[i].v4)
+          if (face[i].v4) {
             copy_v3_v3(co[3], vert[face[i].v4].co);
+          }
 
           BLI_bvhtree_insert(tree, i, co[0], face[i].v4 ? 4 : 3);
         }
index f4d09be..59811cf 100644 (file)
@@ -129,8 +129,9 @@ void BKE_camera_free(Camera *ca)
 float BKE_camera_object_dof_distance(Object *ob)
 {
   Camera *cam = (Camera *)ob->data;
-  if (ob->type != OB_CAMERA)
+  if (ob->type != OB_CAMERA) {
     return 0.0f;
+  }
   if (cam->dof_ob) {
     float view_dir[3], dof_dir[3];
     normalize_v3_v3(view_dir, ob->obmat[2]);
@@ -143,8 +144,9 @@ float BKE_camera_object_dof_distance(Object *ob)
 float BKE_camera_sensor_size(int sensor_fit, float sensor_x, float sensor_y)
 {
   /* sensor size used to fit to. for auto, sensor_x is both x and y. */
-  if (sensor_fit == CAMERA_SENSOR_FIT_VERT)
+  if (sensor_fit == CAMERA_SENSOR_FIT_VERT) {
     return sensor_y;
+  }
 
   return sensor_x;
 }
@@ -152,10 +154,12 @@ float BKE_camera_sensor_size(int sensor_fit, float sensor_x, float sensor_y)
 int BKE_camera_sensor_fit(int sensor_fit, float sizex, float sizey)
 {
   if (sensor_fit == CAMERA_SENSOR_FIT_AUTO) {
-    if (sizex >= sizey)
+    if (sizex >= sizey) {
       return CAMERA_SENSOR_FIT_HOR;
-    else
+    }
+    else {
       return CAMERA_SENSOR_FIT_VERT;
+    }
   }
 
   return sensor_fit;
@@ -181,15 +185,17 @@ void BKE_camera_params_init(CameraParams *params)
 
 void BKE_camera_params_from_object(CameraParams *params, const Object *ob)
 {
-  if (!ob)
+  if (!ob) {
     return;
+  }
 
   if (ob->type == OB_CAMERA) {
     /* camera object */
     Camera *cam = ob->data;
 
-    if (cam->type == CAM_ORTHO)
+    if (cam->type == CAM_ORTHO) {
       params->is_ortho = true;
+    }
     params->lens = cam->lens;
     params->ortho_scale = cam->ortho_scale;
 
@@ -207,8 +213,9 @@ void BKE_camera_params_from_object(CameraParams *params, const Object *ob)
     /* light object */
     Light *la = ob->data;
     params->lens = 16.0f / tanf(la->spotsize * 0.5f);
-    if (params->lens == 0.0f)
+    if (params->lens == 0.0f) {
       params->lens = 35.0f;
+    }
   }
   else {
     params->lens = 35.0f;
@@ -282,10 +289,12 @@ void BKE_camera_params_compute_viewplane(
   /* determine sensor fit */
   sensor_fit = BKE_camera_sensor_fit(params->sensor_fit, xasp * winx, yasp * winy);
 
-  if (sensor_fit == CAMERA_SENSOR_FIT_HOR)
+  if (sensor_fit == CAMERA_SENSOR_FIT_HOR) {
     viewfac = winx;
-  else
+  }
+  else {
     viewfac = params->ycor * winy;
+  }
 
   pixsize /= viewfac;
 
@@ -328,7 +337,7 @@ void BKE_camera_params_compute_matrix(CameraParams *params)
   rctf viewplane = params->viewplane;
 
   /* compute projection matrix */
-  if (params->is_ortho)
+  if (params->is_ortho) {
     orthographic_m4(params->winmat,
                     viewplane.xmin,
                     viewplane.xmax,
@@ -336,7 +345,8 @@ void BKE_camera_params_compute_matrix(CameraParams *params)
                     viewplane.ymax,
                     params->clip_start,
                     params->clip_end);
-  else
+  }
+  else {
     perspective_m4(params->winmat,
                    viewplane.xmin,
                    viewplane.xmax,
@@ -344,6 +354,7 @@ void BKE_camera_params_compute_matrix(CameraParams *params)
                    viewplane.ymax,
                    params->clip_start,
                    params->clip_end);
+  }
 }
 
 /***************************** Camera View Frame *****************************/
@@ -723,8 +734,9 @@ static void camera_stereo3d_model_matrix(const Object *camera,
     size_to_mat4(sizemat, size);
   }
 
-  if (pivot == CAM_S3D_PIVOT_CENTER)
+  if (pivot == CAM_S3D_PIVOT_CENTER) {
     fac = 0.5f;
+  }
 
   fac_signed = is_left ? fac : -fac;
 
@@ -865,13 +877,16 @@ bool BKE_camera_multiview_spherical_stereo(RenderData *rd, const Object *camera)
   Camera *cam;
   const bool is_multiview = (rd && rd->scemode & R_MULTIVIEW) != 0;
 
-  if (!is_multiview)
+  if (!is_multiview) {
     return false;
+  }
 
-  if (camera->type != OB_CAMERA)
+  if (camera->type != OB_CAMERA) {
     return false;
-  else
+  }
+  else {
     cam = camera->data;
+  }
 
   if ((rd->views_format == SCE_VIEWS_FORMAT_STEREO_3D) && ELEM(cam->type, CAM_PANO, CAM_PERSP) &&
       ((cam->stereo.flag & CAM_S3D_SPHERICAL) != 0)) {
@@ -895,8 +910,9 @@ static Object *camera_multiview_advanced(Scene *scene, Object *camera, const cha
   for (srv = scene->r.views.first; srv; srv = srv->next) {
     const int len_suffix = strlen(srv->suffix);
 
-    if ((len_suffix < len_suffix_max) || (len_name < len_suffix))
+    if ((len_suffix < len_suffix_max) || (len_name < len_suffix)) {
       continue;
+    }
 
     if (STREQ(camera_name + (len_name - len_suffix), srv->suffix)) {
       BLI_snprintf(name, sizeof(name), "%.*s%s", (len_name - len_suffix), camera_name, suffix);
@@ -951,15 +967,17 @@ static float camera_stereo3d_shift_x(const Object *camera, const char *viewname)
   convergence_mode = data->stereo.convergence_mode;
   pivot = data->stereo.pivot;
 
-  if (convergence_mode != CAM_S3D_OFFAXIS)
+  if (convergence_mode != CAM_S3D_OFFAXIS) {
     return shift;
+  }
 
   if (((pivot == CAM_S3D_PIVOT_LEFT) && is_left) || ((pivot == CAM_S3D_PIVOT_RIGHT) && !is_left)) {
     return shift;
   }
 
-  if (pivot == CAM_S3D_PIVOT_CENTER)
+  if (pivot == CAM_S3D_PIVOT_CENTER) {
     fac = 0.5f;
+  }
 
   fac_signed = is_left ? fac : -fac;
   shift += ((interocular_distance / data->sensor_x) * (data->lens / convergence_distance)) *
index debdeda..e41f733 100644 (file)
@@ -178,8 +178,9 @@ static void cdDM_getVertCos(DerivedMesh *dm, float (*r_cos)[3])
   MVert *mv = CDDM_get_verts(dm);
   int i;
 
-  for (i = 0; i < dm->numVertData; i++, mv++)
+  for (i = 0; i < dm->numVertData; i++, mv++) {
     copy_v3_v3(r_cos[i], mv->co);
+  }
 }
 
 static void cdDM_getVertNo(DerivedMesh *dm, int index, float r_no[3])
@@ -248,8 +249,9 @@ static PBVH *cdDM_getPBVH(Object *ob, DerivedMesh *dm)
     return NULL;
   }
 
-  if (!ob->sculpt)
+  if (!ob->sculpt) {
     return NULL;
+  }
 
   if (ob->sculpt->pbvh) {
     cddm->pbvh = ob->sculpt->pbvh;
@@ -335,8 +337,9 @@ static void cdDM_foreachMappedVert(DerivedMesh *dm,
     for (i = 0; i < dm->numVertData; i++, mv++) {
       const short *no = (flag & DM_FOREACH_USE_NORMAL) ? mv->no : NULL;
       const int orig = *index++;
-      if (orig == ORIGINDEX_NONE)
+      if (orig == ORIGINDEX_NONE) {
         continue;
+      }
       func(userData, orig, mv->co, NULL, no);
     }
   }
@@ -361,12 +364,14 @@ static void cdDM_foreachMappedEdge(
   for (i = 0; i < dm->numEdgeData; i++, med++) {
     if (index) {
       orig = *index++;
-      if (orig == ORIGINDEX_NONE)
+      if (orig == ORIGINDEX_NONE) {
         continue;
+      }
       func(userData, orig, mv[med->v1].co, mv[med->v2].co);
     }
-    else
+    else {
       func(userData, i, mv[med->v1].co, mv[med->v2].co);
+    }
   }
 }
 
@@ -423,8 +428,9 @@ static void cdDM_foreachMappedFaceCenter(
 
     if (index) {
       orig = *index++;
-      if (orig == ORIGINDEX_NONE)
+      if (orig == ORIGINDEX_NONE) {
         continue;
+      }
     }
     else {
       orig = i;
@@ -489,10 +495,12 @@ void CDDM_recalc_looptri(DerivedMesh *dm)
 
 static void cdDM_free_internal(CDDerivedMesh *cddm)
 {
-  if (cddm->pmap)
+  if (cddm->pmap) {
     MEM_freeN(cddm->pmap);
-  if (cddm->pmap_mem)
+  }
+  if (cddm->pmap_mem) {
     MEM_freeN(cddm->pmap_mem);
+  }
 }
 
 static void cdDM_release(DerivedMesh *dm)
@@ -829,11 +837,13 @@ static DerivedMesh *cddm_from_bmesh_ex(struct BMesh *bm,
 
     mv->flag = BM_vert_flag_to_mflag(eve);
 
-    if (cd_vert_bweight_offset != -1)
+    if (cd_vert_bweight_offset != -1) {
       mv->bweight = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(eve, cd_vert_bweight_offset);
+    }
 
-    if (add_orig)
+    if (add_orig) {
       *index++ = i;
+    }
 
     CustomData_from_bmesh_block(&bm->vdata, &dm->vertData, eve->head.data, i);
   }
@@ -858,14 +868,17 @@ static DerivedMesh *cddm_from_bmesh_ex(struct BMesh *bm,
       }
     }
 
-    if (cd_edge_crease_offset != -1)
+    if (cd_edge_crease_offset != -1) {
       med->crease = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(eed, cd_edge_crease_offset);
-    if (cd_edge_bweight_offset != -1)
+    }
+    if (cd_edge_bweight_offset != -1) {
       med->bweight = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(eed, cd_edge_bweight_offset);
+    }
 
     CustomData_from_bmesh_block(&bm->edata, &dm->edgeData, eed->head.data, i);
-    if (add_orig)
+    if (add_orig) {
       *index++ = i;
+    }
   }
   bm->elem_index_dirty &= ~BM_EDGE;
 
@@ -923,8 +936,9 @@ static DerivedMesh *cddm_from_bmesh_ex(struct BMesh *bm,
 
     CustomData_from_bmesh_block(&bm->pdata, &dm->polyData, efa->head.data, i);
 
-    if (add_orig)
+    if (add_orig) {
       *index++ = i;
+    }
   }
   bm->elem_index_dirty &= ~(BM_FACE | BM_LOOP);
 
@@ -1029,12 +1043,15 @@ DerivedMesh *CDDM_from_template_ex(DerivedMesh *source,
   CustomData_add_layer(&dm->loopData, CD_MLOOP, CD_CALLOC, NULL, numLoops);
   CustomData_add_layer(&dm->polyData, CD_MPOLY, CD_CALLOC, NULL, numPolys);
 
-  if (!CustomData_get_layer(&dm->vertData, CD_ORIGINDEX))
+  if (!CustomData_get_layer(&dm->vertData, CD_ORIGINDEX)) {
     CustomData_add_layer(&dm->vertData, CD_ORIGINDEX, CD_CALLOC, NULL, numVerts);
-  if (!CustomData_get_layer(&dm->edgeData, CD_ORIGINDEX))
+  }
+  if (!CustomData_get_layer(&dm->edgeData, CD_ORIGINDEX)) {
     CustomData_add_layer(&dm->edgeData, CD_ORIGINDEX, CD_CALLOC, NULL, numEdges);
-  if (!CustomData_get_layer(&dm->faceData, CD_ORIGINDEX))
+  }
+  if (!CustomData_get_layer(&dm->faceData, CD_ORIGINDEX)) {
     CustomData_add_layer(&dm->faceData, CD_ORIGINDEX, CD_CALLOC, NULL, numTessFaces);
+  }
 
   cddm->mvert = CustomData_get_layer(&dm->vertData, CD_MVERT);
   cddm->medge = CustomData_get_layer(&dm->edgeData, CD_MEDGE);
@@ -1061,8 +1078,9 @@ void CDDM_apply_vert_coords(DerivedMesh *dm, float (*vertCoords)[3])
   vert = CustomData_duplicate_referenced_layer(&dm->vertData, CD_MVERT, dm->numVertData);
   cddm->mvert = vert;
 
-  for (i = 0; i < dm->numVertData; ++i, ++vert)
+  for (i = 0; i < dm->numVertData; ++i, ++vert) {
     copy_v3_v3(vert->co, vertCoords[i]);
+  }
 
   cddm->dm.dirty |= DM_DIRTY_NORMALS;
 }
@@ -1077,8 +1095,9 @@ void CDDM_apply_vert_normals(DerivedMesh *dm, short (*vertNormals)[3])
   vert = CustomData_duplicate_referenced_layer(&dm->vertData, CD_MVERT, dm->numVertData);
   cddm->mvert = vert;
 
-  for (i = 0; i < dm->numVertData; ++i, ++vert)
+  for (i = 0; i < dm->numVertData; ++i, ++vert) {
     copy_v3_v3_short(vert->no, vertNormals[i]);
+  }
 
   cddm->dm.dirty &= ~DM_DIRTY_NORMALS;
 }
@@ -1306,8 +1325,9 @@ void CDDM_calc_loop_normals_spacearr(DerivedMesh *dm,
 void CDDM_lower_num_verts(DerivedMesh *dm, int numVerts)
 {
   BLI_assert(numVerts >= 0);
-  if (numVerts < dm->numVertData)
+  if (numVerts < dm->numVertData) {
     CustomData_free_elem(&dm->vertData, numVerts, dm->numVertData - numVerts);
+  }
 
   dm->numVertData = numVerts;
 }
@@ -1315,8 +1335,9 @@ void CDDM_lower_num_verts(DerivedMesh *dm, int numVerts)
 void CDDM_lower_num_edges(DerivedMesh *dm, int numEdges)
 {
   BLI_assert(numEdges >= 0);
-  if (numEdges < dm->numEdgeData)
+  if (numEdges < dm->numEdgeData) {
     CustomData_free_elem(&dm->edgeData, numEdges, dm->numEdgeData - numEdges);
+  }
 
   dm->numEdgeData = numEdges;
 }
@@ -1324,8 +1345,9 @@ void CDDM_lower_num_edges(DerivedMesh *dm, int numEdges)
 void CDDM_lower_num_tessfaces(DerivedMesh *dm, int numTessFaces)
 {
   BLI_assert(numTessFaces >= 0);
-  if (numTessFaces < dm->numTessFaceData)
+  if (numTessFaces < dm->numTessFaceData) {
     CustomData_free_elem(&dm->faceData, numTessFaces, dm->numTessFaceData - numTessFaces);
+  }
 
   dm->numTessFaceData = numTessFaces;
 }
@@ -1333,8 +1355,9 @@ void CDDM_lower_num_tessfaces(DerivedMesh *dm, int numTessFaces)
 void CDDM_lower_num_loops(DerivedMesh *dm, int numLoops)
 {
   BLI_assert(numLoops >= 0);
-  if (numLoops < dm->numLoopData)
+  if (numLoops < dm->numLoopData) {
     CustomData_free_elem(&dm->loopData, numLoops, dm->numLoopData - numLoops);
+  }
 
   dm->numLoopData = numLoops;
 }
@@ -1342,8 +1365,9 @@ void CDDM_lower_num_loops(DerivedMesh *dm, int numLoops)
 void CDDM_lower_num_polys(DerivedMesh *dm, int numPolys)
 {
   BLI_assert(numPolys >= 0);
-  if (numPolys < dm->numPolyData)
+  if (numPolys < dm->numPolyData) {
     CustomData_free_elem(&dm->polyData, numPolys, dm->numPolyData - numPolys);
+  }
 
   dm->numPolyData = numPolys;
 }
@@ -1406,8 +1430,9 @@ void CDDM_set_mvert(DerivedMesh *dm, MVert *mvert)
 {
   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
 
-  if (!CustomData_has_layer(&dm->vertData, CD_MVERT))
+  if (!CustomData_has_layer(&dm->vertData, CD_MVERT)) {
     CustomData_add_layer(&dm->vertData, CD_MVERT, CD_ASSIGN, mvert, dm->numVertData);
+  }
 
   cddm->mvert = mvert;
 }
@@ -1416,8 +1441,9 @@ void CDDM_set_medge(DerivedMesh *dm, MEdge *medge)
 {
   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
 
-  if (!CustomData_has_layer(&dm->edgeData, CD_MEDGE))
+  if (!CustomData_has_layer(&dm->edgeData, CD_MEDGE)) {
     CustomData_add_layer(&dm->edgeData, CD_MEDGE, CD_ASSIGN, medge, dm->numEdgeData);
+  }
 
   cddm->medge = medge;
 }
@@ -1426,8 +1452,9 @@ void CDDM_set_mface(DerivedMesh *dm, MFace *mface)
 {
   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
 
-  if (!CustomData_has_layer(&dm->faceData, CD_MFACE))
+  if (!CustomData_has_layer(&dm->faceData, CD_MFACE)) {
     CustomData_add_layer(&dm->faceData, CD_MFACE, CD_ASSIGN, mface, dm->numTessFaceData);
+  }
 
   cddm->mface = mface;
 }
@@ -1436,8 +1463,9 @@ void CDDM_set_mloop(DerivedMesh *dm, MLoop *mloop)
 {
   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
 
-  if (!CustomData_has_layer(&dm->loopData, CD_MLOOP))
+  if (!CustomData_has_layer(&dm->loopData, CD_MLOOP)) {
     CustomData_add_layer(&dm->loopData, CD_MLOOP, CD_ASSIGN, mloop, dm->numLoopData);
+  }
 
   cddm->mloop = mloop;
 }
@@ -1446,8 +1474,9 @@ void CDDM_set_mpoly(DerivedMesh *dm, MPoly *mpoly)
 {
   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
 
-  if (!CustomData_has_layer(&dm->polyData, CD_MPOLY))
+  if (!CustomData_has_layer(&dm->polyData, CD_MPOLY)) {
     CustomData_add_layer(&dm->polyData, CD_MPOLY, CD_ASSIGN, mpoly, dm->numPolyData);
+  }
 
   cddm->mpoly = mpoly;
 }
index 3062c4d..6db5745 100644 (file)
@@ -140,11 +140,13 @@ void cloth_init(ClothModifierData *clmd)
 
   clmd->sim_parms->bending_model = CLOTH_BENDING_ANGULAR;
 
-  if (!clmd->sim_parms->effector_weights)
+  if (!clmd->sim_parms->effector_weights) {
     clmd->sim_parms->effector_weights = BKE_effector_add_weights(NULL);
+  }
 
-  if (clmd->point_cache)
+  if (clmd->point_cache) {
     clmd->point_cache->step = 1;
+  }
 }
 
 static BVHTree *bvhtree_build_from_cloth(ClothModifierData *clmd, float epsilon)
@@ -155,20 +157,23 @@ static BVHTree *bvhtree_build_from_cloth(ClothModifierData *clmd, float epsilon)
   ClothVertex *verts;
   const MVertTri *vt;
 
-  if (!clmd)
+  if (!clmd) {
     return NULL;
+  }
 
   cloth = clmd->clothObject;
 
-  if (!cloth)
+  if (!cloth) {
     return NULL;
+  }
 
   verts = cloth->verts;
   vt = cloth->tri;
 
   /* in the moment, return zero if no faces there */
-  if (!cloth->tri_num)
+  if (!cloth->tri_num) {
     return NULL;
+  }
 
   /* create quadtree with k=26 */
   bvhtree = BLI_bvhtree_new(cloth->tri_num, epsilon, 4, 26);
@@ -205,8 +210,9 @@ void bvhtree_update_from_cloth(ClothModifierData *clmd, bool moving, bool self)
     bvhtree = cloth->bvhtree;
   }
 
-  if (!bvhtree)
+  if (!bvhtree) {
     return;
+  }
 
   vt = cloth->tri;
 
@@ -254,8 +260,9 @@ void cloth_clear_cache(Object *ob, ClothModifierData *clmd, float framenr)
   BKE_ptcache_id_from_cloth(&pid, ob, clmd);
 
   // don't do anything as long as we're in editmode!
-  if (pid.cache->edit && ob->mode & OB_MODE_PARTICLE_EDIT)
+  if (pid.cache->edit && ob->mode & OB_MODE_PARTICLE_EDIT) {
     return;
+  }
 
   BKE_ptcache_id_clear(&pid, PTCACHE_CLEAR_AFTER, framenr);
 }
@@ -317,8 +324,9 @@ static int do_step_cloth(
 
   effectors = BKE_effectors_create(depsgraph, ob, NULL, clmd->sim_parms->effector_weights);
 
-  if (clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_DYNAMIC_BASEMESH)
+  if (clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_DYNAMIC_BASEMESH) {
     cloth_update_verts(ob, clmd, result);
+  }
 
   /* Support for dynamic vertex groups, changing from frame to frame */
   cloth_apply_vgroup(clmd, result);
@@ -387,8 +395,9 @@ void clothModifier_do(ClothModifierData *clmd,
   }
 
   /* initialize simulation data if it didn't exist already */
-  if (!do_init_cloth(ob, clmd, mesh, framenr))
+  if (!do_init_cloth(ob, clmd, mesh, framenr)) {
     return;
+  }
 
   if (framenr == startframe) {
     BKE_ptcache_id_reset(scene, &pid, PTCACHE_RESET_OUTDATED);
@@ -412,8 +421,9 @@ void clothModifier_do(ClothModifierData *clmd,
 
     BKE_ptcache_validate(cache, framenr);
 
-    if (cache_result == PTCACHE_READ_INTERPOLATED && cache->flag & PTCACHE_REDO_NEEDED)
+    if (cache_result == PTCACHE_READ_INTERPOLATED && cache->flag & PTCACHE_REDO_NEEDED) {
       BKE_ptcache_write(&pid, framenr);
+    }
 
     clmd->clothObject->last_frame = framenr;
 
@@ -431,8 +441,10 @@ void clothModifier_do(ClothModifierData *clmd,
   }
 
   /* if on second frame, write cache for first frame */
-  if (cache->simframe == startframe && (cache->flag & PTCACHE_OUTDATED || cache->last_exact == 0))
+  if (cache->simframe == startframe &&
+      (cache->flag & PTCACHE_OUTDATED || cache->last_exact == 0)) {
     BKE_ptcache_write(&pid, startframe);
+  }
 
   clmd->sim_parms->timescale *= framenr - cache->simframe;
 
@@ -442,8 +454,9 @@ void clothModifier_do(ClothModifierData *clmd,
   if (!do_step_cloth(depsgraph, ob, clmd, mesh, framenr)) {
     BKE_ptcache_invalidate(cache);
   }
-  else
+  else {
     BKE_ptcache_write(&pid, framenr);
+  }
 
   cloth_to_object(ob, clmd, vertexCos);
   clmd->clothObject->last_frame = framenr;
@@ -454,8 +467,9 @@ void cloth_free_modifier(ClothModifierData *clmd)
 {
   Cloth *cloth = NULL;
 
-  if (!clmd)
+  if (!clmd) {
     return;
+  }
 
   cloth = clmd->clothObject;
 
@@ -463,8 +477,9 @@ void cloth_free_modifier(ClothModifierData *clmd)
     BPH_cloth_solver_free(clmd);
 
     // Free the verts.
-    if (cloth->verts != NULL)
+    if (cloth->verts != NULL) {
       MEM_freeN(cloth->verts);
+    }
 
     cloth->verts = NULL;
     cloth->mvert_num = 0;
@@ -490,18 +505,22 @@ void cloth_free_modifier(ClothModifierData *clmd)
     cloth->numsprings = 0;
 
     // free BVH collision tree
-    if (cloth->bvhtree)
+    if (cloth->bvhtree) {
       BLI_bvhtree_free(cloth->bvhtree);
+    }
 
-    if (cloth->bvhselftree)
+    if (cloth->bvhselftree) {
       BLI_bvhtree_free(cloth->bvhselftree);
+    }
 
     // we save our faces for collision objects
-    if (cloth->tri)
+    if (cloth->tri) {
       MEM_freeN(cloth->tri);
+    }
 
-    if (cloth->edgeset)
+    if (cloth->edgeset) {
       BLI_edgeset_free(cloth->edgeset);
+    }
 
 #if 0
     if (clmd->clothObject->facemarks) {
@@ -521,8 +540,9 @@ void cloth_free_modifier_extern(ClothModifierData *clmd)
     printf("cloth_free_modifier_extern\n");
   }
 
-  if (!clmd)
+  if (!clmd) {
     return;
+  }
 
   cloth = clmd->clothObject;
 
@@ -534,8 +554,9 @@ void cloth_free_modifier_extern(ClothModifierData *clmd)
     BPH_cloth_solver_free(clmd);
 
     // Free the verts.
-    if (cloth->verts != NULL)
+    if (cloth->verts != NULL) {
       MEM_freeN(cloth->verts);
+    }
 
     cloth->verts = NULL;
     cloth->mvert_num = 0;
@@ -561,18 +582,22 @@ void cloth_free_modifier_extern(ClothModifierData *clmd)
     cloth->numsprings = 0;
 
     // free BVH collision tree
-    if (cloth->bvhtree)
+    if (cloth->bvhtree) {
       BLI_bvhtree_free(cloth->bvhtree);
+    }
 
-    if (cloth->bvhselftree)
+    if (cloth->bvhselftree) {
       BLI_bvhtree_free(cloth->bvhselftree);
+    }
 
     // we save our faces for collision objects
-    if (cloth->tri)
+    if (cloth->tri) {
       MEM_freeN(cloth->tri);
+    }
 
-    if (cloth->edgeset)
+    if (cloth->edgeset) {
       BLI_edgeset_free(cloth->edgeset);
+    }
 
 #if 0
     if (clmd->clothObject->facemarks) {
@@ -631,8 +656,9 @@ static void cloth_apply_vgroup(ClothModifierData *clmd, Mesh *mesh)
   /* float goalfac = 0; */ /* UNUSED */
   ClothVertex *verts = NULL;
 
-  if (!clmd || !mesh)
+  if (!clmd || !mesh) {
     return;
+  }
 
   clothObj = clmd->clothObject;
 
@@ -644,10 +670,12 @@ static void cloth_apply_vgroup(ClothModifierData *clmd, Mesh *mesh)
     for (i = 0; i < mvert_num; i++, verts++) {
 
       /* Reset Goal values to standard */
-      if (clmd->sim_parms->vgroup_mass > 0)
+      if (clmd->sim_parms->vgroup_mass > 0) {
         verts->goal = clmd->sim_parms->defgoal;
-      else
+      }
+      else {
         verts->goal = 0.0f;
+      }
 
       /* Compute base cloth shrink weight */
       verts->shrink_factor = 0.0f;
@@ -668,8 +696,9 @@ static void cloth_apply_vgroup(ClothModifierData *clmd, Mesh *mesh)
             // ABS ( clmd->sim_parms->maxgoal - clmd->sim_parms->mingoal );
 
             verts->goal = pow4f(verts->goal);
-            if (verts->goal >= SOFTGOALSNAP)
+            if (verts->goal >= SOFTGOALSNAP) {
               verts->flags |= CLOTH_VERT_FLAG_PINNED;
+            }
           }
 
           if (dvert->dw[j].def_nr == (clmd->sim_parms->vgroup_struct - 1)) {
@@ -746,8 +775,9 @@ static int cloth_from_object(
   }
 
   // mesh input objects need Mesh
-  if (!mesh)
+  if (!mesh) {
     return 0;
+  }
 
   cloth_from_mesh(clmd, mesh);
 
@@ -756,8 +786,9 @@ static int cloth_from_object(
   clmd->clothObject->numsprings = -1;
 
   if (clmd->sim_parms->shapekey_rest &&
-      !(clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_DYNAMIC_BASEMESH))
+      !(clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_DYNAMIC_BASEMESH)) {
     shapekey_rest = CustomData_get_layer(&mesh->vdata, CD_CLOTH_ORCO);
+  }
 
   mvert = mesh->mvert;
 
@@ -774,18 +805,21 @@ static int cloth_from_object(
         copy_v3_v3(verts->xrest, shapekey_rest[i]);
         mul_m4_v3(ob->obmat, verts->xrest);
       }
-      else
+      else {
         copy_v3_v3(verts->xrest, verts->x);
+      }
     }
 
     /* no GUI interface yet */
     verts->mass = clmd->sim_parms->mass;
     verts->impulse_count = 0;
 
-    if (clmd->sim_parms->vgroup_mass > 0)
+    if (clmd->sim_parms->vgroup_mass > 0) {
       verts->goal = clmd->sim_parms->defgoal;
-    else
+    }
+    else {
       verts->goal = 0.0f;
+    }
 
     verts->shrink_factor = 0.0f;
 
@@ -813,8 +847,9 @@ static int cloth_from_object(
   // init our solver
   BPH_cloth_solver_init(ob, clmd);
 
-  if (!first)
+  if (!first) {
     BKE_cloth_solver_set_positions(clmd);
+  }
 
   clmd->clothObject->bvhtree = bvhtree_build_from_cloth(clmd, clmd->coll_parms->epsilon);
   clmd->clothObject->bvhselftree = bvhtree_build_from_cloth(clmd, clmd->coll_parms->selfepsilon);
@@ -854,8 +889,9 @@ static void cloth_from_mesh(ClothModifierData *clmd, Mesh *mesh)
   /* Free the springs since they can't be correct if the vertices
    * changed.
    */
-  if (clmd->clothObject->springs != NULL)
+  if (clmd->clothObject->springs != NULL) {
     MEM_freeN(clmd->clothObject->springs);
+  }
 }
 
 /***************************************************************************************
@@ -960,8 +996,9 @@ static void cloth_hair_update_bending_targets(ClothModifierData *clmd)
   float hair_frame[3][3], dir_old[3], dir_new[3];
   int prev_mn; /* to find hair chains */
 
-  if (!clmd->hairdata)
+  if (!clmd->hairdata) {
     return;
+  }
 
   /* XXX Note: we need to propagate frames from the root up,
    * but structural hair springs are stored in reverse order.
@@ -1017,8 +1054,9 @@ static void cloth_hair_update_bending_rest_targets(ClothModifierData *clmd)
   float hair_frame[3][3], dir_old[3], dir_new[3];
   int prev_mn; /* to find hair roots */
 
-  if (!clmd->hairdata)
+  if (!clmd->hairdata) {
     return;
+  }
 
   /* XXX Note: we need to propagate frames from the root up,
    * but structural hair springs are stored in reverse order.
@@ -1358,8 +1396,9 @@ static int cloth_build_springs(ClothModifierData *clmd, Mesh *mesh)
   BendSpringRef *spring_ref = NULL;
 
   // error handling
-  if (numedges == 0)
+  if (numedges == 0) {
     return 0;
+  }
 
   /* NOTE: handling ownership of springs and edgeset is quite sloppy
    * currently they are never initialized but assert just to be sure */
@@ -1434,13 +1473,15 @@ static int cloth_build_springs(ClothModifierData *clmd, Mesh *mesh)
     }
   }
 
-  if (struct_springs_real > 0)
+  if (struct_springs_real > 0) {
     clmd->sim_parms->avg_spring_len /= struct_springs_real;
+  }
 
   for (int i = 0; i < mvert_num; i++) {
-    if (cloth->verts[i].spring_count > 0)
+    if (cloth->verts[i].spring_count > 0) {
       cloth->verts[i].avg_spring_len = cloth->verts[i].avg_spring_len * 0.49f /
                                        ((float)cloth->verts[i].spring_count);
+    }
   }
 
   edgeset = BLI_edgeset_new_ex(__func__, numedges);
index 3809484..16b330d 100644 (file)
@@ -602,8 +602,9 @@ Collection *BKE_collection_object_find(Main *bmain,
   }
 
   while (collection) {
-    if (BKE_collection_has_object(collection, ob))
+    if (BKE_collection_has_object(collection, ob)) {
       return collection;
+    }
     collection = collection_next_find(bmain, scene, collection);
   }
   return NULL;
@@ -1217,8 +1218,9 @@ static void scene_collections_array(Scene *scene, Collection ***collections_arra
   BLI_assert(collection != NULL);
   scene_collection_callback(collection, scene_collections_count, tot);
 
-  if (*tot == 0)
+  if (*tot == 0) {
     return;
+  }
 
   *collections_array = array = MEM_mallocN(sizeof(Collection *) * (*tot), "CollectionArray");
   scene_collection_callback(collection, scene_collections_build_array, &array);
index 41dc82c..a8ca6d4 100644 (file)
@@ -446,13 +446,15 @@ static void collision_compute_barycentric(
 
   w1[0] = (float)((e * c - b * f) / d);
 
-  if (w1[0] < 0)
+  if (w1[0] < 0) {
     w1[0] = 0;
+  }
 
   w2[0] = (float)((f - b * (double)w1[0]) / c);
 
-  if (w2[0] < 0)
+  if (w2[0] < 0) {
     w2[0] = 0;
+  }
 
   w3[0] = 1.0f - w1[0] - w2[0];
 
@@ -637,16 +639,19 @@ static int cloth_collision_response_static(ClothModifierData *clmd,
 
       for (int j = 0; j < 3; j++) {
         if (cloth1->verts[collpair->ap1].impulse_count > 0 &&
-            ABS(cloth1->verts[collpair->ap1].impulse[j]) < ABS(i1[j]))
+            ABS(cloth1->verts[collpair->ap1].impulse[j]) < ABS(i1[j])) {
           cloth1->verts[collpair->ap1].impulse[j] = i1[j];
+        }
 
         if (cloth1->verts[collpair->ap2].impulse_count > 0 &&
-            ABS(cloth1->verts[collpair->ap2].impulse[j]) < ABS(i2[j]))
+            ABS(cloth1->verts[collpair->ap2].impulse[j]) < ABS(i2[j])) {
           cloth1->verts[collpair->ap2].impulse[j] = i2[j];
+        }
 
         if (cloth1->verts[collpair->ap3].impulse_count > 0 &&
-            ABS(cloth1->verts[collpair->ap3].impulse[j]) < ABS(i3[j]))
+            ABS(cloth1->verts[collpair->ap3].impulse[j]) < ABS(i3[j])) {
           cloth1->verts[collpair->ap3].impulse[j] = i3[j];
+        }
       }
     }
   }
@@ -816,16 +821,19 @@ static int cloth_selfcollision_response_static(ClothModifierData *clmd,
 
       for (int j = 0; j < 3; j++) {
         if (cloth1->verts[collpair->ap1].impulse_count > 0 &&
-            ABS(cloth1->verts[collpair->ap1].impulse[j]) < ABS(i1[j]))
+            ABS(cloth1->verts[collpair->ap1].impulse[j]) < ABS(i1[j])) {
           cloth1->verts[collpair->ap1].impulse[j] = i1[j];
+        }
 
         if (cloth1->verts[collpair->ap2].impulse_count > 0 &&
-            ABS(cloth1->verts[collpair->ap2].impulse[j]) < ABS(i2[j]))
+            ABS(cloth1->verts[collpair->ap2].impulse[j]) < ABS(i2[j])) {
           cloth1->verts[collpair->ap2].impulse[j] = i2[j];
+        }
 
         if (cloth1->verts[collpair->ap3].impulse_count > 0 &&
-            ABS(cloth1->verts[collpair->ap3].impulse[j]) < ABS(i3[j]))
+            ABS(cloth1->verts[collpair->ap3].impulse[j]) < ABS(i3[j])) {
           cloth1->verts[collpair->ap3].impulse[j] = i3[j];
+        }
       }
     }
   }
@@ -974,8 +982,9 @@ static void add_collision_object(ListBase *relations,
 
   /* only get objects with collision modifier */
   if (((modifier_type == eModifierType_Collision) && ob->pd && ob->pd->deflect) ||
-      (modifier_type != eModifierType_Collision))
+      (modifier_type != eModifierType_Collision)) {
     cmd = (CollisionModifierData *)modifiers_findByType(ob, modifier_type);
+  }
 
   if (cmd) {
     CollisionRelation *relation = MEM_callocN(sizeof(CollisionRelation), "CollisionRelation");
@@ -1279,8 +1288,9 @@ int cloth_bvh_collision(
   uint coll_count_self = 0;
   BVHTreeOverlap *overlap_self = NULL;
 
-  if ((clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_COLLOBJ) || cloth_bvh == NULL)
+  if ((clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_COLLOBJ) || cloth_bvh == NULL) {
     return 0;
+  }
 
   verts = cloth->verts;
   mvert_num = cloth->mvert_num;
@@ -1500,16 +1510,18 @@ static CollPair *cloth_point_collpair(float p1[3],
   float facenor[3], v1p1[3], v1p2[3];
   float w[3];
 
-  if (!cloth_point_face_collision_params(p1, p2, co1, co2, co3, facenor, &lambda, w))
+  if (!cloth_point_face_collision_params(p1, p2, co1, co2, co3, facenor, &lambda, w)) {
     return collpair;
+  }
 
   sub_v3_v3v3(v1p1, p1, co1);
   //  distance1 = dot_v3v3(v1p1, facenor);
   sub_v3_v3v3(v1p2, p2, co1);
   distance2 = dot_v3v3(v1p2, facenor);
   //  if (distance2 > epsilon || (distance1 < 0.0f && distance2 < 0.0f))
-  if (distance2 > epsilon)
+  if (distance2 > epsilon) {
     return collpair;
+  }
 
   collpair->face1 = index_cloth; /* XXX actually not a face, but equivalent index for point */
   collpair->face2 = index_coll;
@@ -1642,8 +1654,9 @@ void cloth_find_point_contacts(Depsgraph *depsgraph,
     Object *collob = collobjs[i];
     CollisionModifierData *collmd = (CollisionModifierData *)modifiers_findByType(
         collob, eModifierType_Collision);
-    if (!collmd->bvhtree)
+    if (!collmd->bvhtree) {
       continue;
+    }
 
     /* move object to position (step) in time */
     collision_move_object(collmd, step + dt, step);
@@ -1666,8 +1679,9 @@ void cloth_find_point_contacts(Depsgraph *depsgraph,
     ct->collisions = NULL;
     ct->totcollisions = 0;
 
-    if (!collmd->bvhtree)
+    if (!collmd->bvhtree) {
       continue;
+    }
 
     /* search for overlapping collision pairs */
     overlap = BLI_bvhtree_overlap(cloth_bvh, collmd->bvhtree, &result, NULL, NULL);
@@ -1686,8 +1700,9 @@ void cloth_find_point_contacts(Depsgraph *depsgraph,
       //          ret += cloth_points_objcollisions_resolve(clmd, collmd, collob->pd, collisions[i], collisions_index[i], dt);
     }
 
-    if (overlap)
+    if (overlap) {
       MEM_freeN(overlap);
+    }
   }
 
   BKE_collision_objects_free(collobjs);
index ffb6019..3d13c16 100644 (file)
@@ -338,38 +338,49 @@ static float colorband_hue_interp(
 
   switch (ipotype_hue) {
     case COLBAND_HUE_NEAR: {
-      if ((h1 < h2) && (h2 - h1) > +0.5f)
+      if ((h1 < h2) && (h2 - h1) > +0.5f) {
         mode = 1;
-      else if ((h1 > h2) && (h2 - h1) < -0.5f)
+      }
+      else if ((h1 > h2) && (h2 - h1) < -0.5f) {
         mode = 2;
-      else
+      }
+      else {
         mode = 0;
+      }
       break;
     }
     case COLBAND_HUE_FAR: {
       /* Do full loop in Hue space in case both stops are the same... */
-      if (h1 == h2)
+      if (h1 == h2) {
         mode = 1;
-      else if ((h1 < h2) && (h2 - h1) < +0.5f)
+      }
+      else if ((h1 < h2) && (h2 - h1) < +0.5f) {
         mode = 1;
-      else if ((h1 > h2) && (h2 - h1) > -0.5f)
+      }
+      else if ((h1 > h2) && (h2 - h1) > -0.5f) {
         mode = 2;
-      else
+      }
+      else {
         mode = 0;
+      }
       break;
     }
     case COLBAND_HUE_CCW: {
-      if (h1 > h2)
+      if (h1 > h2) {
         mode = 2;
-      else
+      }
+      else {
         mode = 0;
+      }
       break;
     }
     case COLBAND_HUE_CW: {
-      if (h1 < h2)
+      if (h1 < h2) {
         mode = 1;
-      else
+      }
+      else {
         mode = 0;
+      }
       break;
     }
   }
@@ -403,8 +414,9 @@ bool BKE_colorband_evaluate(const ColorBand *coba, float in, float out[4])
   int ipotype;
   int a;
 
-  if (coba == NULL || coba->tot == 0)
+  if (coba == NULL || coba->tot == 0) {
     return false;
+  }
 
   cbd1 = coba->data;
 
@@ -480,14 +492,18 @@ bool BKE_colorband_evaluate(const ColorBand *coba, float in, float out[4])
         /* ipo from right to left: 3 2 1 0 */
         float t[4];
 
-        if (a >= coba->tot - 1)
+        if (a >= coba->tot - 1) {
           cbd0 = cbd1;
-        else
+        }
+        else {
           cbd0 = cbd1 + 1;
-        if (a < 2)
+        }
+        if (a < 2) {
           cbd3 = cbd2;
-        else
+        }
+        else {
           cbd3 = cbd2 - 1;
+        }
 
         CLAMP(fac, 0.0f, 1.0f);
 
@@ -561,18 +577,21 @@ void BKE_colorband_evaluate_table_rgba(const ColorBand *coba, float **array, int
   *size = CM_TABLE + 1;
   *array = MEM_callocN(sizeof(float) * (*size) * 4, "ColorBand");
 
-  for (a = 0; a < *size; a++)
+  for (a = 0; a < *size; a++) {
     BKE_colorband_evaluate(coba, (float)a / (float)CM_TABLE, &(*array)[a * 4]);
+  }
 }
 
 static int vergcband(const void *a1, const void *a2)
 {
   const CBData *x1 = a1, *x2 = a2;
 
-  if (x1->pos > x2->pos)
+  if (x1->pos > x2->pos) {
     return 1;
-  else if (x1->pos < x2->pos)
+  }
+  else if (x1->pos < x2->pos) {
     return -1;
+  }
   return 0;
 }
 
@@ -580,11 +599,13 @@ void BKE_colorband_update_sort(ColorBand *coba)
 {
   int a;
 
-  if (coba->tot < 2)
+  if (coba->tot < 2) {
     return;
+  }
 
-  for (a = 0; a < coba->tot; a++)
+  for (a = 0; a < coba->tot; a++) {
     coba->data[a].cur = a;
+  }
 
   qsort(coba->data, coba->tot, sizeof(CBData), vergcband);
 
@@ -627,17 +648,20 @@ int BKE_colorband_element_remove(struct ColorBand *coba, int index)
 {
   int a;
 
-  if (coba->tot < 2)
+  if (coba->tot < 2) {
     return 0;
+  }
 
-  if (index < 0 || index >= coba->tot)
+  if (index < 0 || index >= coba->tot) {
     return 0;
+  }
 
   coba->tot--;
   for (a = index; a < coba->tot; a++) {
     coba->data[a] = coba->data[a + 1];
   }
-  if (coba->cur)
+  if (coba->cur) {
     coba->cur--;
+  }
   return 1;
 }
index 6d3aea9..45cb5e8 100644 (file)
@@ -55,8 +55,9 @@ void curvemapping_set_defaults(
   float clipminx, clipminy, clipmaxx, clipmaxy;
 
   cumap->flag = CUMA_DO_CLIP;
-  if (tot == 4)
+  if (tot == 4) {
     cumap->cur = 3; /* rhms, hack for 'col' curve? */
+  }
 
   clipminx = min_ff(minx, maxx);
   clipminy = min_ff(miny, maxy);
@@ -129,12 +130,15 @@ void curvemapping_copy_data(CurveMapping *target, const CurveMapping *cumap)
   *target = *cumap;
 
   for (a = 0; a < CM_TOT; a++) {
-    if (cumap->cm[a].curve)
+    if (cumap->cm[a].curve) {
       target->cm[a].curve = MEM_dupallocN(cumap->cm[a].curve);
-    if (cumap->cm[a].table)
+    }
+    if (cumap->cm[a].table) {
       target->cm[a].table = MEM_dupallocN(cumap->cm[a].table);
-    if (cumap->cm[a].premultable)
+    }
+    if (cumap->cm[a].premultable) {
       target->cm[a].premultable = MEM_dupallocN(cumap->cm[a].premultable);
+    }
   }
 }
 
@@ -181,8 +185,9 @@ bool curvemap_remove_point(CurveMap *cuma, CurveMapPoint *point)
   int a, b, removed = 0;
 
   /* must have 2 points minimum */
-  if (cuma->totpoint <= 2)
+  if (cuma->totpoint <= 2) {
     return false;
+  }
 
   cmp = MEM_mallocN((cuma->totpoint) * sizeof(CurveMapPoint), "curve points");
 
@@ -263,8 +268,9 @@ CurveMapPoint *curvemap_insert(CurveMap *cuma, float x, float y)
 
 void curvemap_reset(CurveMap *cuma, const rctf *clipr, int preset, int slope)
 {
-  if (cuma->curve)
+  if (cuma->curve) {
     MEM_freeN(cuma->curve);
+  }
 
   switch (preset) {
     case CURVE_PRESET_LINE:
@@ -502,10 +508,12 @@ static void calchandle_curvemap(BezTriple *bezt, const BezTriple *prev, const Be
   len_a = len_v2(dvec_a);
   len_b = len_v2(dvec_b);
 
-  if (len_a == 0.0f)
+  if (len_a == 0.0f) {
     len_a = 1.0f;
-  if (len_b == 0.0f)
+  }
+  if (len_b == 0.0f) {
     len_b = 1.0f;
+  }
 
   if (ELEM(bezt->h1, HD_AUTO, HD_AUTO_ANIM) || ELEM(bezt->h2, HD_AUTO, HD_AUTO_ANIM)) { /* auto */
     float tvec[2];
@@ -590,10 +598,12 @@ static float curvemap_calc_extend(const CurveMap *cuma,
       return first[1];
     }
     else {
-      if (cuma->ext_in[0] == 0.0f)
+      if (cuma->ext_in[0] == 0.0f) {
         return first[1] + cuma->ext_in[1] * 10000.0f;
-      else
+      }
+      else {
         return first[1] + cuma->ext_in[1] * (x - first[0]) / cuma->ext_in[0];
+      }
     }
   }
   else if (x >= last[0]) {
@@ -602,10 +612,12 @@ static float curvemap_calc_extend(const CurveMap *cuma,
       return last[1];
     }
     else {
-      if (cuma->ext_out[0] == 0.0f)
+      if (cuma->ext_out[0] == 0.0f) {
         return last[1] - cuma->ext_out[1] * 10000.0f;
-      else
+      }
+      else {
         return last[1] + cuma->ext_out[1] * (x - last[0]) / cuma->ext_out[0];
+      }
     }
   }
   return 0.0f;
@@ -619,8 +631,9 @@ static void curvemap_make_table(CurveMap *cuma, const rctf *clipr)
   float *fp, *allpoints, *lastpoint, curf, range;
   int a, totpoint;
 
-  if (cuma->curve == NULL)
+  if (cuma->curve == NULL) {
     return;
+  }
 
   /* default rect also is table range */
   cuma->mintable = clipr->xmin;
@@ -662,8 +675,9 @@ static void curvemap_make_table(CurveMap *cuma, const rctf *clipr)
       hlen = len_v3v3(bezt[0].vec[1], bezt[0].vec[2]); /* original handle length */
       /* clip handle point */
       copy_v3_v3(vec, bezt[1].vec[0]);
-      if (vec[0] < bezt[0].vec[1][0])
+      if (vec[0] < bezt[0].vec[1][0]) {
         vec[0] = bezt[0].vec[1][0];
+      }
 
       sub_v3_v3(vec, bezt[0].vec[1]);
       nlen = len_v3(vec);
@@ -679,8 +693,9 @@ static void curvemap_make_table(CurveMap *cuma, const rctf *clipr)
       hlen = len_v3v3(bezt[a].vec[1], bezt[a].vec[0]); /* original handle length */
       /* clip handle point */
       copy_v3_v3(vec, bezt[a - 1].vec[2]);
-      if (vec[0] > bezt[a].vec[1][0])
+      if (vec[0] > bezt[a].vec[1][0]) {
         vec[0] = bezt[a].vec[1][0];
+      }
 
       sub_v3_v3(vec, bezt[a].vec[1]);
       nlen = len_v3(vec);
@@ -692,8 +707,9 @@ static void curvemap_make_table(CurveMap *cuma, const rctf *clipr)
     }
   }
   /* make the bezier curve */
-  if (cuma->table)
+  if (cuma->table) {
     MEM_freeN(cuma->table);
+  }
   totpoint = (cuma->totpoint - 1) * CM_RESOL;
   fp = allpoints = MEM_callocN(totpoint * 2 * sizeof(float), "table");
 
@@ -748,15 +764,18 @@ static void curvemap_make_table(CurveMap *cuma, const rctf *clipr)
     while (curf >= fp[0] && fp != lastpoint) {
       fp += 2;
     }
-    if (fp == allpoints || (curf >= fp[0] && fp == lastpoint))
+    if (fp == allpoints || (curf >= fp[0] && fp == lastpoint)) {
       cmp[a].y = curvemap_calc_extend(cuma, curf, allpoints, lastpoint);
+    }
     else {
       float fac1 = fp[0] - fp[-2];
       float fac2 = fp[0] - curf;
-      if (fac1 > FLT_EPSILON)
+      if (fac1 > FLT_EPSILON) {
         fac1 = fac2 / fac1;
-      else
+      }
+      else {
         fac1 = 0.0f;
+      }
       cmp[a].y = fac1 * fp[-1] + (1.0f - fac1) * fp[1];
     }
   }
@@ -791,16 +810,18 @@ void curvemapping_premultiply(CurveMapping *cumap, int restore)
     if ((cumap->flag & CUMA_PREMULLED) == 0) {
       /* verify and copy */
       for (a = 0; a < 3; a++) {
-        if (cumap->cm[a].table == NULL)
+        if (cumap->cm[a].table == NULL) {
           curvemap_make_table(cumap->cm + a, &cumap->clipr);
+        }
         cumap->cm[a].premultable = cumap->cm[a].table;
         cumap->cm[a].table = MEM_mallocN((CM_TABLE + 1) * sizeof(CurveMapPoint), "premul table");
         memcpy(
             cumap->cm[a].table, cumap->cm[a].premultable, (CM_TABLE + 1) * sizeof(CurveMapPoint));
       }
 
-      if (cumap->cm[3].table == NULL)
+      if (cumap->cm[3].table == NULL) {
         curvemap_make_table(cumap->cm + 3, &cumap->clipr);
+      }
 
       /* premul */
       for (a = 0; a < 3; a++) {
@@ -824,10 +845,12 @@ static int sort_curvepoints(const void *a1, const void *a2)
 {
   const struct CurveMapPoint *x1 = a1, *x2 = a2;
 
-  if (x1->x > x2->x)
+  if (x1->x > x2->x) {
     return 1;
-  else if (x1->x < x2->x)
+  }
+  else if (x1->x < x2->x) {
     return -1;
+  }
   return 0;
 }
 
@@ -849,14 +872,18 @@ void curvemapping_changed(CurveMapping *cumap, const bool rem_doubles)
   if (cumap->flag & CUMA_DO_CLIP) {
     for (a = 0; a < cuma->totpoint; a++) {
       if (cmp[a].flag & CUMA_SELECT) {
-        if (cmp[a].x < clipr->xmin)
+        if (cmp[a].x < clipr->xmin) {
           dx = min_ff(dx, cmp[a].x - clipr->xmin);
-        else if (cmp[a].x > clipr->xmax)
+        }
+        else if (cmp[a].x > clipr->xmax) {
           dx = max_ff(dx, cmp[a].x - clipr->xmax);
-        if (cmp[a].y < clipr->ymin)
+        }
+        if (cmp[a].y < clipr->ymin) {
           dy = min_ff(dy, cmp[a].y - clipr->ymin);
-        else if (cmp[a].y > clipr->ymax)
+        }
+        else if (cmp[a].y > clipr->ymax) {
           dy = max_ff(dy, cmp[a].y - clipr->ymax);
+        }
       }
     }
     for (a = 0; a < cuma->totpoint; a++) {
@@ -887,19 +914,22 @@ void curvemapping_changed(CurveMapping *cumap, const bool rem_doubles)
       if (sqrtf(dx * dx + dy * dy) < thresh) {
         if (a == 0) {
           cmp[a + 1].flag |= CUMA_HANDLE_VECTOR;
-          if (cmp[a + 1].flag & CUMA_SELECT)
+          if (cmp[a + 1].flag & CUMA_SELECT) {
             cmp[a].flag |= CUMA_SELECT;
+          }
         }
         else {
           cmp[a].flag |= CUMA_HANDLE_VECTOR;
-          if (cmp[a].flag & CUMA_SELECT)
+          if (cmp[a].flag & CUMA_SELECT) {
             cmp[a + 1].flag |= CUMA_SELECT;
+          }
         }
         break; /* we assume 1 deletion per edit is ok */
       }
     }
-    if (a != cuma->totpoint - 1)
+    if (a != cuma->totpoint - 1) {
       curvemap_remove(cuma, 2);
+    }
   }
   curvemap_make_table(cuma, clipr);
 }
@@ -929,13 +959,16 @@ float curvemap_evaluateF(const CurveMap *cuma, float value)
   i = (int)fi;
 
   /* fi is table float index and should check against table range i.e. [0.0 CM_TABLE] */
-  if (fi < 0.0f || fi > CM_TABLE)
+  if (fi < 0.0f || fi > CM_TABLE) {
     return curvemap_calc_extend(cuma, value, &cuma->table[0].x, &cuma->table[CM_TABLE].x);
+  }
   else {
-    if (i < 0)
+    if (i < 0) {
       return cuma->table[0].y;
-    if (i >= CM_TABLE)
+    }
+    if (i >= CM_TABLE) {
       return cuma->table[CM_TABLE].y;
+    }
 
     fi = fi - (float)i;
     return (1.0f - fi) * cuma->table[i].y + (fi)*cuma->table[i + 1].y;
@@ -950,10 +983,12 @@ float curvemapping_evaluateF(const CurveMapping *cumap, int cur, float value)
 
   /* account for clipping */
   if (cumap->flag & CUMA_DO_CLIP) {
-    if (val < cumap->curr.ymin)
+    if (val < cumap->curr.ymin) {
       val = cumap->curr.ymin;
-    else if (val > cumap->curr.ymax)
+    }
+    else if (val > cumap->curr.ymax) {
       val = cumap->curr.ymax;
+    }
   }
 
   return val;
@@ -1096,32 +1131,43 @@ int curvemapping_RGBA_does_something(const CurveMapping *cumap)
 {
   int a;
 
-  if (cumap->black[0] != 0.0f)
+  if (cumap->black[0] != 0.0f) {
     return 1;
-  if (cumap->black[1] != 0.0f)
+  }
+  if (cumap->black[1] != 0.0f) {
     return 1;
-  if (cumap->black[2] != 0.0f)
+  }
+  if (cumap->black[2] != 0.0f) {
     return 1;
-  if (cumap->white[0] != 1.0f)
+  }
+  if (cumap->white[0] != 1.0f) {
     return 1;
-  if (cumap->white[1] != 1.0f)
+  }
+  if (cumap->white[1] != 1.0f) {
     return 1;
-  if (cumap->white[2] != 1.0f)
+  }
+  if (cumap->white[2] != 1.0f) {
     return 1;
+  }
 
   for (a = 0; a < CM_TOT; a++) {
     if (cumap->cm[a].curve) {
-      if (cumap->cm[a].totpoint != 2)
+      if (cumap->cm[a].totpoint != 2) {
         return 1;
+      }
 
-      if (cumap->cm[a].curve[0].x != 0.0f)
+      if (cumap->cm[a].curve[0].x != 0.0f) {
         return 1;
-      if (cumap->cm[a].curve[0].y != 0.0f)
+      }
+      if (cumap->cm[a].curve[0].y != 0.0f) {
         return 1;
-      if (cumap->cm[a].curve[1].x != 1.0f)
+      }
+      if (cumap->cm[a].curve[1].x != 1.0f) {
         return 1;
-      if (cumap->cm[a].curve[1].y != 1.0f)
+      }
+      if (cumap->cm[a].curve[1].y != 1.0f) {
         return 1;
+      }
     }
   }
   return 0;
@@ -1131,12 +1177,14 @@ void curvemapping_initialize(CurveMapping *cumap)
 {
   int a;
 
-  if (cumap == NULL)
+  if (cumap == NULL) {
     return;
+  }
 
   for (a = 0; a < CM_TOT; a++) {
-    if (cumap->cm[a].table == NULL)
+    if (cumap->cm[a].table == NULL) {
       curvemap_make_table(cumap->cm + a, &cumap->clipr);
+    }
   }
 }
 
@@ -1148,14 +1196,18 @@ void curvemapping_table_RGBA(const CurveMapping *cumap, float **array, int *size
   *array = MEM_callocN(sizeof(float) * (*size) * 4, "CurveMapping");
 
   for (a = 0; a < *size; a++) {
-    if (cumap->cm[0].table)
+    if (cumap->cm[0].table) {
       (*array)[a * 4 + 0] = cumap->cm[0].table[a].y;
-    if (cumap->cm[1].table)
+    }
+    if (cumap->cm[1].table) {
       (*array)[a * 4 + 1] = cumap->cm[1].table[a].y;
-    if (cumap->cm[2].table)
+    }
+    if (cumap->cm[2].table) {
       (*array)[a * 4 + 2] = cumap->cm[2].table[a].y;
-    if (cumap->cm[3].table)
+    }
+    if (cumap->cm[3].table) {
       (*array)[a * 4 + 3] = cumap->cm[3].table[a].y;
+    }
   }
 }
 
@@ -1232,11 +1284,13 @@ void BKE_histogram_update_sample_line(Histogram *hist,
   hist->xmax = 1.0f;
   /* hist->ymax = 1.0f; */ /* now do this on the operator _only_ */
 
-  if (ibuf->rect == NULL && ibuf->rect_float == NULL)
+  if (ibuf->rect == NULL && ibuf->rect_float == NULL) {
     return;
+  }
 
-  if (ibuf->rect_float)
+  if (ibuf->rect_float) {
     cm_processor = IMB_colormanagement_display_processor_new(view_settings, display_settings);
+  }
 
   for (i = 0; i < 256; i++) {
     x = (int)(0.5f + x1 + (float)i * (x2 - x1) / 255.0f);
@@ -1290,8 +1344,9 @@ void BKE_histogram_update_sample_line(Histogram *hist,
     }
   }
 
-  if (cm_processor)
+  if (cm_processor) {
     IMB_colormanagement_processor_free(cm_processor);
+  }
 }
 
 /* if view_settings, it also applies this to byte buffers */
@@ -1343,8 +1398,9 @@ static void scopes_update_cb(void *__restrict userdata,
                               (y % rows_per_sample_line) == 0;
   const bool is_float = (ibuf->rect_float != NULL);
 
-  if (is_float)
+  if (is_float) {
     rf = ibuf->rect_float + ((size_t)y) * ibuf->x * ibuf->channels;
+  }
   else {
     rc = display_buffer + ((size_t)y) * ibuf->x * ibuf->channels;
   }
@@ -1376,8 +1432,9 @@ static void scopes_update_cb(void *__restrict userdata,
       }
     }
     else {
-      for (int c = 4; c--;)
+      for (int c = 4; c--;) {
         rgba[c] = rc[c] * INV_255;
+      }
     }
 
     /* we still need luma for histogram */
@@ -1440,10 +1497,12 @@ static void scopes_update_finalize(void *__restrict userdata, void *__restrict u
   }
 
   for (int c = 3; c--;) {
-    if (min[c] < minmax[c][0])
+    if (min[c] < minmax[c][0]) {
       minmax[c][0] = min[c];
-    if (max[c] > minmax[c][1])
+    }
+    if (max[c] > minmax[c][1]) {
       minmax[c][1] = max[c];
+    }
   }
 }
 
@@ -1461,18 +1520,22 @@ void scopes_update(Scopes *scopes,
   void *cache_handle = NULL;
   struct ColormanageProcessor *cm_processor = NULL;
 
-  if (ibuf->rect == NULL && ibuf->rect_float == NULL)
+  if (ibuf->rect == NULL && ibuf->rect_float == NULL) {
     return;
+  }
 
-  if (scopes->ok == 1)
+  if (scopes->ok == 1) {
     return;
+  }
 
-  if (scopes->hist.ymax == 0.f)
+  if (scopes->hist.ymax == 0.f) {
     scopes->hist.ymax = 1.f;
+  }
 
   /* hmmmm */
-  if (!(ELEM(ibuf->channels, 3, 4)))
+  if (!(ELEM(ibuf->channels, 3, 4))) {
     return;
+  }
 
   scopes->hist.channels = 3;
   scopes->hist.x_resolution = 256;
@@ -1499,8 +1562,9 @@ void scopes_update(Scopes *scopes,
   scopes->sample_lines = (scopes->accuracy * 0.01f) * (scopes->accuracy * 0.01f) * ibuf->y;
   CLAMP_MIN(scopes->sample_lines, 1);
 
-  if (scopes->sample_full)
+  if (scopes->sample_full) {
     scopes->sample_lines = ibuf->y;
+  }
 
   /* scan the image */
   for (a = 0; a < 3; a++) {
@@ -1510,14 +1574,18 @@ void scopes_update(Scopes *scopes,
 
   scopes->waveform_tot = ibuf->x * scopes->sample_lines;
 
-  if (scopes->waveform_1)
+  if (scopes->waveform_1) {
     MEM_freeN(scopes->waveform_1);
-  if (scopes->waveform_2)
+  }
+  if (scopes->waveform_2) {
     MEM_freeN(scopes->waveform_2);
-  if (scopes->waveform_3)
+  }
+  if (scopes->waveform_3) {
     MEM_freeN(scopes->waveform_3);
-  if (scopes->vecscope)
+  }
+  if (scopes->vecscope) {
     MEM_freeN(scopes->vecscope);
+  }
 
   scopes->waveform_1 = MEM_callocN(scopes->waveform_tot * 2 * sizeof(float),
                                    "waveform point channel 1");
@@ -1563,16 +1631,21 @@ void scopes_update(Scopes *scopes,
   /* convert hist data to float (proportional to max count) */
   nl = na = nr = nb = ng = 0;
   for (a = 0; a < 256; a++) {
-    if (bin_lum[a] > nl)
+    if (bin_lum[a] > nl) {
       nl = bin_lum[a];
-    if (bin_r[a] > nr)
+    }
+    if (bin_r[a] > nr) {
       nr = bin_r[a];
-    if (bin_g[a] > ng)
+    }
+    if (bin_g[a] > ng) {
       ng = bin_g[a];
-    if (bin_b[a] > nb)
+    }
+    if (bin_b[a] > nb) {
       nb = bin_b[a];
-    if (bin_a[a] > na)
+    }
+    if (bin_a[a] > na) {
       na = bin_a[a];
+    }
   }
   divl = nl ? 1.0 / (double)nl : 1.0;
   diva = na ? 1.0 / (double)na : 1.0;
@@ -1588,10 +1661,12 @@ void scopes_update(Scopes *scopes,
     scopes->hist.data_a[a] = bin_a[a] * diva;
   }
 
-  if (cm_processor)
+  if (cm_processor) {
     IMB_colormanagement_processor_free(cm_processor);
-  if (cache_handle)
+  }
+  if (cache_handle) {
     IMB_display_buffer_release(cache_handle);
+  }
 
   scopes->ok = 1;
 }
@@ -1691,16 +1766,19 @@ void BKE_color_managed_view_settings_copy(ColorManagedViewSettings *new_settings
   new_settings->exposure = settings->exposure;
   new_settings->gamma = settings->gamma;
 
-  if (settings->curve_mapping)
+  if (settings->curve_mapping) {
     new_settings->curve_mapping = curvemapping_copy(settings->curve_mapping);
-  else
+  }
+  else {
     new_settings->curve_mapping = NULL;
+  }
 }
 
 void BKE_color_managed_view_settings_free(ColorManagedViewSettings *settings)
 {
-  if (settings->curve_mapping)
+  if (settings->curve_mapping) {
     curvemapping_free(settings->curve_mapping);
+  }
 }
 
 void BKE_color_managed_colorspace_settings_init(
index 1ceaf8f..d6b6812 100644 (file)
@@ -156,8 +156,9 @@ bConstraintOb *BKE_constraints_make_evalob(
         }
         copy_m4_m4(cob->matrix, ob->obmat);
       }
-      else
+      else {
         unit_m4(cob->matrix);
+      }
 
       copy_m4_m4(cob->startmat, cob->matrix);
       break;
@@ -181,8 +182,9 @@ bConstraintOb *BKE_constraints_make_evalob(
         /* matrix in world-space */
         mul_m4_m4m4(cob->matrix, ob->obmat, cob->pchan->pose_mat);
       }
-      else
+      else {
         unit_m4(cob->matrix);
+      }
 
       copy_m4_m4(cob->startmat, cob->matrix);
       break;
@@ -202,8 +204,9 @@ void BKE_constraints_clear_evalob(bConstraintOb *cob)
   float delta[4][4], imat[4][4];
 
   /* prevent crashes */
-  if (cob == NULL)
+  if (cob == NULL) {
     return;
+  }
 
   /* calculate delta of constraints evaluation */
   invert_m4_m4(imat, cob->startmat);
@@ -256,11 +259,13 @@ void BKE_constraint_mat_convertspace(
   float imat[4][4];
 
   /* prevent crashes in these unlikely events  */
-  if (ob == NULL || mat == NULL)
+  if (ob == NULL || mat == NULL) {
     return;
+  }
   /* optimize trick - check if need to do anything */
-  if (from == to)
+  if (from == to) {
     return;
+  }
 
   /* are we dealing with pose-channels or objects */
   if (pchan) {
@@ -513,10 +518,12 @@ static void contarget_get_lattice_mat(Object *ob, const char *substring, float m
   copy_m4_m4(mat, ob->obmat);
 
   /* get index of vertex group */
-  if (defgroup == -1)
+  if (defgroup == -1) {
     return;
-  if (dv == NULL)
+  }
+  if (dv == NULL) {
     return;
+  }
 
   /* 1. Loop through control-points checking if in nominated vertex-group.
    * 2. If it is, add it to vec to find the average point.
@@ -534,15 +541,18 @@ static void contarget_get_lattice_mat(Object *ob, const char *substring, float m
     }
 
     /* advance pointer to coordinate data */
-    if (co)
+    if (co) {
       co += 3;
-    else
+    }
+    else {
       bp++;
+    }
   }
 
   /* find average location, then multiply by ob->obmat to find world-space location */
-  if (grouped)
+  if (grouped) {
     mul_v3_fl(vec, 1.0f / grouped);
+  }
   mul_v3_m4v3(tvec, ob->obmat, vec);
 
   /* copy new location to matrix */
@@ -638,8 +648,9 @@ static void constraint_target_to_mat4(Object *ob,
         mul_m4_m4m4(mat, ob->obmat, tempmat);
       }
     }
-    else
+    else {
       copy_m4_m4(mat, ob->obmat);
+    }
 
     /* convert matrix space as required */
     BKE_constraint_mat_convertspace(ob, pchan, mat, from, to, false);
@@ -689,7 +700,7 @@ static void default_get_tarmat(struct Depsgraph *UNUSED(depsgraph),
                                bConstraintTarget *ct,
                                float UNUSED(ctime))
 {
-  if (VALID_CONS_TARGET(ct))
+  if (VALID_CONS_TARGET(ct)) {
     constraint_target_to_mat4(ct->tar,
                               ct->subtarget,
                               ct->matrix,
@@ -697,8 +708,10 @@ static void default_get_tarmat(struct Depsgraph *UNUSED(depsgraph),
                               ct->space,
                               con->flag,
                               con->headtail);
-  else if (ct)
+  }
+  else if (ct) {
     unit_m4(ct->matrix);
+  }
 }
 
 /* This is a variant that extracts full transformation from B-Bone segments.
@@ -709,7 +722,7 @@ static void default_get_tarmat_full_bbone(struct Depsgraph *UNUSED(depsgraph),
                                           bConstraintTarget *ct,
                                           float UNUSED(ctime))
 {
-  if (VALID_CONS_TARGET(ct))
+  if (VALID_CONS_TARGET(ct)) {
     constraint_target_to_mat4(ct->tar,
                               ct->subtarget,
                               ct->matrix,
@@ -717,8 +730,10 @@ static void default_get_tarmat_full_bbone(struct Depsgraph *UNUSED(depsgraph),
                               ct->space,
                               con->flag | CONSTRAINT_BBONE_SHAPE_FULL,
                               con->headtail);
-  else if (ct)
+  }
+  else if (ct) {
     unit_m4(ct->matrix);
+  }
 }
 
 /* This following macro should be used for all standard single-target *_get_tars functions
@@ -905,24 +920,33 @@ static void childof_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *tar
       mat4_to_size(sizo, invmat);
 
       /* disable channels not enabled */
-      if (!(data->flag & CHILDOF_LOCX))
+      if (!(data->flag & CHILDOF_LOCX)) {
         loc[0] = loco[0] = 0.0f;
-      if (!(data->flag & CHILDOF_LOCY))
+      }
+      if (!(data->flag & CHILDOF_LOCY)) {
         loc[1] = loco[1] = 0.0f;
-      if (!(data->flag & CHILDOF_LOCZ))
+      }
+      if (!(data->flag & CHILDOF_LOCZ)) {
         loc[2] = loco[2] = 0.0f;
-      if (!(data->flag & CHILDOF_ROTX))
+      }
+      if (!(data->flag & CHILDOF_ROTX)) {
         eul[0] = eulo[0] = 0.0f;
-      if (!(data->flag & CHILDOF_ROTY))
+      }
+      if (!(data->flag & CHILDOF_ROTY)) {
         eul[1] = eulo[1] = 0.0f;
-      if (!(data->flag & CHILDOF_ROTZ))
+      }
+      if (!(data->flag & CHILDOF_ROTZ)) {
         eul[2] = eulo[2] = 0.0f;
-      if (!(data->flag & CHILDOF_SIZEX))
+      }
+      if (!(data->flag & CHILDOF_SIZEX)) {
         size[0] = sizo[0] = 1.0f;
-      if (!(data->flag & CHILDOF_SIZEY))
+      }
+      if (!(data->flag & CHILDOF_SIZEY)) {
         size[1] = sizo[1] = 1.0f;
-      if (!(data->flag & CHILDOF_SIZEZ))
+      }
+      if (!(data->flag & CHILDOF_SIZEZ)) {
         size[2] = sizo[2] = 1.0f;
+      }
 
       /* make new target mat and offset mat */
       loc_eulO_size_to_mat4(ct->matrix, loc, eul, size, ct->rotOrder);
@@ -942,12 +966,15 @@ static void childof_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *tar
       /* without this, changes to scale and rotation can change location
        * of a parentless bone or a disconnected bone. Even though its set
        * to zero above. */
-      if (!(data->flag & CHILDOF_LOCX))
+      if (!(data->flag & CHILDOF_LOCX)) {
         cob->matrix[3][0] = tempmat[3][0];
-      if (!(data->flag & CHILDOF_LOCY))
+      }
+      if (!(data->flag & CHILDOF_LOCY)) {
         cob->matrix[3][1] = tempmat[3][1];
-      if (!(data->flag & CHILDOF_LOCZ))
+      }
+      if (!(data->flag & CHILDOF_LOCZ)) {
         cob->matrix[3][2] = tempmat[3][2];
+      }
     }
   }
 }
@@ -1047,10 +1074,12 @@ static void vectomat(const float vec[3],
     n[1] = 0.0f;
     n[2] = 1.0f;
   }
-  if (axis > 2)
+  if (axis > 2) {
     axis -= 3;
-  else
+  }
+  else {
     negate_v3(n);
+  }
 
   /* n specifies the transformation of the track axis */
   if (flags & TARGET_Z_UP) {
@@ -1210,7 +1239,7 @@ static void kinematic_get_tarmat(struct Depsgraph *UNUSED(depsgraph),
 {
   bKinematicConstraint *data = con->data;
 
-  if (VALID_CONS_TARGET(ct))
+  if (VALID_CONS_TARGET(ct)) {
     constraint_target_to_mat4(ct->tar,
                               ct->subtarget,
                               ct->matrix,
@@ -1218,6 +1247,7 @@ static void kinematic_get_tarmat(struct Depsgraph *UNUSED(depsgraph),
                               ct->space,
                               con->flag,
                               con->headtail);
+  }
   else if (ct) {
     if (data->flag & CONSTRAINT_IK_AUTO) {
       Object *ob = cob->ob;
@@ -1233,8 +1263,9 @@ static void kinematic_get_tarmat(struct Depsgraph *UNUSED(depsgraph),
         copy_v3_v3(ct->matrix[3], vec);
       }
     }
-    else
+    else {
       unit_m4(ct->matrix);
+    }
   }
 }
 
@@ -1379,8 +1410,9 @@ static void followpath_get_tarmat(struct Depsgraph *UNUSED(depsgraph),
       }
     }
   }
-  else if (ct)
+  else if (ct) {
     unit_m4(ct->matrix);
+  }
 }
 
 static void followpath_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets)
@@ -1410,12 +1442,15 @@ static void followpath_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *
       float obsize[3];
 
       mat4_to_size(obsize, cob->matrix);
-      if (obsize[0])
+      if (obsize[0]) {
         mul_v3_fl(cob->matrix[0], size[0] / obsize[0]);
-      if (obsize[1])
+      }
+      if (obsize[1]) {
         mul_v3_fl(cob->matrix[1], size[1] / obsize[1]);
-      if (obsize[2])
+      }
+      if (obsize[2]) {
         mul_v3_fl(cob->matrix[2], size[2] / obsize[2]);
+      }
     }
   }
 }
@@ -1442,28 +1477,34 @@ static void loclimit_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *UN
   bLocLimitConstraint *data = con->data;
 
   if (data->flag & LIMIT_XMIN) {
-    if (cob->matrix[3][0] < data->xmin)
+    if (cob->matrix[3][0] < data->xmin) {
       cob->matrix[3][0] = data->xmin;
+    }
   }
   if (data->flag & LIMIT_XMAX) {
-    if (cob->matrix[3][0] > data->xmax)
+    if (cob->matrix[3][0] > data->xmax) {
       cob->matrix[3][0] = data->xmax;
+    }
   }
   if (data->flag & LIMIT_YMIN) {
-    if (cob->matrix[3][1] < data->ymin)
+    if (cob->matrix[3][1] < data->ymin) {
       cob->matrix[3][1] = data->ymin;
+    }
   }
   if (data->flag & LIMIT_YMAX) {
-    if (cob->matrix[3][1] > data->ymax)
+    if (cob->matrix[3][1] > data->ymax) {
       cob->matrix[3][1] = data->ymax;
+    }
   }
   if (data->flag & LIMIT_ZMIN) {
-    if (cob->matrix[3][2] < data->zmin)
+    if (cob->matrix[3][2] < data->zmin) {
       cob->matrix[3][2] = data->zmin;
+    }
   }
   if (data->flag & LIMIT_ZMAX) {
-    if (cob->matrix[3][2] > data->zmax)
+    if (cob->matrix[3][2] > data->zmax) {
       cob->matrix[3][2] = data->zmax;
+    }
   }
 }
 
@@ -1500,25 +1541,31 @@ static void rotlimit_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *UN
 
   /* limiting of euler values... */
   if (data->flag & LIMIT_XROT) {
-    if (eul[0] < data->xmin)
+    if (eul[0] < data->xmin) {
       eul[0] = data->xmin;
+    }
 
-    if (eul[0] > data->xmax)
+    if (eul[0] > data->xmax) {
       eul[0] = data->xmax;
+    }
   }
   if (data->flag & LIMIT_YROT) {
-    if (eul[1] < data->ymin)
+    if (eul[1] < data->ymin) {
       eul[1] = data->ymin;
+    }
 
-    if (eul[1] > data->ymax)
+    if (eul[1] > data->ymax) {
       eul[1] = data->ymax;
+    }
   }
   if (data->flag & LIMIT_ZROT) {
-    if (eul[2] < data->zmin)
+    if (eul[2] < data->zmin) {
       eul[2] = data->zmin;
+    }
 
-    if (eul[2] > data->zmax)
+    if (eul[2] > data->zmax) {
       eul[2] = data->zmax;
+    }
   }
 
   loc_eulO_size_to_mat4(cob->matrix, loc, eul, size, cob->rotOrder);
@@ -1550,36 +1597,45 @@ static void sizelimit_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *U
   mat4_to_size(obsize, cob->matrix);
 
   if (data->flag & LIMIT_XMIN) {
-    if (size[0] < data->xmin)
+    if (size[0] < data->xmin) {
       size[0] = data->xmin;
+    }
   }
   if (data->flag & LIMIT_XMAX) {
-    if (size[0] > data->xmax)
+    if (size[0] > data->xmax) {
       size[0] = data->xmax;
+    }
   }
   if (data->flag & LIMIT_YMIN) {
-    if (size[1] < data->ymin)
+    if (size[1] < data->ymin) {
       size[1] = data->ymin;
+    }
   }
   if (data->flag & LIMIT_YMAX) {
-    if (size[1] > data->ymax)
+    if (size[1] > data->ymax) {
       size[1] = data->ymax;
+    }
   }
   if (data->flag & LIMIT_ZMIN) {
-    if (size[2] < data->zmin)
+    if (size[2] < data->zmin) {
       size[2] = data->zmin;
+    }
   }
   if (data->flag & LIMIT_ZMAX) {
-    if (size[2] > data->zmax)
+    if (size[2] > data->zmax) {
       size[2] = data->zmax;
+    }
   }
 
-  if (obsize[0])
+  if (obsize[0]) {
     mul_v3_fl(cob->matrix[0], size[0] / obsize[0]);
-  if (obsize[1])
+  }
+  if (obsize[1]) {
     mul_v3_fl(cob->matrix[1], size[1] / obsize[1]);
-  if (obsize[2])
+  }
+  if (obsize[2]) {
     mul_v3_fl(cob->matrix[2], size[2] / obsize[2]);
+  }
 }
 
 static bConstraintTypeInfo CTI_SIZELIMIT = {
@@ -1648,28 +1704,32 @@ static void loclike_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *tar
   if (VALID_CONS_TARGET(ct)) {
     float offset[3] = {0.0f, 0.0f, 0.0f};
 
-    if (data->flag & LOCLIKE_OFFSET)
+    if (data->flag & LOCLIKE_OFFSET) {
       copy_v3_v3(offset, cob->matrix[3]);
+    }
 
     if (data->flag & LOCLIKE_X) {
       cob->matrix[3][0] = ct->matrix[3][0];
 
-      if (data->flag & LOCLIKE_X_INVERT)
+      if (data->flag & LOCLIKE_X_INVERT) {
         cob->matrix[3][0] *= -1;
+      }
       cob->matrix[3][0] += offset[0];
     }
     if (data->flag & LOCLIKE_Y) {
       cob->matrix[3][1] = ct->matrix[3][1];
 
-      if (data->flag & LOCLIKE_Y_INVERT)
+      if (data->flag & LOCLIKE_Y_INVERT) {
         cob->matrix[3][1] *= -1;
+      }
       cob->matrix[3][1] += offset[1];
     }
     if (data->flag & LOCLIKE_Z) {
       cob->matrix[3][2] = ct->matrix[3][2];
 
-      if (data->flag & LOCLIKE_Z_INVERT)
+      if (data->flag & LOCLIKE_Z_INVERT) {
         cob->matrix[3][2] *= -1;
+      }
       cob->matrix[3][2] += offset[2];
     }
   }
@@ -1751,34 +1811,43 @@ static void rotlike_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *tar
     /* we must get compatible eulers from the beginning because some of them can be modified below (see bug #21875) */
     mat4_to_compatible_eulO(eul, obeul, cob->rotOrder, ct->matrix);
 
-    if ((data->flag & ROTLIKE_X) == 0)
+    if ((data->flag & ROTLIKE_X) == 0) {
       eul[0] = obeul[0];
+    }
     else {
-      if (data->flag & ROTLIKE_OFFSET)
+      if (data->flag & ROTLIKE_OFFSET) {
         rotate_eulO(eul, cob->rotOrder, 'X', obeul[0]);
+      }
 
-      if (data->flag & ROTLIKE_X_INVERT)
+      if (data->flag & ROTLIKE_X_INVERT) {
         eul[0] *= -1;
+      }
     }
 
-    if ((data->flag & ROTLIKE_Y) == 0)
+    if ((data->flag & ROTLIKE_Y) == 0) {
       eul[1] = obeul[1];
+    }
     else {
-      if (data->flag & ROTLIKE_OFFSET)
+      if (data->flag & ROTLIKE_OFFSET) {
         rotate_eulO(eul, cob->rotOrder, 'Y', obeul[1]);
+      }
 
-      if (data->flag & ROTLIKE_Y_INVERT)
+      if (data->flag & ROTLIKE_Y_INVERT) {
         eul[1] *= -1;
+      }
     }
 
-    if ((data->flag & ROTLIKE_Z) == 0)
+    if ((data->flag & ROTLIKE_Z) == 0) {
       eul[2] = obeul[2];
+    }
     else {
-      if (data->flag & ROTLIKE_OFFSET)
+      if (data->flag & ROTLIKE_OFFSET) {
         rotate_eulO(eul, cob->rotOrder, 'Z', obeul[2]);
+      }
 
-      if (data->flag & ROTLIKE_Z_INVERT)
+      if (data->flag & ROTLIKE_Z_INVERT) {
         eul[2] *= -1;
+      }
     }
 
     /* good to make eulers compatible again, since we don't know how much they were changed above */
@@ -1980,8 +2049,9 @@ static void samevolume_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *
 
   /* calculate normalizing scale factor for non-essential values */
   total_scale = obsize[0] * obsize[1] * obsize[2];
-  if (total_scale != 0)
+  if (total_scale != 0) {
     fac = sqrtf(volume / total_scale);
+  }
 
   /* apply scaling factor to the channels not being kept */
   switch (data->flag) {
@@ -2067,8 +2137,9 @@ static void pycon_id_looper(bConstraint *con, ConstraintIDFunc func, void *userd
   bConstraintTarget *ct;
 
   /* targets */
-  for (ct = data->targets.first; ct; ct = ct->next)
+  for (ct = data->targets.first; ct; ct = ct->next) {
     func(con, (ID **)&ct->tar, false, userdata);
+  }
 
   /* script */
   func(con, (ID **)&data->text, true, userdata);
@@ -2104,12 +2175,14 @@ static void pycon_get_tarmat(struct Depsgraph *UNUSED(depsgraph),
 
     /* only execute target calculation if allowed */
 #ifdef WITH_PYTHON
-    if (G.f & G_FLAG_SCRIPT_AUTOEXEC)
+    if (G.f & G_FLAG_SCRIPT_AUTOEXEC) {
       BPY_pyconstraint_target(data, ct);
+    }
 #endif
   }
-  else if (ct)
+  else if (ct) {
     unit_m4(ct->matrix);
+  }
 }
 
 static void pycon_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets)
@@ -2121,8 +2194,9 @@ static void pycon_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targe
   bPythonConstraint *data = con->data;
 
   /* only evaluate in python if we're allowed to do so */
-  if ((G.f & G_FLAG_SCRIPT_AUTOEXEC) == 0)
+  if ((G.f & G_FLAG_SCRIPT_AUTOEXEC) == 0) {
     return;
+  }
 
   /* Now, run the actual 'constraint' function, which should only access the matrices */
   BPY_pyconstraint_exec(data, cob, targets);
@@ -2215,8 +2289,9 @@ static void armdef_accumulate_matrix(float obmat[4][4],
                                      float r_sum_mat[4][4],
                                      DualQuat *r_sum_dq)
 {
-  if (weight == 0.0f)
+  if (weight == 0.0f) {
     return;
+  }
 
   /* Convert the selected matrix into object space. */
   float mat[4][4];
@@ -2479,11 +2554,12 @@ static void actcon_get_tarmat(struct Depsgraph *UNUSED(depsgraph),
     CLAMP(s, 0, 1);
     t = (s * (data->end - data->start)) + data->start;
 
-    if (G.debug & G_DEBUG)
+    if (G.debug & G_DEBUG) {
       printf("do Action Constraint %s - Ob %s Pchan %s\n",
              con->name,
              cob->ob->id.name + 2,
              (cob->pchan) ? cob->pchan->name : NULL);
+    }
 
     /* Get the appropriate information from the action */
     if (cob->type == CONSTRAINT_OBTYPE_OBJECT || (data->flag & ACTCON_BONE_USE_OBJECT_ACTION)) {
@@ -2945,8 +3021,9 @@ static void distlimit_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *t
       /* if inside, then move to surface */
       if (dist <= data->dist) {
         clamp_surf = 1;
-        if (dist != 0.0f)
+        if (dist != 0.0f) {
           sfac = data->dist / dist;
+        }
       }
       /* if soft-distance is enabled, start fading once owner is dist+softdist from the target */
       else if (data->flag & LIMITDIST_USESOFT) {
@@ -2959,8 +3036,9 @@ static void distlimit_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *t
       /* if outside, then move to surface */
       if (dist >= data->dist) {
         clamp_surf = 1;
-        if (dist != 0.0f)
+        if (dist != 0.0f) {
           sfac = data->dist / dist;
+        }
       }
       /* if soft-distance is enabled, start fading once owner is dist-soft from the target */
       else if (data->flag & LIMITDIST_USESOFT) {
@@ -2968,8 +3046,9 @@ static void distlimit_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *t
         if (dist >= (data->dist - data->soft)) {
           sfac = (float)(data->soft * (1.0f - expf(-(dist - data->dist) / data->soft)) +
                          data->dist);
-          if (dist != 0.0f)
+          if (dist != 0.0f) {
             sfac /= dist;
+          }
 
           clamp_surf = 1;
         }
@@ -2978,8 +3057,9 @@ static void distlimit_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *t
     else {
       if (IS_EQF(dist, data->dist) == 0) {
         clamp_surf = 1;
-        if (dist != 0.0f)
+        if (dist != 0.0f) {
           sfac = data->dist / dist;
+        }
       }
     }
 
@@ -3410,8 +3490,9 @@ static void clampto_get_tarmat(struct Depsgraph *UNUSED(depsgraph),
   /* technically, this isn't really needed for evaluation, but we don't know what else
    * might end up calling this...
    */
-  if (ct)
+  if (ct) {
     unit_m4(ct->matrix);
+  }
 }
 
 static void clampto_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets)
@@ -3450,15 +3531,19 @@ static void clampto_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *tar
          * extent. Otherwise, default to the x-axis, as that is quite
          * frequently used.
          */
-        if ((size[2] > size[0]) && (size[2] > size[1]))
+        if ((size[2] > size[0]) && (size[2] > size[1])) {
           clamp_axis = CLAMPTO_Z - 1;
-        else if ((size[1] > size[0]) && (size[1] > size[2]))
+        }
+        else if ((size[1] > size[0]) && (size[1] > size[2])) {
           clamp_axis = CLAMPTO_Y - 1;
-        else
+        }
+        else {
           clamp_axis = CLAMPTO_X - 1;
+        }
       }
-      else
+      else {
         clamp_axis = data->flag - 1;
+      }
 
       /* 2. determine position relative to curve on a 0-1 scale based on bounding box */
       if (data->flag2 & CLAMPTO_CYCLIC) {
@@ -3497,15 +3582,19 @@ static void clampto_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *tar
       }
       else {
         /* no cyclic, so position is clamped to within the bounding box */
-        if (ownLoc[clamp_axis] <= curveMin[clamp_axis])
+        if (ownLoc[clamp_axis] <= curveMin[clamp_axis]) {
           curvetime = 0.0f;
-        else if (ownLoc[clamp_axis] >= curveMax[clamp_axis])
+        }
+        else if (ownLoc[clamp_axis] >= curveMax[clamp_axis]) {
           curvetime = 1.0f;
-        else if (IS_EQF((curveMax[clamp_axis] - curveMin[clamp_axis]), 0.0f) == false)
+        }
+        else if (IS_EQF((curveMax[clamp_axis] - curveMin[clamp_axis]), 0.0f) == false) {
           curvetime = (ownLoc[clamp_axis] - curveMin[clamp_axis]) /
                       (curveMax[clamp_axis] - curveMin[clamp_axis]);
-        else
+        }
+        else {
           curvetime = 0.0f;
+        }
       }
 
       /* 3. position on curve */
@@ -3631,20 +3720,24 @@ static void transform_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *t
     /* determine where in range current transforms lie */
     if (data->expo) {
       for (i = 0; i < 3; i++) {
-        if (from_max[i] - from_min[i])
+        if (from_max[i] - from_min[i]) {
           sval[i] = (dvec[i] - from_min[i]) / (from_max[i] - from_min[i]);
-        else
+        }
+        else {
           sval[i] = 0.0f;
+        }
       }
     }
     else {
       /* clamp transforms out of range */
       for (i = 0; i < 3; i++) {
         CLAMP(dvec[i], from_min[i], from_max[i]);
-        if (from_max[i] - from_min[i])
+        if (from_max[i] - from_min[i]) {
           sval[i] = (dvec[i] - from_min[i]) / (from_max[i] - from_min[i]);
-        else
+        }
+        else {
           sval[i] = 0.0f;
+        }
       }
     }
 
@@ -4101,8 +4194,9 @@ static void splineik_free(bConstraint *con)
   bSplineIKConstraint *data = con->data;
 
   /* binding array */
-  if (data->points)
+  if (data->points) {
     MEM_freeN(data->points);
+  }
 }
 
 static void splineik_copy(bConstraint *con, bConstraint *srccon)
@@ -4169,8 +4263,9 @@ static void splineik_get_tarmat(struct Depsgraph *UNUSED(depsgraph),
   /* technically, this isn't really needed for evaluation, but we don't know what else
    * might end up calling this...
    */
-  if (ct)
+  if (ct) {
     unit_m4(ct->matrix);
+  }
 }
 
 static bConstraintTypeInfo CTI_SPLINEIK = {
@@ -4245,13 +4340,15 @@ static void pivotcon_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *ta
     /* check which range might be violated */
     if (data->rotAxis < PIVOTCON_AXIS_X) {
       /* negative rotations (data->rotAxis = 0 -> 2) */
-      if (rot[data->rotAxis] > 0.0f)
+      if (rot[data->rotAxis] > 0.0f) {
         return;
+      }
     }
     else {
       /* positive rotations (data->rotAxis = 3 -> 5 */
-      if (rot[data->rotAxis - PIVOTCON_AXIS_X] < 0.0f)
+      if (rot[data->rotAxis - PIVOTCON_AXIS_X] < 0.0f) {
         return;
+      }
     }
   }
 
@@ -4346,26 +4443,32 @@ static void followtrack_evaluate(bConstraint *con, bConstraintOb *cob, ListBase
   float ctime = DEG_get_ctime(depsgraph);
   float framenr;
 
-  if (data->flag & FOLLOWTRACK_ACTIVECLIP)
+  if (data->flag & FOLLOWTRACK_ACTIVECLIP) {
     clip = scene->clip;
+  }
 
-  if (!clip || !data->track[0] || !camob_eval)
+  if (!clip || !data->track[0] || !camob_eval) {
     return;
+  }
 
   tracking = &clip->tracking;
 
-  if (data->object[0])
+  if (data->object[0]) {
     tracking_object = BKE_tracking_object_get_named(tracking, data->object);
-  else
+  }
+  else {
     tracking_object = BKE_tracking_object_get_camera(tracking);
+  }
 
-  if (!tracking_object)
+  if (!tracking_object) {
     return;
+  }
 
   track = BKE_tracking_track_get_named(tracking, tracking_object, data->track);
 
-  if (!track)
+  if (!track) {
     return;
+  }
 
   framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, ctime);
 
@@ -4477,10 +4580,12 @@ static void followtrack_evaluate(bConstraint *con, bConstraintOb *cob, ListBase
         vec[1] = params.ortho_scale * (pos[1] - 0.5f + params.shifty);
         vec[2] = -len;
 
-        if (aspect > 1.0f)
+        if (aspect > 1.0f) {
           vec[1] /= aspect;
-        else
+        }
+        else {
           vec[0] *= aspect;
+        }
 
         mul_v3_m4v3(disp, camob_eval->obmat, vec);
 
@@ -4497,10 +4602,12 @@ static void followtrack_evaluate(bConstraint *con, bConstraintOb *cob, ListBase
         vec[1] = d * (2.0f * (pos[1] + params.shifty) - 1.0f);
         vec[2] = -len;
 
-        if (aspect > 1.0f)
+        if (aspect > 1.0f) {
           vec[1] /= aspect;
-        else
+        }
+        else {
           vec[0] *= aspect;
+        }
 
         mul_v3_m4v3(disp, camob_eval->obmat, vec);
 
@@ -4587,8 +4694,9 @@ static void camerasolver_evaluate(bConstraint *con, bConstraintOb *cob, ListBase
   bCameraSolverConstraint *data = con->data;
   MovieClip *clip = data->clip;
 
-  if (data->flag & CAMERASOLVER_ACTIVECLIP)
+  if (data->flag & CAMERASOLVER_ACTIVECLIP) {
     clip = scene->clip;
+  }
 
   if (clip) {
     float mat[4][4], obmat[4][4];
@@ -4647,11 +4755,13 @@ static void objectsolver_evaluate(bConstraint *con, bConstraintOb *cob, ListBase
   MovieClip *clip = data->clip;
   Object *camob = data->camera ? data->camera : scene->camera;
 
-  if (data->flag & OBJECTSOLVER_ACTIVECLIP)
+  if (data->flag & OBJECTSOLVER_ACTIVECLIP) {
     clip = scene->clip;
+  }
 
-  if (!camob || !clip)
+  if (!camob || !clip) {
     return;
+  }
 
   if (clip) {
     MovieTracking *tracking = &clip->tracking;
@@ -4859,10 +4969,12 @@ const bConstraintTypeInfo *BKE_constraint_typeinfo_from_type(int type)
 const bConstraintTypeInfo *BKE_constraint_typeinfo_get(bConstraint *con)
 {
   /* only return typeinfo for valid constraints */
-  if (con)
+  if (con) {
     return BKE_constraint_typeinfo_from_type(con->type);
-  else
+  }
+  else {
     return NULL;
+  }
 }
 
 /* ************************* General Constraints API ************************** */
@@ -4880,8 +4992,9 @@ static void con_unlink_refs_cb(bConstraint *UNUSED(con),
                                bool is_reference,
                                void *UNUSED(userData))
 {
-  if (*idpoin && is_reference)
+  if (*idpoin && is_reference) {
     id_us_min(*idpoin);
+  }
 }
 
 /**
@@ -4896,12 +5009,14 @@ void BKE_constraint_free_data_ex(bConstraint *con, bool do_id_user)
 
     if (cti) {
       /* perform any special freeing constraint may have */
-      if (cti->free_data)
+      if (cti->free_data) {
         cti->free_data(con);
+      }
 
       /* unlink the referenced resources it uses */
-      if (do_id_user && cti->id_looper)
+      if (do_id_user && cti->id_looper) {
         cti->id_looper(con, con_unlink_refs_cb, NULL);
+      }
     }
 
     /* free constraint data now */
@@ -4920,8 +5035,9 @@ void BKE_constraints_free_ex(ListBase *list, bool do_id_user)
   bConstraint *con;
 
   /* Free constraint data and also any extra data */
-  for (con = list->first; con; con = con->next)
+  for (con = list->first; con; con = con->next) {
     BKE_constraint_free_data_ex(con, do_id_user);
+  }
 
   /* Free the whole list */
   BLI_freelistN(list);
@@ -4980,8 +5096,9 @@ static bConstraint *add_new_constraint_internal(const char *name, short type)
     con->data = MEM_callocN(cti->size, cti->structName);
 
     /* only constraints that change any settings need this */
-    if (cti->new_data)
+    if (cti->new_data) {
       cti->new_data(con->data);
+    }
 
     /* if no name is provided, use the type of the constraint as the name */
     newName = (name && name[0]) ? name : DATA_(cti->name);
@@ -5025,8 +5142,9 @@ static bConstraint *add_new_constraint(Object *ob,
      * Armature layer, we must tag newly added constraints with a flag which allows them
      * to persist after proxy syncing has been done
      */
-    if (BKE_constraints_proxylocked_owner(ob, pchan))
+    if (BKE_constraints_proxylocked_owner(ob, pchan)) {
       con->flag |= CONSTRAINT_PROXY_LOCAL;
+    }
 
     /* make this constraint the active one */
     BKE_constraints_active_set(list, con);
@@ -5063,8 +5181,9 @@ bConstraint *BKE_constraint_add_for_pose(Object *ob,
                                          const char *name,
                                          short type)
 {
-  if (pchan == NULL)
+  if (pchan == NULL) {
     return NULL;
+  }
 
   return add_new_constraint(ob, pchan, name, type);
 }
@@ -5086,8 +5205,9 @@ void BKE_constraints_id_loop(ListBase *conlist, ConstraintIDFunc func, void *use
     const bConstraintTypeInfo *cti = BKE_constraint_typeinfo_get(con);
 
     if (cti) {
-      if (cti->id_looper)
+      if (cti->id_looper) {
         cti->id_looper(con, func, userdata);
+      }
     }
   }
 }
@@ -5100,8 +5220,9 @@ static void con_extern_cb(bConstraint *UNUSED(con),
                           bool UNUSED(is_reference),
                           void *UNUSED(userData))
 {
-  if (*idpoin && ID_IS_LINKED(*idpoin))
+  if (*idpoin && ID_IS_LINKED(*idpoin)) {
     id_lib_extern(*idpoin);
+  }
 }
 
 /* helper for BKE_constraints_copy(), to be used for making sure that usercounts of copied ID's are fixed up */
@@ -5111,8 +5232,9 @@ static void con_fix_copied_refs_cb(bConstraint *UNUSED(con),
                                    void *UNUSED(userData))
 {
   /* increment usercount if this is a reference type */
-  if ((*idpoin) && (is_reference))
+  if ((*idpoin) && (is_reference)) {
     id_us_plus(*idpoin);
+  }
 }
 
 /** Copies a single constraint's data (\a dst must already be a shallow copy of \a src). */
@@ -5129,8 +5251,9 @@ static void constraint_copy_data_ex(bConstraint *dst,
   /* only do specific constraints if required */
   if (cti) {
     /* perform custom copying operations if needed */
-    if (cti->copy_data)
+    if (cti->copy_data) {
       cti->copy_data(dst, src);
+    }
 
     /* Fix usercounts for all referenced data that need it. */
     if (cti->id_looper && (flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
@@ -5140,8 +5263,9 @@ static void constraint_copy_data_ex(bConstraint *dst,
     /* for proxies we don't want to make extern */
     if (do_extern) {
       /* go over used ID-links for this constraint to ensure that they are valid for proxies */
-      if (cti->id_looper)
+      if (cti->id_looper) {
         cti->id_looper(dst, con_extern_cb, NULL);
+      }
     }
   }
 }
@@ -5189,8 +5313,9 @@ bConstraint *BKE_constraints_active_get(ListBase *list)
   /* search for the first constraint with the 'active' flag set */
   if (list) {
     for (con = list->first; con; con = con->next) {
-      if (con->flag & CONSTRAINT_ACTIVE)
+      if (con->flag & CONSTRAINT_ACTIVE) {
         return con;
+      }
     }
   }
 
@@ -5205,10 +5330,12 @@ void BKE_constraints_active_set(ListBase *list, bConstraint *con)
 
   if (list) {
     for (c = list->first; c; c = c->next) {
-      if (c == con)
+      if (c == con) {
         c->flag |= CONSTRAINT_ACTIVE;
-      else
+      }
+      else {
         c->flag &= ~CONSTRAINT_ACTIVE;
+      }
     }
   }
 }
@@ -5359,8 +5486,9 @@ bool BKE_constraints_proxylocked_owner(Object *ob, bPoseChannel *pchan)
       bArmature *arm = ob->data;
 
       /* On bone-level, check if bone is on proxy-protected layer */
-      if ((pchan->bone) && (pchan->bone->layer & arm->layer_protected))
+      if ((pchan->bone) && (pchan->bone->layer & arm->layer_protected)) {
         return true;
+      }
     }
     else {
       /* FIXME: constraints on object-level are not handled well yet */
@@ -5438,14 +5566,16 @@ void BKE_constraint_target_matrix_get(struct Depsgraph *depsgraph,
     ct = BLI_findlink(&targets, index);
 
     if (ct) {
-      if (cti->get_target_matrix)
+      if (cti->get_target_matrix) {
         cti->get_target_matrix(depsgraph, con, cob, ct, ctime);
+      }
       copy_m4_m4(mat, ct->matrix);
     }
 
     /* free targets + 'constraint-ob' */
-    if (cti->flush_constraint_targets)
+    if (cti->flush_constraint_targets) {
       cti->flush_constraint_targets(con, &targets, 1);
+    }
     MEM_freeN(cob);
   }
   else {
@@ -5476,12 +5606,14 @@ void BKE_constraint_targets_for_solving_get(struct Depsgraph *depsgraph,
      * - calculate if possible, otherwise just initialize as identity matrix
      */
     if (cti->get_target_matrix) {
-      for (ct = targets->first; ct; ct = ct->next)
+      for (ct = targets->first; ct; ct = ct->next) {
         cti->get_target_matrix(depsgraph, con, cob, ct, ctime);
+      }
     }
     else {
-      for (ct = targets->first; ct; ct = ct->next)
+      for (ct = targets->first; ct; ct = ct->next) {
         unit_m4(ct->matrix);
+      }
     }
   }
 }
@@ -5504,8 +5636,9 @@ void BKE_constraints_solve(struct Depsgraph *depsgraph,
   float enf;
 
   /* check that there is a valid constraint object to evaluate */
-  if (cob == NULL)
+  if (cob == NULL) {
     return;
+  }
 
   /* loop over available constraints, solving and blending them */
   for (con = conlist->first; con; con = con->next) {
@@ -5513,16 +5646,20 @@ void BKE_constraints_solve(struct Depsgraph *depsgraph,
     ListBase targets = {NULL, NULL};
 
     /* these we can skip completely (invalid constraints...) */
-    if (cti == NULL)
+    if (cti == NULL) {
       continue;
-    if (con->flag & (CONSTRAINT_DISABLE | CONSTRAINT_OFF))
+    }
+    if (con->flag & (CONSTRAINT_DISABLE | CONSTRAINT_OFF)) {
       continue;
+    }
     /* these constraints can't be evaluated anyway */
-    if (cti->evaluate_constraint == NULL)
+    if (cti->evaluate_constraint == NULL) {
       continue;
+    }
     /* influence == 0 should be ignored */
-    if (con->enforce == 0.0f)
+    if (con->enforce == 0.0f) {
       continue;
+    }
 
     /* influence of constraint
      * - value should have been set from animation data already
@@ -5551,9 +5688,10 @@ void BKE_constraints_solve(struct Depsgraph *depsgraph,
     }
 
     /* move owner back into worldspace for next constraint/other business */
-    if ((con->flag & CONSTRAINT_SPACEONCE) == 0)
+    if ((con->flag & CONSTRAINT_SPACEONCE) == 0) {
       BKE_constraint_mat_convertspace(
           cob->ob, cob->pchan, cob->matrix, con->ownspace, CONSTRAINT_SPACE_WORLD, false);
+    }
 
     /* Interpolate the enforcement, to blend result of constraint into final owner transform
      * - all this happens in worldspace to prevent any weirdness creeping in ([#26014] and [#25725]),
index d9ee3ab..4383b6a 100644 (file)
@@ -134,8 +134,9 @@ bContextStore *CTX_store_add(ListBase *contexts, const char *name, PointerRNA *p
       ctx = MEM_dupallocN(lastctx);
       BLI_duplicatelist(&ctx->entries, &lastctx->entries);
     }
-    else
+    else {
       ctx = MEM_callocN(sizeof(bContextStore), "bContextStore");
+    }
 
     BLI_addtail(contexts, ctx);
   }
@@ -164,8 +165,9 @@ bContextStore *CTX_store_add_all(ListBase *contexts, bContextStore *context)
       ctx = MEM_dupallocN(lastctx);
       BLI_duplicatelist(&ctx->entries, &lastctx->entries);
     }
-    else
+    else {
       ctx = MEM_callocN(sizeof(bContextStore), "bContextStore");
+    }
 
     BLI_addtail(contexts, ctx);
   }
@@ -266,8 +268,9 @@ static void *ctx_wm_python_context_get(const bContext *C,
 #endif
 
   /* don't allow UI context access from non-main threads */
-  if (!BLI_thread_is_main())
+  if (!BLI_thread_is_main()) {
     return NULL;
+  }
 
   return fall_through;
 }
@@ -290,8 +293,9 @@ static int ctx_data_get(bContext *C, const char *member, bContextDataResult *res
 #endif
 
   /* don't allow UI context access from non-main threads */
-  if (!BLI_thread_is_main())
+  if (!BLI_thread_is_main()) {
     return done;
+  }
 
   /* we check recursion to ensure that we do not get infinite
    * loops requesting data from ourselves in a context callback */
@@ -317,16 +321,18 @@ static int ctx_data_get(bContext *C, const char *member, bContextDataResult *res
     C->data.recursion = 2;
     if (ar->type && ar->type->context) {
       ret = ar->type->context(C, member, result);
-      if (ret)
+      if (ret) {
         done = -(-ret | -done);
+      }
     }
   }
   if (done != 1 && recursion < 3 && (sa = CTX_wm_area(C))) {
     C->data.recursion = 3;
     if (sa->type && sa->type->context) {
       ret = sa->type->context(C, member, result);
-      if (ret)
+      if (ret) {
         done = -(-ret | -done);
+      }
     }
   }
   if (done != 1 && recursion < 4 && (sc = CTX_wm_screen(C))) {
@@ -334,8 +340,9 @@ static int ctx_data_get(bContext *C, const char *member, bContextDataResult *res
     C->data.recursion = 4;
     if (cb) {
       ret = cb(C, member, result);
-      if (ret)
+      if (ret) {
         done = -(-ret | -done);
+      }
     }
   }
 
@@ -464,11 +471,13 @@ static void data_dir_add(ListBase *lb, const char *member, const bool use_all)
 {
   LinkData *link;
 
-  if ((use_all == false) && STREQ(member, "scene")) /* exception */
+  if ((use_all == false) && STREQ(member, "scene")) /* exception */
     return;
+  }
 
-  if (BLI_findstring(lb, member, offsetof(LinkData, data)))
+  if (BLI_findstring(lb, member, offsetof(LinkData, data))) {
     return;
+  }
 
   link = MEM_callocN(sizeof(LinkData), "LinkData");
   link->data = (void *)member;
@@ -519,33 +528,40 @@ ListBase CTX_data_dir_get_ex(const bContext *C,
   if (use_store && C->wm.store) {
     bContextStoreEntry *entry;
 
-    for (entry = C->wm.store->entries.first; entry; entry = entry->next)
+    for (entry = C->wm.store->entries.first; entry; entry = entry->next) {
       data_dir_add(&lb, entry->name, use_all);
+    }
   }
   if ((ar = CTX_wm_region(C)) && ar->type && ar->type->context) {
     memset(&result, 0, sizeof(result));
     ar->type->context(C, "", &result);
 
-    if (result.dir)
-      for (a = 0; result.dir[a]; a++)
+    if (result.dir) {
+      for (a = 0; result.dir[a]; a++) {
         data_dir_add(&lb, result.dir[a], use_all);
+      }
+    }
   }
   if ((sa = CTX_wm_area(C)) && sa->type && sa->type->context) {
     memset(&result, 0, sizeof(result));
     sa->type->context(C, "", &result);
 
-    if (result.dir)
-      for (a = 0; result.dir[a]; a++)
+    if (result.dir) {
+      for (a = 0; result.dir[a]; a++) {
         data_dir_add(&lb, result.dir[a], use_all);
+      }
+    }
   }
   if ((sc = CTX_wm_screen(C)) && sc->context) {
     bContextDataCallback cb = sc->context;
     memset(&result, 0, sizeof(result));
     cb(C, "", &result);
 
-    if (result.dir)
-      for (a = 0; result.dir[a]; a++)
+    if (result.dir) {
+      for (a = 0; result.dir[a]; a++) {
         data_dir_add(&lb, result.dir[a], use_all);
+      }
+    }
   }
 
   return lb;
@@ -605,8 +621,9 @@ int ctx_data_list_count(const bContext *C, int (*func)(const bContext *, ListBas
     BLI_freelistN(&list);
     return tot;
   }
-  else
+  else {
     return 0;
+  }
 }
 
 void CTX_data_dir_set(bContextDataResult *result, const char **dir)
@@ -685,8 +702,9 @@ struct wmMsgBus *CTX_wm_message_bus(const bContext *C)
 
 struct ReportList *CTX_wm_reports(const bContext *C)
 {
-  if (C->wm.manager)
+  if (C->wm.manager) {
     return &(C->wm.manager->reports);
+  }
 
   return NULL;
 }
@@ -694,8 +712,9 @@ struct ReportList *CTX_wm_reports(const bContext *C)
 View3D *CTX_wm_view3d(const bContext *C)
 {
   ScrArea *sa = CTX_wm_area(C);
-  if (sa && sa->spacetype == SPACE_VIEW3D)
+  if (sa && sa->spacetype == SPACE_VIEW3D) {
     return sa->spacedata.first;
+  }
   return NULL;
 }
 
@@ -704,129 +723,146 @@ RegionView3D *CTX_wm_region_view3d(const bContext *C)
   ScrArea *sa = CTX_wm_area(C);
   ARegion *ar = CTX_wm_region(C);
 
-  if (sa && sa->spacetype == SPACE_VIEW3D)
-    if (ar)
+  if (sa && sa->spacetype == SPACE_VIEW3D) {
+    if (ar) {
       return ar->regiondata;
+    }
+  }
   return NULL;
 }
 
 struct SpaceText *CTX_wm_space_text(const bContext *C)
 {
   ScrArea *sa = CTX_wm_area(C);
-  if (sa && sa->spacetype == SPACE_TEXT)
+  if (sa && sa->spacetype == SPACE_TEXT) {
     return sa->spacedata.first;
+  }
   return NULL;
 }
 
 struct SpaceConsole *CTX_wm_space_console(const bContext *C)
 {
   ScrArea *sa = CTX_wm_area(C);
-  if (sa && sa->spacetype == SPACE_CONSOLE)
+  if (sa && sa->spacetype == SPACE_CONSOLE) {
     return sa->spacedata.first;
+  }
   return NULL;
 }
 
 struct SpaceImage *CTX_wm_space_image(const bContext *C)
 {
   ScrArea *sa = CTX_wm_area(C);
-  if (sa && sa->spacetype == SPACE_IMAGE)
+  if (sa && sa->spacetype == SPACE_IMAGE) {
     return sa->spacedata.first;
+  }
   return NULL;
 }
 
 struct SpaceProperties *CTX_wm_space_properties(const bContext *C)
 {
   ScrArea *sa = CTX_wm_area(C);
-  if (sa && sa->spacetype == SPACE_PROPERTIES)
+  if (sa && sa->spacetype == SPACE_PROPERTIES) {
     return sa->spacedata.first;
+  }
   return NULL;
 }
 
 struct SpaceFile *CTX_wm_space_file(const bContext *C)
 {
   ScrArea *sa = CTX_wm_area(C);
-  if (sa && sa->spacetype == SPACE_FILE)
+  if (sa && sa->spacetype == SPACE_FILE) {
     return sa->spacedata.first;
+  }
   return NULL;
 }
 
 struct SpaceSeq *CTX_wm_space_seq(const bContext *C)
 {
   ScrArea *sa = CTX_wm_area(C);
-  if (sa && sa->spacetype == SPACE_SEQ)
+  if (sa && sa->spacetype == SPACE_SEQ) {
     return sa->spacedata.first;
+  }
   return NULL;
 }
 
 struct SpaceOutliner *CTX_wm_space_outliner(const bContext *C)
 {
   ScrArea *sa = CTX_wm_area(C);
-  if (sa && sa->spacetype == SPACE_OUTLINER)
+  if (sa && sa->spacetype == SPACE_OUTLINER) {
     return sa->spacedata.first;
+  }
   return NULL;
 }
 
 struct SpaceNla *CTX_wm_space_nla(const bContext *C)
 {
   ScrArea *sa = CTX_wm_area(C);
-  if (sa && sa->spacetype == SPACE_NLA)
+  if (sa && sa->spacetype == SPACE_NLA) {
     return sa->spacedata.first;
+  }
   return NULL;
 }
 
 struct SpaceNode *CTX_wm_space_node(const bContext *C)
 {
   ScrArea *sa = CTX_wm_area(C);
-  if (sa && sa->spacetype == SPACE_NODE)
+  if (sa && sa->spacetype == SPACE_NODE) {
     return sa->spacedata.first;
+  }
   return NULL;
 }
 
 struct SpaceGraph *CTX_wm_space_graph(const bContext *C)
 {
   ScrArea *sa = CTX_wm_area(C);
-  if (sa && sa->spacetype == SPACE_GRAPH)
+  if (sa && sa->spacetype == SPACE_GRAPH) {
     return sa->spacedata.first;
+  }
   return NULL;
 }
 
 struct SpaceAction *CTX_wm_space_action(const bContext *C)
 {
   ScrArea *sa = CTX_wm_area(C);
-  if (sa && sa->spacetype == SPACE_ACTION)
+  if (sa && sa->spacetype == SPACE_ACTION) {
     return sa->spacedata.first;
+  }
   return NULL;
 }
 
 struct SpaceInfo *CTX_wm_space_info(const bContext *C)
 {
   ScrArea *sa = CTX_wm_area(C);
-  if (sa && sa->spacetype == SPACE_INFO)
+  if (sa && sa->spacetype == SPACE_INFO) {
     return sa->spacedata.first;
+  }
   return NULL;
 }
 
 struct SpaceUserPref *CTX_wm_space_userpref(const bContext *C)
 {
   ScrArea *sa = CTX_wm_area(C);
-  if (sa && sa->spacetype == SPACE_USERPREF)
+  if (sa && sa->spacetype == SPACE_USERPREF) {
     return sa->spacedata.first;
+  }
   return NULL;
 }
 
 struct SpaceClip *CTX_wm_space_clip(const bContext *C)
 {
   ScrArea *sa = CTX_wm_area(C);
-  if (sa && sa->spacetype == SPACE_CLIP)
+  if (sa && sa->spacetype == SPACE_CLIP) {
     return sa->spacedata.first;
+  }
   return NULL;
 }
 
 struct SpaceTopBar *CTX_wm_space_topbar(const bContext *C)
 {
   ScrArea *sa = CTX_wm_area(C);
-  if (sa && sa->spacetype == SPACE_TOPBAR)
+  if (sa && sa->spacetype == SPACE_TOPBAR) {
     return sa->spacedata.first;
+  }
   return NULL;
 }
 
@@ -895,10 +931,12 @@ Main *CTX_data_main(const bContext *C)
 {
   Main *bmain;
 
-  if (ctx_data_pointer_verify(C, "blend_data", (void *)&bmain))
+  if (ctx_data_pointer_verify(C, "blend_data", (void *)&bmain)) {
     return bmain;
-  else
+  }
+  else {
     return C->data.main;
+  }
 }
 
 void CTX_data_main_set(bContext *C, Main *bmain)
@@ -911,10 +949,12 @@ Scene *CTX_data_scene(const bContext *C)
 {
   Scene *scene;
 
-  if (ctx_data_pointer_verify(C, "scene", (void *)&scene))
+  if (ctx_data_pointer_verify(C, "scene", (void *)&scene)) {
     return scene;
-  else
+  }
+  else {
     return C->data.scene;
+  }
 }
 
 ViewLayer *CTX_data_view_layer(const bContext *C)
@@ -1008,26 +1048,36 @@ enum eContextObjectMode CTX_data_mode_enum_ex(const Object *obedit,
   else {
     // Object *ob = CTX_data_active_object(C);
     if (ob) {
-      if (object_mode & OB_MODE_POSE)
+      if (object_mode & OB_MODE_POSE) {
         return CTX_MODE_POSE;
-      else if (object_mode & OB_MODE_SCULPT)
+      }
+      else if (object_mode & OB_MODE_SCULPT) {
         return CTX_MODE_SCULPT;
-      else if (object_mode & OB_MODE_WEIGHT_PAINT)
+      }
+      else if (object_mode & OB_MODE_WEIGHT_PAINT) {
         return CTX_MODE_PAINT_WEIGHT;
-      else if (object_mode & OB_MODE_VERTEX_PAINT)
+      }
+      else if (object_mode & OB_MODE_VERTEX_PAINT) {
         return CTX_MODE_PAINT_VERTEX;
-      else if (object_mode & OB_MODE_TEXTURE_PAINT)
+      }
+      else if (object_mode & OB_MODE_TEXTURE_PAINT) {
         return CTX_MODE_PAINT_TEXTURE;
-      else if (object_mode & OB_MODE_PARTICLE_EDIT)
+      }
+      else if (object_mode & OB_MODE_PARTICLE_EDIT) {
         return CTX_MODE_PARTICLE;
-      else if (object_mode & OB_MODE_PAINT_GPENCIL)
+      }
+      else if (object_mode & OB_MODE_PAINT_GPENCIL) {
         return CTX_MODE_PAINT_GPENCIL;
-      else if (object_mode & OB_MODE_EDIT_GPENCIL)
+      }
+      else if (object_mode & OB_MODE_EDIT_GPENCIL) {
         return CTX_MODE_EDIT_GPENCIL;
-      else if (object_mode & OB_MODE_SCULPT_GPENCIL)
+      }
+      else if (object_mode & OB_MODE_SCULPT_GPENCIL) {
         return CTX_MODE_SCULPT_GPENCIL;
-      else if (object_mode & OB_MODE_WEIGHT_GPENCIL)
+      }
+      else if (object_mode & OB_MODE_WEIGHT_GPENCIL) {
         return CTX_MODE_WEIGHT_GPENCIL;
+      }
     }
   }
 
@@ -1080,10 +1130,12 @@ ToolSettings *CTX_data_tool_settings(const bContext *C)
 {
   Scene *scene = CTX_data_scene(C);
 
-  if (scene)
+  if (scene) {
     return scene->toolsettings;
-  else
+  }
+  else {
     return NULL;
+  }
 }
 
 int CTX_data_selected_nodes(const bContext *C, ListBase *list)
index 465a998..3b46f49 100644 (file)
@@ -86,12 +86,14 @@ static int modifiers_disable_subsurf_temporary(Object *ob)
   ModifierData *md;
   int disabled = 0;
 
-  for (md = ob->m