Style Cleanup: bmesh code style was a bit mixed - follow http://wiki.blender.org...
authorCampbell Barton <ideasman42@gmail.com>
Mon, 6 Feb 2012 04:37:27 +0000 (04:37 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Mon, 6 Feb 2012 04:37:27 +0000 (04:37 +0000)
33 files changed:
source/blender/bmesh/intern/bmesh_construct.c
source/blender/bmesh/intern/bmesh_inline.c
source/blender/bmesh/intern/bmesh_interp.c
source/blender/bmesh/intern/bmesh_iterators.c
source/blender/bmesh/intern/bmesh_iterators_inline.c
source/blender/bmesh/intern/bmesh_marking.c
source/blender/bmesh/intern/bmesh_mesh.c
source/blender/bmesh/intern/bmesh_mods.c
source/blender/bmesh/intern/bmesh_newcore.c
source/blender/bmesh/intern/bmesh_opdefines.c
source/blender/bmesh/intern/bmesh_operators.c
source/blender/bmesh/intern/bmesh_polygon.c
source/blender/bmesh/intern/bmesh_queries.c
source/blender/bmesh/intern/bmesh_structure.c
source/blender/bmesh/intern/bmesh_walkers.c
source/blender/bmesh/intern/bmesh_walkers_impl.c
source/blender/bmesh/operators/bevel.c
source/blender/bmesh/operators/bmesh_dupeops.c
source/blender/bmesh/operators/connectops.c
source/blender/bmesh/operators/createops.c
source/blender/bmesh/operators/dissolveops.c
source/blender/bmesh/operators/edgesplitop.c
source/blender/bmesh/operators/extrudeops.c
source/blender/bmesh/operators/join_triangles.c
source/blender/bmesh/operators/mesh_conv.c
source/blender/bmesh/operators/mirror.c
source/blender/bmesh/operators/primitiveops.c
source/blender/bmesh/operators/removedoubles.c
source/blender/bmesh/operators/subdivideop.c
source/blender/bmesh/operators/triangulateop.c
source/blender/bmesh/operators/utils.c
source/blender/bmesh/tools/BME_bevel.c
source/blender/editors/mesh/meshtools.c

index 644a4f00a3f4ddaf385a332c89bd0955bcd7a539..64453f3aeee0db492830afcc4f396fa174507826 100644 (file)
@@ -55,7 +55,7 @@
 
 #define SELECT 1
 
-/*prototypes*/
+/* prototypes */
 static void bm_copy_loop_attributes(BMesh *source_mesh, BMesh *target_mesh,
                                     const BMLoop *source_loop, BMLoop *target_loop);
 #if 0
@@ -66,7 +66,7 @@ static void bm_copy_loop_attributes(BMesh *source_mesh, BMesh *target_mesh,
  * This file contains functions for making and destroying
  * individual elements like verts, edges and faces.
  *
-*/
+ */
 
 /*
  * BMESH MAKE VERT
@@ -76,7 +76,7 @@ static void bm_copy_loop_attributes(BMesh *source_mesh, BMesh *target_mesh,
  * passed in, it's custom data and properties
  * will be copied to the new vertex.
  *
-*/
+ */
 
 BMVert *BM_Make_Vert(BMesh *bm, float co[3], BMVert *example)
 {
@@ -100,13 +100,13 @@ BMVert *BM_Make_Vert(BMesh *bm, float co[3], BMVert *example)
  * provided, it's custom data and properties will be copied to the
  * new edge.
  *
-*/
+ */
 
 BMEdge *BM_Make_Edge(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge *example, int nodouble)
 {
        BMEdge *e = NULL;
        
-       if (nodouble) /*test if edge already exists.*/
+       if (nodouble) /* test if edge already exists. */
                e = BM_Edge_Exist(v1, v2);
 
        if (!e) {
@@ -135,21 +135,20 @@ BMEdge *BM_Make_Edge(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge *example, int nod
  *
  * Note that the winding of the face is determined
  * by the order of the vertices in the vertex array
- *
-*/
+ */
 
 BMFace *BM_Make_Face_QuadTri(BMesh *bm,
                              BMVert *v1, BMVert *v2, BMVert *v3, BMVert *v4,
                              const BMFace *example, const int nodouble)
 {
-       BMVert *vtar[4]= {v1, v2, v3, v4};
+       BMVert *vtar[4] = {v1, v2, v3, v4};
        return BM_Make_Face_QuadTri_v(bm, vtar, v4 ? 4 : 3, example, nodouble);
 }
 
-/*remove the edge array bits from this. Its not really needed?*/
+/* remove the edge array bits from this. Its not really needed? */
 BMFace *BM_Make_Face_QuadTri_v(BMesh *bm, BMVert **verts, int len, const BMFace *example, const int nodouble)
 {
-       BMEdge *edar[4]= {NULL};
+       BMEdge *edar[4] = {NULL};
        BMFace *f = NULL;
        int overlap = 0;
 
@@ -164,7 +163,7 @@ BMFace *BM_Make_Face_QuadTri_v(BMesh *bm, BMVert **verts, int len, const BMFace
        }
 
        if (nodouble) {
-               /*check if face exists or overlaps*/
+               /* check if face exists or overlaps */
                if (len == 4) {
                        overlap = BM_Exist_Face_Overlaps(bm, verts, len, &f);
                }
@@ -173,7 +172,7 @@ BMFace *BM_Make_Face_QuadTri_v(BMesh *bm, BMVert **verts, int len, const BMFace
                }
        }
 
-       /*make new face*/
+       /* make new face */
        if ((!f) && (!overlap)) {
                if (!edar[0]) edar[0] = BM_Make_Edge(bm, verts[0], verts[1], NULL, 0);
                if (!edar[1]) edar[1] = BM_Make_Edge(bm, verts[1], verts[2], NULL, 0);
@@ -196,7 +195,7 @@ BMFace *BM_Make_Face_QuadTri_v(BMesh *bm, BMVert **verts, int len, const BMFace
 }
 
 
-/*copies face data from shared adjacent faces*/
+/* copies face data from shared adjacent faces */
 void BM_Face_CopyShared(BMesh *bm, BMFace *f)
 {
        BMIter iter;
@@ -204,8 +203,8 @@ void BM_Face_CopyShared(BMesh *bm, BMFace *f)
 
        if (!f) return;
 
-       l=BMIter_New(&iter, bm, BM_LOOPS_OF_FACE, f);
-       for ( ; l; l=BMIter_Step(&iter)) {
+       l = BMIter_New(&iter, bm, BM_LOOPS_OF_FACE, f);
+       for ( ; l; l = BMIter_Step(&iter)) {
                l2 = l->radial_next;
                
                if (l2 && l2 != l) {
@@ -233,7 +232,7 @@ void BM_Face_CopyShared(BMesh *bm, BMFace *f)
  * are already sorted, if the edges are always going to be sorted,
  * BM_Make_Face should be considered over this function as it
  * avoids some unnecessary work.
-*/
+ */
 BMFace *BM_Make_Ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, int len, int nodouble)
 {
        BMEdge **edges2 = NULL;
@@ -243,18 +242,18 @@ BMFace *BM_Make_Ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, int len,
        BMFace *f = NULL;
        BMEdge *e;
        BMVert *ev1, *ev2;
-       int i, /* j,*/ v1found, reverse;
+       int i, /* j, */ v1found, reverse;
 
-       /*this code is hideous, yeek.  I'll have to think about ways of
-         cleaning it up.  basically, it now combines the old BM_Make_Ngon
-         *and* the old bmesh_mf functions, so its kindof smashed together
-               - joeedh*/
+       /* this code is hideous, yeek.  I'll have to think about ways of
+         cleaning it up.  basically, it now combines the old BM_Make_Ngon
+        *  _and_ the old bmesh_mf functions, so its kindof smashed together
+        * - joeedh */
 
        if (!len || !v1 || !v2 || !edges || !bm)
                return NULL;
 
-       /*put edges in correct order*/
-       for (i=0; i<len; i++) {
+       /* put edges in correct order */
+       for (i = 0; i < len; i++) {
                bmesh_api_setflag(edges[i], _FLAG_MF);
        }
 
@@ -263,8 +262,8 @@ BMFace *BM_Make_Ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, int len,
 
        if (v1 == ev2) {
                /* Swapping here improves performance and consistency of face
-                  structure in the special case that the edges are already in
-                  the correct order and winding */
+                * structure in the special case that the edges are already in
+                * the correct order and winding */
                SWAP(BMVert *, ev1, ev2);
        }
 
@@ -286,24 +285,25 @@ BMFace *BM_Make_Ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, int len,
                } while (e2 != e);
 
                if (e2 == e)
-                       goto err; /*the edges do not form a closed loop*/
+                       goto err; /* the edges do not form a closed loop */
 
                e = e2;
        } while (e != edges[0]);
 
-       if (BLI_array_count(edges2) != len)
-               goto err; /*we didn't use all edges in forming the boundary loop*/
+       if (BLI_array_count(edges2) != len) {
+               goto err; /* we didn't use all edges in forming the boundary loop */
+       }
 
-       /*ok, edges are in correct order, now ensure they are going
-         in the correct direction*/
+       /* ok, edges are in correct order, now ensure they are going
+        * in the correct direction */
        v1found = reverse = 0;
-       for (i=0; i<len; i++) {
+       for (i = 0; i < len; i++) {
                if (BM_Vert_In_Edge(edges2[i], v1)) {
-                       /*see if v1 and v2 are in the same edge*/
+                       /* see if v1 and v2 are in the same edge */
                        if (BM_Vert_In_Edge(edges2[i], v2)) {
-                               /*if v1 is shared by the *next* edge, then the winding
-                                 is incorrect*/
-                               if (BM_Vert_In_Edge(edges2[(i+1)%len], v1)) {
+                               /* if v1 is shared by the *next* edge, then the winding
+                                * is incorrect */
+                               if (BM_Vert_In_Edge(edges2[(i + 1) % len], v1)) {
                                        reverse = 1;
                                        break;
                                }
@@ -319,23 +319,24 @@ BMFace *BM_Make_Ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, int len,
        }
 
        if (reverse) {
-               for (i=0; i<len/2; i++) {
+               for (i = 0; i < len / 2; i++) {
                        v = verts[i];
-                       verts[i] = verts[len-i-1];
-                       verts[len-i-1] = v;
+                       verts[i] = verts[len - i - 1];
+                       verts[len - i - 1] = v;
                }
        }
 
-       for (i=0; i<len; i++) {
-               edges2[i] = BM_Edge_Exist(verts[i], verts[(i+1)%len]);
-               if (!edges2[i])
+       for (i = 0; i < len; i++) {
+               edges2[i] = BM_Edge_Exist(verts[i], verts[(i + 1) % len]);
+               if (!edges2[i]) {
                        goto err;
+               }
        }
 
        f = BM_Make_Face(bm, verts, edges2, len, nodouble);
 
-       /*clean up flags*/
-       for (i=0; i<len; i++) {
+       /* clean up flags */
+       for (i = 0; i < len; i++) {
                bmesh_api_clearflag(edges2[i], _FLAG_MF);
        }
 
@@ -345,7 +346,7 @@ BMFace *BM_Make_Ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, int len,
        return f;
 
 err:
-       for (i=0; i<len; i++) {
+       for (i = 0; i < len; i++) {
                bmesh_api_clearflag(edges[i], _FLAG_MF);
        }
 
@@ -356,7 +357,7 @@ err:
 }
 
 
-/*bmesh_make_face_from_face(BMesh *bm, BMFace *source, BMFace *target) */
+/* bmesh_make_face_from_face(BMesh *bm, BMFace *source, BMFace *target) */
 
 
 /*
@@ -365,7 +366,7 @@ err:
  * Called by operators to remove elements that they have marked for
  * removal.
  *
-*/
+ */
 
 void BM_remove_tagged_faces(BMesh *bm, int flag)
 {
@@ -436,7 +437,7 @@ static void bm_copy_face_attributes(BMesh *source_mesh, BMesh *target_mesh, cons
        target_face->mat_nr = source_face->mat_nr;
 }
 
-/*BMESH_TODO: Special handling for hide flags?*/
+/* BMESH_TODO: Special handling for hide flags? */
 
 void BM_Copy_Attributes(BMesh *source_mesh, BMesh *target_mesh, const void *source, void *target)
 {
@@ -446,21 +447,21 @@ void BM_Copy_Attributes(BMesh *source_mesh, BMesh *target_mesh, const void *sour
        if (sheader->htype != theader->htype)
                return;
 
-       /*First we copy select*/
+       /* First we copy select */
        if (BM_Selected(source_mesh, source)) BM_Select(target_mesh, target, TRUE);
        
-       /*Now we copy flags*/
+       /* Now we copy flags */
        theader->hflag = sheader->hflag;
        
-       /*Copy specific attributes*/
+       /* Copy specific attributes */
        if (theader->htype == BM_VERT)
-               bm_copy_vert_attributes(source_mesh, target_mesh, (const BMVert*)source, (BMVert*)target);
+               bm_copy_vert_attributes(source_mesh, target_mesh, (const BMVert *)source, (BMVert *)target);
        else if (theader->htype == BM_EDGE)
-               bm_copy_edge_attributes(source_mesh, target_mesh, (const BMEdge*)source, (BMEdge*)target);
+               bm_copy_edge_attributes(source_mesh, target_mesh, (const BMEdge *)source, (BMEdge *)target);
        else if (theader->htype == BM_LOOP)
-               bm_copy_loop_attributes(source_mesh, target_mesh, (const BMLoop*)source, (BMLoop*)target);
+               bm_copy_loop_attributes(source_mesh, target_mesh, (const BMLoop *)source, (BMLoop *)target);
        else if (theader->htype == BM_FACE)
-               bm_copy_face_attributes(source_mesh, target_mesh, (const BMFace*)source, (BMFace*)target);
+               bm_copy_face_attributes(source_mesh, target_mesh, (const BMFace *)source, (BMFace *)target);
 }
 
 BMesh *BM_Copy_Mesh(BMesh *bmold)
@@ -469,15 +470,15 @@ BMesh *BM_Copy_Mesh(BMesh *bmold)
        BMVert *v, *v2, **vtable = NULL;
        BMEdge *e, *e2, **edges = NULL, **etable = NULL;
        BLI_array_declare(edges);
-       BMLoop *l, /* *l2,*/ **loops = NULL;
+       BMLoop *l, /* *l2, */ **loops = NULL;
        BLI_array_declare(loops);
        BMFace *f, *f2, **ftable = NULL;
        BMEditSelection *ese;
        BMIter iter, liter;
-       int allocsize[4] = {512,512,2048,512};
+       int allocsize[4] = {512, 512, 2048, 512};
        int i, j;
 
-       /*allocate a bmesh*/
+       /* allocate a bmesh */
        bm = BM_Make_Mesh(bmold->ob, allocsize);
 
        CustomData_copy(&bmold->vdata, &bm->vdata, CD_MASK_BMESH, CD_CALLOC, 0);
@@ -490,12 +491,12 @@ BMesh *BM_Copy_Mesh(BMesh *bmold)
        CustomData_bmesh_init_pool(&bm->ldata, allocsize[2]);
        CustomData_bmesh_init_pool(&bm->pdata, allocsize[3]);
 
-       vtable= MEM_mallocN(sizeof(BMVert *) * bmold->totvert, "BM_Copy_Mesh vtable");
-       etable= MEM_mallocN(sizeof(BMEdge *) * bmold->totedge, "BM_Copy_Mesh etable");
-       ftable= MEM_mallocN(sizeof(BMFace *) * bmold->totface, "BM_Copy_Mesh ftable");
+       vtable = MEM_mallocN(sizeof(BMVert *) * bmold->totvert, "BM_Copy_Mesh vtable");
+       etable = MEM_mallocN(sizeof(BMEdge *) * bmold->totedge, "BM_Copy_Mesh etable");
+       ftable = MEM_mallocN(sizeof(BMFace *) * bmold->totface, "BM_Copy_Mesh ftable");
 
        v = BMIter_New(&iter, bmold, BM_VERTS_OF_MESH, NULL);
-       for (i=0; v; v=BMIter_Step(&iter), i++) {
+       for (i = 0; v; v = BMIter_Step(&iter), i++) {
                v2 = BM_Make_Vert(bm, v->co, NULL); /* copy between meshes so cant use 'example' argument */
                BM_Copy_Attributes(bmold, bm, v, v2);
                vtable[i] = v2;
@@ -509,7 +510,7 @@ BMesh *BM_Copy_Mesh(BMesh *bmold)
        BLI_assert(i == bmold->totvert);
        
        e = BMIter_New(&iter, bmold, BM_EDGES_OF_MESH, NULL);
-       for (i=0; e; e=BMIter_Step(&iter), i++) {
+       for (i = 0; e; e = BMIter_Step(&iter), i++) {
                e2 = BM_Make_Edge(bm, vtable[BM_GetIndex(e->v1)],
                                  vtable[BM_GetIndex(e->v2)], e, 0);
 
@@ -525,7 +526,7 @@ BMesh *BM_Copy_Mesh(BMesh *bmold)
        BLI_assert(i == bmold->totedge);
        
        f = BMIter_New(&iter, bmold, BM_FACES_OF_MESH, NULL);
-       for (i=0; f; f=BMIter_Step(&iter), i++) {
+       for (i = 0; f; f = BMIter_Step(&iter), i++) {
                BM_SetIndex(f, i); /* set_inline */
 
                BLI_array_empty(loops);
@@ -534,7 +535,7 @@ BMesh *BM_Copy_Mesh(BMesh *bmold)
                BLI_array_growitems(edges, f->len);
 
                l = BMIter_New(&liter, bmold, BM_LOOPS_OF_FACE, f);
-               for (j=0; j<f->len; j++, l = BMIter_Step(&liter)) {
+               for (j = 0; j < f->len; j++, l = BMIter_Step(&liter)) {
                        loops[j] = l;
                        edges[j] = etable[BM_GetIndex(l->e)];
                }
@@ -543,7 +544,7 @@ BMesh *BM_Copy_Mesh(BMesh *bmold)
                v2 = vtable[BM_GetIndex(loops[1]->v)];
 
                if (!bmesh_verts_in_edge(v, v2, edges[0])) {
-                       v = vtable[BM_GetIndex(loops[BLI_array_count(loops)-1]->v)];
+                       v = vtable[BM_GetIndex(loops[BLI_array_count(loops) - 1]->v)];
                        v2 = vtable[BM_GetIndex(loops[0]->v)];
                }
 
@@ -551,7 +552,7 @@ BMesh *BM_Copy_Mesh(BMesh *bmold)
                if (!f2)
                        continue;
                /* use totface incase adding some faces fails */
-               BM_SetIndex(f2, (bm->totface-1)); /* set_inline */
+               BM_SetIndex(f2, (bm->totface - 1)); /* set_inline */
 
                ftable[i] = f2;
 
@@ -559,7 +560,7 @@ BMesh *BM_Copy_Mesh(BMesh *bmold)
                copy_v3_v3(f2->no, f->no);
 
                l = BMIter_New(&liter, bm, BM_LOOPS_OF_FACE, f2);
-               for (j=0; j<f->len; j++, l = BMIter_Step(&liter)) {
+               for (j = 0; j < f->len; j++, l = BMIter_Step(&liter)) {
                        BM_Copy_Attributes(bmold, bm, loops[j], l);
                }
 
@@ -571,16 +572,16 @@ BMesh *BM_Copy_Mesh(BMesh *bmold)
        /* safety check */
        BLI_assert(i == bmold->totface);
 
-       /*copy over edit selection history*/
-       for (ese=bmold->selected.first; ese; ese=ese->next) {
+       /* copy over edit selection history */
+       for (ese = bmold->selected.first; ese; ese = ese->next) {
                void *ele = NULL;
 
                if (ese->htype == BM_VERT)
-                       ele= vtable[BM_GetIndex(ese->data)];
+                       ele = vtable[BM_GetIndex(ese->data)];
                else if (ese->htype == BM_EDGE)
-                       ele= etable[BM_GetIndex(ese->data)];
+                       ele = etable[BM_GetIndex(ese->data)];
                else if (ese->htype == BM_FACE) {
-                       ele= ftable[BM_GetIndex(ese->data)];
+                       ele = ftable[BM_GetIndex(ese->data)];
                }
                else {
                        BLI_assert(0);
@@ -626,7 +627,7 @@ char BM_Face_Flag_From_MEFlag(const char  meflag)
 /* BM -> ME */
 char  BM_Vert_Flag_To_MEFlag(BMVert *eve)
 {
-    const char hflag= eve->head.hflag;
+    const char hflag = eve->head.hflag;
 
     return ( ((hflag & BM_SELECT)  ? SELECT  : 0) |
              ((hflag & BM_HIDDEN)  ? ME_HIDE : 0)
@@ -634,7 +635,7 @@ char  BM_Vert_Flag_To_MEFlag(BMVert *eve)
 }
 short BM_Edge_Flag_To_MEFlag(BMEdge *eed)
 {
-       const char hflag= eed->head.hflag;
+       const char hflag = eed->head.hflag;
 
        return ( ((hflag & BM_SELECT)       ? SELECT    : 0) |
                 ((hflag & BM_SEAM)         ? ME_SEAM   : 0) |
@@ -646,7 +647,7 @@ short BM_Edge_Flag_To_MEFlag(BMEdge *eed)
 }
 char  BM_Face_Flag_To_MEFlag(BMFace *efa)
 {
-    const char hflag= efa->head.hflag;
+    const char hflag = efa->head.hflag;
 
     return ( ((hflag & BM_SELECT) ? ME_FACE_SEL : 0) |
              ((hflag & BM_SMOOTH) ? ME_SMOOTH   : 0) |
@@ -662,10 +663,10 @@ char  BM_Face_Flag_To_MEFlag(BMFace *efa)
   Returns the flags stored in element,
   which much be either a BMVert, BMEdge,
   or BMFace, converted to mesh flags.
-*/
+ */
 short BMFlags_To_MEFlags(void *element)
 {
-       const char src_htype= ((BMHeader *)element)->htype;
+       const char src_htype = ((BMHeader *)element)->htype;
 
        if (src_htype == BM_FACE) {
                return BM_Face_Flag_To_MEFlag(element);
@@ -689,7 +690,7 @@ short BMFlags_To_MEFlags(void *element)
   or MPoly, converted to mesh flags.
   type must be either BM_VERT, BM_EDGE,
   or BM_FACE.
-*/
+ */
 char MEFlags_To_BMFlags(const short hflag, const char htype)
 {
        if (htype == BM_FACE) {
index d53c42a336e75fc29779a36ab16ff2d4fc653596..54339610a9fee1cc032769bc9187828bc86d4236 100644 (file)
@@ -68,5 +68,5 @@ BM_INLINE int BM_GetIndex(const void *element)
        return ((BMHeader *)element)->index;
 }
 
-#endif /*BM_INLINE_C*/
+#endif /* BM_INLINE_C */
 
index c9c17a738ab82d50c0fb0330bba6576192b0f069..1ce715391987dd2298d8eaf357bd780773e842c5 100644 (file)
@@ -77,8 +77,8 @@ void BM_Data_Interp_From_Verts(BMesh *bm, BMVert *v1, BMVert *v2, BMVert *v, flo
                        void *src[2];
                        float w[2];
 
-                       src[0]= v1->head.data;
-                       src[1]= v2->head.data;
+                       src[0] = v1->head.data;
+                       src[1] = v2->head.data;
                        w[0] = 1.0f-fac;
                        w[1] = fac;
                        CustomData_bmesh_interp(&bm->vdata, src, w, NULL, 2, v->head.data);
@@ -87,11 +87,11 @@ void BM_Data_Interp_From_Verts(BMesh *bm, BMVert *v1, BMVert *v2, BMVert *v, flo
 }
 
 /*
   BM Data Vert Average
-
   Sets all the customdata (e.g. vert, loop) associated with a vert
   to the average of the face regions surrounding it.
-*/
*  BM Data Vert Average
+ *
* Sets all the customdata (e.g. vert, loop) associated with a vert
* to the average of the face regions surrounding it.
+ */
 
 
 static void UNUSED_FUNCTION(BM_Data_Vert_Average)(BMesh *UNUSED(bm), BMFace *UNUSED(f))
@@ -107,13 +107,13 @@ static void UNUSED_FUNCTION(BM_Data_Vert_Average)(BMesh *UNUSED(bm), BMFace *UNU
  * 
  *  Returns -
  *     Nothing
-*/
+ */
  
 void BM_Data_Facevert_Edgeinterp(BMesh *bm, BMVert *v1, BMVert *UNUSED(v2), BMVert *v, BMEdge *e1, float fac)
 {
        void *src[2];
        float w[2];
-       BMLoop *l=NULL, *v1loop = NULL, *vloop = NULL, *v2loop = NULL;
+       BMLoop *l = NULL, *v1loop = NULL, *vloop = NULL, *v2loop = NULL;
        
        w[1] = 1.0f - fac;
        w[0] = fac;
@@ -138,9 +138,9 @@ void BM_Data_Facevert_Edgeinterp(BMesh *bm, BMVert *v1, BMVert *UNUSED(v2), BMVe
                src[0] = v1loop->head.data;
                src[1] = v2loop->head.data;                                     
 
-               CustomData_bmesh_interp(&bm->ldata, src,w, NULL, 2, vloop->head.data);                          
+               CustomData_bmesh_interp(&bm->ldata, src, w, NULL, 2, vloop->head.data);
                l = l->radial_next;
-       } while (l!=e1->l);
+       } while (l != e1->l);
 }
 
 void BM_loops_to_corners(BMesh *bm, Mesh *me, int findex,
@@ -155,7 +155,7 @@ void BM_loops_to_corners(BMesh *bm, Mesh *me, int findex,
        MLoopUV *mloopuv;
        int i, j;
 
-       for (i=0; i < numTex; i++) {
+       for (i = 0; i < numTex; i++) {
                texface = CustomData_get_n(&me->fdata, CD_MTFACE, findex, i);
                texpoly = CustomData_bmesh_get_n(&bm->pdata, f->head.data, CD_MTEXPOLY, i);
                
@@ -176,7 +176,7 @@ void BM_loops_to_corners(BMesh *bm, Mesh *me, int findex,
 
        }
 
-       for (i=0; i < numCol; i++) {
+       for (i = 0; i < numCol; i++) {
                mcol = CustomData_get_n(&me->fdata, CD_MCOL, findex, i);
 
                j = 0;
@@ -200,14 +200,14 @@ void BM_loops_to_corners(BMesh *bm, Mesh *me, int findex,
  * 
  *  Returns -
  *     Nothing
-*/
+ */
 void BM_face_interp_from_face(BMesh *bm, BMFace *target, BMFace *source)
 {
        BMLoop *l1, *l2;
        BMLoop *l_first;
 
-       void **blocks=NULL;
-       float (*cos)[3]=NULL, *w=NULL;
+       void **blocks = NULL;
+       float (*cos)[3] = NULL, *w = NULL;
        BLI_array_fixedstack_declare(cos,     BM_NGON_STACK_SIZE, source->len, __func__);
        BLI_array_fixedstack_declare(w,       BM_NGON_STACK_SIZE, source->len, __func__);
        BLI_array_fixedstack_declare(blocks,  BM_NGON_STACK_SIZE, source->len, __func__);
@@ -236,22 +236,22 @@ void BM_face_interp_from_face(BMesh *bm, BMFace *target, BMFace *source)
        BLI_array_fixedstack_free(blocks);
 }
 
-/****some math stuff for dealing with doubles, put here to
 avoid merge errors - joeedh ****/
+/* some math stuff for dealing with doubles, put here to
* avoid merge errors - joeedh */
 
 #define VECMUL(a, b) (((a)[0] = (a)[0] * (b)), ((a)[1] = (a)[1] * (b)), ((a)[2] = (a)[2] * (b)))
 #define VECADD2(a, b) (((a)[0] = (a)[0] + (b)[0]), ((a)[1] = (a)[1] + (b)[1]), ((a)[2] = (a)[2] + (b)[2]))
 #define VECSUB2(a, b) (((a)[0] = (a)[0] - (b)[0]), ((a)[1] = (a)[1] - (b)[1]), ((a)[2] = (a)[2] - (b)[2]))
 
-/* find closest point to p on line through l1,l2 and return lambda,
- * where (0 <= lambda <= 1) when cp is in the line segement l1,l2
+/* find closest point to p on line through l1, l2 and return lambda,
+ * where (0 <= lambda <= 1) when cp is in the line segement l1, l2
  */
 static double closest_to_line_v3_d(double cp[3], const double p[3], const double l1[3], const double l2[3])
 {
-       double h[3],u[3],lambda;
+       double h[3], u[3], lambda;
        VECSUB(u, l2, l1);
        VECSUB(h, p, l1);
-       lambda =INPR(u,h)/INPR(u,u);
+       lambda = INPR(u, h) / INPR(u, u);
        cp[0] = l1[0] + u[0] * lambda;
        cp[1] = l1[1] + u[1] * lambda;
        cp[2] = l1[2] + u[2] * lambda;
@@ -263,7 +263,7 @@ static void UNUSED_FUNCTION(closest_to_line_segment_v3_d)(double *closest, doubl
 {
        double lambda, cp[3];
 
-       lambda= closest_to_line_v3_d(cp,v1, v2, v3);
+       lambda = closest_to_line_v3_d(cp, v1, v2, v3);
 
        if (lambda <= 0.0) {
                VECCOPY(closest, v2);
@@ -291,23 +291,23 @@ static double UNUSED_FUNCTION(len_v3v3_d)(const double a[3], const double b[3])
 
 static void cent_quad_v3_d(double *cent, double *v1, double *v2, double *v3, double *v4)
 {
-       cent[0]= 0.25*(v1[0]+v2[0]+v3[0]+v4[0]);
-       cent[1]= 0.25*(v1[1]+v2[1]+v3[1]+v4[1]);
-       cent[2]= 0.25*(v1[2]+v2[2]+v3[2]+v4[2]);
+       cent[0] = 0.25 * (v1[0] + v2[0] + v3[0] + v4[0]);
+       cent[1] = 0.25 * (v1[1] + v2[1] + v3[1] + v4[1]);
+       cent[2] = 0.25 * (v1[2] + v2[2] + v3[2] + v4[2]);
 }
 
 static void UNUSED_FUNCTION(cent_tri_v3_d)(double *cent, double *v1, double *v2, double *v3)
 {
-       cent[0]= 0.33333*(v1[0]+v2[0]+v3[0]);
-       cent[1]= 0.33333*(v1[1]+v2[1]+v3[1]);
-       cent[2]= 0.33333*(v1[2]+v2[2]+v3[2]);
+       cent[0] = 0.33333 * (v1[0] + v2[0] + v3[0]);
+       cent[1] = 0.33333 * (v1[1] + v2[1] + v3[1]);
+       cent[2] = 0.33333 * (v1[2] + v2[2] + v3[2]);
 }
 
 static void UNUSED_FUNCTION(cross_v3_v3v3_d)(double r[3], const double a[3], const double b[3])
 {
-       r[0]= a[1]*b[2] - a[2]*b[1];
-       r[1]= a[2]*b[0] - a[0]*b[2];
-       r[2]= a[0]*b[1] - a[1]*b[0];
+       r[0] = a[1] * b[2] - a[2] * b[1];
+       r[1] = a[2] * b[0] - a[0] * b[2];
+       r[2] = a[0] * b[1] - a[1] * b[0];
 }
 
 /* distance v1 to line-piece v2-v3 */
@@ -315,31 +315,31 @@ static double UNUSED_FUNCTION(dist_to_line_segment_v2_d)(double v1[3], double v2
 {
        double labda, rc[2], pt[2], len;
        
-       rc[0]= v3[0]-v2[0];
-       rc[1]= v3[1]-v2[1];
-       len= rc[0]*rc[0]+ rc[1]*rc[1];
-       if (len==0.0) {
-               rc[0]= v1[0]-v2[0];
-               rc[1]= v1[1]-v2[1];
-               return sqrt(rc[0]*rc[0]+ rc[1]*rc[1]);
+       rc[0] = v3[0] - v2[0];
+       rc[1] = v3[1] - v2[1];
+       len = rc[0]*rc[0]+ rc[1]*rc[1];
+       if (len == 0.0) {
+               rc[0] = v1[0] - v2[0];
+               rc[1] = v1[1] - v2[1];
+               return sqrt(rc[0] * rc[0] + rc[1] * rc[1]);
        }
        
-       labda= (rc[0]*(v1[0]-v2[0]) + rc[1]*(v1[1]-v2[1]))/len;
-       if (labda<=0.0) {
-               pt[0]= v2[0];
-               pt[1]= v2[1];
+       labda = (rc[0]*(v1[0]-v2[0]) + rc[1]*(v1[1]-v2[1])) / len;
+       if (labda <= 0.0) {
+               pt[0] = v2[0];
+               pt[1] = v2[1];
        }
-       else if (labda>=1.0) {
-               pt[0]= v3[0];
-               pt[1]= v3[1];
+       else if (labda >= 1.0) {
+               pt[0] = v3[0];
+               pt[1] = v3[1];
        }
        else {
-               pt[0]= labda*rc[0]+v2[0];
-               pt[1]= labda*rc[1]+v2[1];
+               pt[0] = labda*rc[0]+v2[0];
+               pt[1] = labda*rc[1]+v2[1];
        }
 
-       rc[0]= pt[0]-v1[0];
-       rc[1]= pt[1]-v1[1];
+       rc[0] = pt[0]-v1[0];
+       rc[1] = pt[1]-v1[1];
        return sqrt(rc[0]*rc[0]+ rc[1]*rc[1]);
 }
 
@@ -353,19 +353,19 @@ MINLINE double line_point_side_v2_d(const double *l1, const double *l2, const do
 /* point in quad - only convex quads */
 static int isect_point_quad_v2_d(double pt[2], double v1[2], double v2[2], double v3[2], double v4[2])
 {
-       if (line_point_side_v2_d(v1,v2,pt)>=0.0) {
-               if (line_point_side_v2_d(v2,v3,pt)>=0.0) {
-                       if (line_point_side_v2_d(v3,v4,pt)>=0.0) {
-                               if (line_point_side_v2_d(v4,v1,pt)>=0.0) {
+       if (line_point_side_v2_d(v1, v2, pt) >= 0.0) {
+               if (line_point_side_v2_d(v2, v3, pt) >= 0.0) {
+                       if (line_point_side_v2_d(v3, v4, pt) >= 0.0) {
+                               if (line_point_side_v2_d(v4, v1, pt) >= 0.0) {
                                        return 1;
                                }
                        }
                }
        }
        else {
-               if (! (line_point_side_v2_d(v2,v3,pt)>=0.0)) {
-                       if (! (line_point_side_v2_d(v3,v4,pt)>=0.0)) {
-                               if (! (line_point_side_v2_d(v4,v1,pt)>=0.0)) {
+               if (! (line_point_side_v2_d(v2, v3, pt) >= 0.0)) {
+                       if (! (line_point_side_v2_d(v3, v4, pt) >= 0.0)) {
+                               if (! (line_point_side_v2_d(v4, v1, pt) >= 0.0)) {
                                        return -1;
                                }
                        }
@@ -386,14 +386,14 @@ mdisps is a grid of displacements, ordered thus:
      |
      V
      y
-*/
+ */
 
 static int compute_mdisp_quad(BMLoop *l, double v1[3], double v2[3], double v3[3], double v4[3], double e1[3], double e2[3])
 {
        double cent[3] = {0.0, 0.0, 0.0}, n[3], p[3];
        BMLoop *l2;
        
-       /*computer center*/
+       /* computer center */
        l2 = bm_firstfaceloop(l->f);
        do {
                cent[0] += (double)l2->v->co[0];
@@ -402,7 +402,7 @@ static int compute_mdisp_quad(BMLoop *l, double v1[3], double v2[3], double v3[3
                l2 = l2->next;
        } while (l2 != bm_firstfaceloop(l->f));
        
-       VECMUL(cent, (1.0/(double)l->f->len));
+       VECMUL(cent, (1.0 / (double)l->f->len));
        
        VECADD(p, l->prev->v->co, l->v->co);
        VECMUL(p, 0.5);
@@ -420,38 +420,38 @@ static int compute_mdisp_quad(BMLoop *l, double v1[3], double v2[3], double v3[3
        return 1;
 }
 
-/*funnily enough, I think this is identical to face_to_crn_interp, heh*/
+/* funnily enough, I think this is identical to face_to_crn_interp, heh */
 static double quad_coord(double aa[3], double bb[3], double cc[3], double dd[3], int a1, int a2)
 {
        double x, y, z, f1;
        
-       x = aa[a1]*cc[a2]-cc[a1]*aa[a2];
-       y = aa[a1]*dd[a2]+bb[a1]*cc[a2]-cc[a1]*bb[a2]-dd[a1]*aa[a2];
-       z = bb[a1]*dd[a2]-dd[a1]*bb[a2];
+       x = aa[a1] * cc[a2] - cc[a1] * aa[a2];
+       y = aa[a1] * dd[a2] + bb[a1] * cc[a2] - cc[a1] * bb[a2] - dd[a1] * aa[a2];
+       z = bb[a1] * dd[a2] - dd[a1] * bb[a2];
        
-       if (fabs(2*(x-y+z)) > DBL_EPSILON*10.0) {
+       if (fabs(2 * (x - y + z)) > DBL_EPSILON * 10.0) {
                double f2;
 
-               f1 = (sqrt(y*y-4.0*x*z) - y + 2.0*z) / (2.0*(x-y+z));
-               f2 = (-sqrt(y*y-4.0*x*z) - y + 2.0*z) / (2.0*(x-y+z));
+               f1 = (sqrt(y * y - 4.0 * x * z) - y + 2.0 * z) / (2.0 * (x - y + z));
+               f2 = (-sqrt(y * y - 4.0 * x * z) - y + 2.0 * z) / (2.0 * (x - y + z));
 
-               f1= fabs(f1);
-               f2= fabs(f2);
+               f1 = fabs(f1);
+               f2 = fabs(f2);
                f1 = MIN2(f1, f2);
-               CLAMP(f1, 0.0, 1.0+DBL_EPSILON);
+               CLAMP(f1, 0.0, 1.0 + DBL_EPSILON);
        }
        else {
-               f1 = -z/(y - 2*z);
-               CLAMP(f1, 0.0, 1.0+DBL_EPSILON);
+               f1 = -z / (y - 2 * z);
+               CLAMP(f1, 0.0, 1.0 + DBL_EPSILON);
                
                if (isnan(f1) || f1 > 1.0 || f1 < 0.0) {
                        int i;
                        
-                       for (i=0; i<2; i++) {
-                               if (fabsf(aa[i]) < FLT_EPSILON*100)
-                                       return aa[(i+1)%2] / fabs(bb[(i+1)%2] - aa[(i+1)%2]);
-                               if (fabsf(cc[i]) < FLT_EPSILON*100)
-                                       return cc[(i+1)%2] / fabs(dd[(i+1)%2] - cc[(i+1)%2]);
+                       for (i = 0; i < 2; i++) {
+                               if (fabsf(aa[i]) < FLT_EPSILON * 100)
+                                       return aa[(i + 1) % 2] / fabs(bb[(i + 1) % 2] - aa[(i + 1) % 2]);
+                               if (fabsf(cc[i]) < FLT_EPSILON * 100)
+                                       return cc[(i + 1) % 2] / fabs(dd[(i + 1) % 2] - cc[(i + 1) % 2]);
                        }
                }
        }
@@ -462,10 +462,10 @@ static double quad_coord(double aa[3], double bb[3], double cc[3], double dd[3],
 static int quad_co(double *x, double *y, double v1[3], double v2[3], double v3[3], double v4[3], double p[3], float n[3])
 {
        float projverts[5][3], n2[3];
-       double dprojverts[4][3], origin[3]={0.0f, 0.0f, 0.0f};
+       double dprojverts[4][3], origin[3] = {0.0f, 0.0f, 0.0f};
        int i;
 
-       /*project points into 2d along normal*/
+       /* project points into 2d along normal */
        VECCOPY(projverts[0], v1);
        VECCOPY(projverts[1], v2);
        VECCOPY(projverts[2], v3);
@@ -474,17 +474,20 @@ static int quad_co(double *x, double *y, double v1[3], double v2[3], double v3[3
 
        normal_quad_v3(n2, projverts[0], projverts[1], projverts[2], projverts[3]);
 
-       if (INPR(n, n2) < -FLT_EPSILON)
+       if (INPR(n, n2) < -FLT_EPSILON) {
                return 0;
+       }
 
-       /*rotate*/      
+       /* rotate */
        poly_rotate_plane(n, projverts, 5);
        
-       /*flatten*/
-       for (i=0; i<5; i++) projverts[i][2] = 0.0f;
+       /* flatten */
+       for (i = 0; i < 5; i++) {
+               projverts[i][2] = 0.0f;
+       }
        
-       /*subtract origin*/
-       for (i=0; i<4; i++) {
+       /* subtract origin */
+       for (i = 0; i < 4; i++) {
                VECSUB2(projverts[i], projverts[4]);
        }
        
@@ -493,8 +496,9 @@ static int quad_co(double *x, double *y, double v1[3], double v2[3], double v3[3
        VECCOPY(dprojverts[2], projverts[2]);
        VECCOPY(dprojverts[3], projverts[3]);
 
-       if (!isect_point_quad_v2_d(origin, dprojverts[0], dprojverts[1], dprojverts[2], dprojverts[3]))
+       if (!isect_point_quad_v2_d(origin, dprojverts[0], dprojverts[1], dprojverts[2], dprojverts[3])) {
                return 0;
+       }
        
        *y = quad_coord(dprojverts[1], dprojverts[0], dprojverts[2], dprojverts[3], 0, 1);
        *x = quad_coord(dprojverts[2], dprojverts[1], dprojverts[3], dprojverts[0], 0, 1);
@@ -503,12 +507,12 @@ static int quad_co(double *x, double *y, double v1[3], double v2[3], double v3[3
 }
 
 
-/*tl is loop to project onto, l is loop whose internal displacement, co, is being
 projected.  x and y are location in loop's mdisps grid of point co.*/
+/* tl is loop to project onto, l is loop whose internal displacement, co, is being
* projected.  x and y are location in loop's mdisps grid of point co. */
 static int mdisp_in_mdispquad(BMesh *bm, BMLoop *l, BMLoop *tl, double p[3], double *x, double *y, int res)
 {
        double v1[3], v2[3], c[3], v3[3], v4[3], e1[3], e2[3];
-       double eps = FLT_EPSILON*4000;
+       double eps = FLT_EPSILON * 4000;
        
        if (len_v3(l->v->no) == 0.0f)
                BM_Vert_UpdateAllNormals(bm, l->v);
@@ -517,21 +521,21 @@ static int mdisp_in_mdispquad(BMesh *bm, BMLoop *l, BMLoop *tl, double p[3], dou
                
        compute_mdisp_quad(tl, v1, v2, v3, v4, e1, e2);
 
-       /*expand quad a bit*/
+       /* expand quad a bit */
        cent_quad_v3_d(c, v1, v2, v3, v4);
        
        VECSUB2(v1, c); VECSUB2(v2, c);
        VECSUB2(v3, c); VECSUB2(v4, c);
-       VECMUL(v1, 1.0+eps); VECMUL(v2, 1.0+eps);
-       VECMUL(v3, 1.0+eps); VECMUL(v4, 1.0+eps);
+       VECMUL(v1, 1.0 + eps); VECMUL(v2, 1.0 + eps);
+       VECMUL(v3, 1.0 + eps); VECMUL(v4, 1.0 + eps);
        VECADD2(v1, c); VECADD2(v2, c);
        VECADD2(v3, c); VECADD2(v4, c);
        
        if (!quad_co(x, y, v1, v2, v3, v4, p, l->v->no))
                return 0;
        
-       *x *= res-1;
-       *y *= res-1;
+       *x *= res - 1;
+       *y *= res - 1;
                  
        return 1;
 }
@@ -543,7 +547,7 @@ static void bmesh_loop_interp_mdisps(BMesh *bm, BMLoop *target, BMFace *source)
        double x, y, d, v1[3], v2[3], v3[3], v4[3] = {0.0f, 0.0f, 0.0f}, e1[3], e2[3];
        int ix, iy, res;
        
-       /*ignore 2-edged faces*/
+       /* ignore 2-edged faces */
        if (target->f->len < 3)
                return;
        
@@ -553,28 +557,30 @@ static void bmesh_loop_interp_mdisps(BMesh *bm, BMLoop *target, BMFace *source)
        mdisps = CustomData_bmesh_get(&bm->ldata, target->head.data, CD_MDISPS);
        compute_mdisp_quad(target, v1, v2, v3, v4, e1, e2);
        
-       /*if no disps data allocate a new grid, the size of the first grid in source.*/
+       /* if no disps data allocate a new grid, the size of the first grid in source. */
        if (!mdisps->totdisp) {
                MDisps *md2 = CustomData_bmesh_get(&bm->ldata, bm_firstfaceloop(source)->head.data, CD_MDISPS);
                
                mdisps->totdisp = md2->totdisp;
-               if (mdisps->totdisp)
-                       mdisps->disps = MEM_callocN(sizeof(float)*3*mdisps->totdisp, "mdisp->disps in bmesh_loop_intern_mdisps");
-               else 
+               if (mdisps->totdisp) {
+                       mdisps->disps = MEM_callocN(sizeof(float) * 3 * mdisps->totdisp, "mdisp->disps in bmesh_loop_intern_mdisps");
+               }
+               else {
                        return;
+               }
        }
        
        res = (int)sqrt(mdisps->totdisp);
-       d = 1.0/(double)(res-1);
-       for (x=0.0f, ix=0; ix<res; x += d, ix++) {
-               for (y=0.0f, iy=0; iy<res; y+= d, iy++) {
+       d = 1.0 / (double)(res - 1);
+       for (x = 0.0f, ix = 0; ix < res; x += d, ix++) {
+               for (y = 0.0f, iy = 0; iy < res; y += d, iy++) {
                        double co1[3], co2[3], co[3];
                        /* double xx, yy; */ /* UNUSED */
                        
                        VECCOPY(co1, e1);
                        
-                       /* if (!iy) yy = y + (double)FLT_EPSILON*20; */
-                       /* else yy = y - (double)FLT_EPSILON*20; */
+                       /* if (!iy) yy = y + (double)FLT_EPSILON * 20; */
+                       /* else yy = y - (double)FLT_EPSILON * 20; */
                        
                        VECMUL(co1, y);
                        VECADD2(co1, v1);
@@ -583,8 +589,8 @@ static void bmesh_loop_interp_mdisps(BMesh *bm, BMLoop *target, BMFace *source)
                        VECMUL(co2, y);
                        VECADD2(co2, v4);
                        
-                       /* if (!ix) xx = x + (double)FLT_EPSILON*20; */ /* UNUSED */
-                       /* else xx = x - (double)FLT_EPSILON*20; */ /* UNUSED */
+                       /* if (!ix) xx = x + (double)FLT_EPSILON * 20; */ /* UNUSED */
+                       /* else xx = x - (double)FLT_EPSILON * 20; */ /* UNUSED */
                        
                        VECSUB(co, co2, co1);
                        VECMUL(co, x);
@@ -602,7 +608,7 @@ static void bmesh_loop_interp_mdisps(BMesh *bm, BMLoop *target, BMFace *source)
                                        /* int ix2 = (int)x2; */ /* UNUSED */
                                        /* int iy2 = (int)y2; */ /* UNUSED */
                                        
-                                       old_mdisps_bilinear(md1->disps[iy*res+ix], md2->disps, res, (float)x2, (float)y2);
+                                       old_mdisps_bilinear(md1->disps[iy * res + ix], md2->disps, res, (float)x2, (float)y2);
                                }
                                l2 = l2->next;
                        } while (l2 != bm_firstfaceloop(source));
@@ -626,22 +632,22 @@ void BM_multires_smooth_bounds(BMesh *bm, BMFace *f)
                int sides;
                int y;
                
-               /*****
-               mdisps is a grid of displacements, ordered thus:
-               
-                                  v4/next
-                                    |                          
-                |      v1/cent-----mid2 ---> x
-                |         |         | 
-                |         |         |
-               v2/prev---mid1-----v3/cur
-                          |
-                          V
-                          y
-               *****/
+               /*
+                *  mdisps is a grid of displacements, ordered thus:
+                *  
+                *                     v4/next
+                *                       |                              
+                *   |      v1/cent-----mid2 ---> x
+                *   |         |         | 
+                *   |         |         |
+                *  v2/prev---mid1-----v3/cur
+                *             |
+                *             V
+                *             y
+                */
                  
                sides = (int)sqrt(mdp->totdisp);
-               for (y=0; y<sides; y++) {
+               for (y = 0; y < sides; y++) {
                        add_v3_v3v3(co1, mdn->disps[y*sides], mdl->disps[y]);
                        mul_v3_fl(co1, 0.5);
 
@@ -657,19 +663,19 @@ void BM_multires_smooth_bounds(BMesh *bm, BMFace *f)
                int sides;
                int y;
                
-               /*****
-               mdisps is a grid of displacements, ordered thus:
-               
-                                  v4/next
-                                    |                          
-                |      v1/cent-----mid2 ---> x
-                |         |         | 
-                |         |         |
-               v2/prev---mid1-----v3/cur
-                          |
-                          V
-                          y
-               *****/
+               /*
+                *  mdisps is a grid of displacements, ordered thus:
+                *  
+                *                     v4/next
+                *                       |                              
+                *   |      v1/cent-----mid2 ---> x
+                *   |         |         | 
+                *   |         |         |
+                *  v2/prev---mid1-----v3/cur
+                *             |
+                *             V
+                *             y
+                */
                 
                if (l->radial_next == l)
                        continue;
@@ -680,24 +686,24 @@ void BM_multires_smooth_bounds(BMesh *bm, BMFace *f)
                        mdl2 = CustomData_bmesh_get(&bm->ldata, l->radial_next->next->head.data, CD_MDISPS);
                        
                sides = (int)sqrt(mdl1->totdisp);
-               for (y=0; y<sides; y++) {
+               for (y = 0; y < sides; y++) {
                        int a1, a2, o1, o2;
                        
                        if (l->v != l->radial_next->v) {
                                a1 = sides*y + sides-2;
                                a2 = (sides-2)*sides + y;
                                
-                               o1 = sides*y + sides-1;
-                               o2 = (sides-1)*sides + y;
+                               o1 = sides * y + sides - 1;
+                               o2 = (sides - 1) * sides + y;
                        }
                        else {
-                               a1 = sides*y + sides-2;
-                               a2 = sides*y + sides-2;
-                               o1 = sides*y + sides-1;
-                               o2 = sides*y + sides-1;
+                               a1 = sides * y + sides - 2;
+                               a2 = sides * y + sides - 2;
+                               o1 = sides * y + sides - 1;
+                               o2 = sides * y + sides - 1;
                        }
                        
-                       /*magic blending numbers, hardcoded!*/
+                       /* magic blending numbers, hardcoded! */
                        add_v3_v3v3(co1, mdl1->disps[a1], mdl2->disps[a2]);
                        mul_v3_fl(co1, 0.18);
                        
@@ -707,7 +713,7 @@ void BM_multires_smooth_bounds(BMesh *bm, BMFace *f)
                        add_v3_v3v3(co, co1, co2);
                        
                        copy_v3_v3(mdl1->disps[o1], co);
-                       copy_v3_v3(mdl2->disps[o2], co); //*/
+                       copy_v3_v3(mdl2->disps[o2], co);
                }
        }
 }
@@ -722,9 +728,9 @@ void BM_loop_interp_from_face(BMesh *bm, BMLoop *target, BMFace *source,
 {
        BMLoop *l;
        BMLoop *l_first;
-       void **blocks=NULL;
-       void **vblocks=NULL;
-       float (*cos)[3]=NULL, co[3], *w=NULL, cent[3] = {0.0f, 0.0f, 0.0f};
+       void **blocks = NULL;
+       void **vblocks = NULL;
+       float (*cos)[3] = NULL, co[3], *w = NULL, cent[3] = {0.0f, 0.0f, 0.0f};
        BLI_array_fixedstack_declare(cos,      BM_NGON_STACK_SIZE, source->len, __func__);
        BLI_array_fixedstack_declare(w,        BM_NGON_STACK_SIZE, source->len, __func__);
        BLI_array_fixedstack_declare(blocks,   BM_NGON_STACK_SIZE, source->len, __func__);
@@ -755,9 +761,9 @@ void BM_loop_interp_from_face(BMesh *bm, BMLoop *target, BMFace *source,
        axis_dominant_v3(&ax, &ay, source->no);
 
        /* scale source face coordinates a bit, so points sitting directonly on an
-          edge will work.*/
-       mul_v3_fl(cent, 1.0f/(float)source->len);
-       for (i=0; i<source->len; i++) {
+          edge will work. */
+       mul_v3_fl(cent, 1.0f / (float)source->len);
+       for (i = 0; i < source->len; i++) {
                float vec[3], tmp[3];
                sub_v3_v3v3(vec, cent, cos[i]);
                mul_v3_fl(vec, 0.001f);
@@ -770,7 +776,7 @@ void BM_loop_interp_from_face(BMesh *bm, BMLoop *target, BMFace *source,
        }
        
        
-       /*interpolate*/
+       /* interpolate */
        co[0] = target->v->co[ax];
        co[1] = target->v->co[ay];
        co[2] = 0.0f;
@@ -798,8 +804,8 @@ void BM_vert_interp_from_face(BMesh *bm, BMVert *v, BMFace *source)
 {
        BMLoop *l;
        BMLoop *l_first;
-       void **blocks=NULL;
-       float (*cos)[3]=NULL, *w=NULL, cent[3] = {0.0f, 0.0f, 0.0f};
+       void **blocks = NULL;
+       float (*cos)[3] = NULL, *w = NULL, cent[3] = {0.0f, 0.0f, 0.0f};
        BLI_array_fixedstack_declare(cos,      BM_NGON_STACK_SIZE, source->len, __func__);
        BLI_array_fixedstack_declare(w,        BM_NGON_STACK_SIZE, source->len, __func__);
        BLI_array_fixedstack_declare(blocks,   BM_NGON_STACK_SIZE, source->len, __func__);
@@ -817,8 +823,8 @@ void BM_vert_interp_from_face(BMesh *bm, BMVert *v, BMFace *source)
        } while ((l = l->next) != l_first);
 
        /* scale source face coordinates a bit, so points sitting directonly on an
-     * edge will work.*/
-       mul_v3_fl(cent, 1.0f/(float)source->len);
+     * edge will work. */
+       mul_v3_fl(cent, 1.0f / (float)source->len);
        for (i = 0; i < source->len; i++) {
                float vec[3];
                sub_v3_v3v3(vec, cent, cos[i]);
@@ -826,7 +832,7 @@ void BM_vert_interp_from_face(BMesh *bm, BMVert *v, BMFace *source)
                add_v3_v3(cos[i], vec);
        }
        
-       /*interpolate*/
+       /* interpolate */
        interp_weights_poly_v3(w, cos, source->len, v->co);
        CustomData_bmesh_interp(&bm->vdata, blocks, w, NULL, source->len, v->head.data);
        
@@ -841,7 +847,7 @@ static void update_data_blocks(BMesh *bm, CustomData *olddata, CustomData *data)
        BLI_mempool *oldpool = olddata->pool;
        void *block;
 
-       CustomData_bmesh_init_pool(data, data==&bm->ldata ? 2048 : 512);
+       CustomData_bmesh_init_pool(data, data == &bm->ldata ? 2048 : 512);
 
        if (data == &bm->vdata) {
                BMVert *eve;
@@ -851,7 +857,7 @@ static void update_data_blocks(BMesh *bm, CustomData *olddata, CustomData *data)
                        CustomData_bmesh_set_default(data, &block);
                        CustomData_bmesh_copy_data(olddata, data, eve->head.data, &block);
                        CustomData_bmesh_free_block(olddata, &eve->head.data);
-                       eve->head.data= block;
+                       eve->head.data = block;
                }
        }
        else if (data == &bm->edata) {
@@ -862,7 +868,7 @@ static void update_data_blocks(BMesh *bm, CustomData *olddata, CustomData *data)
                        CustomData_bmesh_set_default(data, &block);
                        CustomData_bmesh_copy_data(olddata, data, eed->head.data, &block);
                        CustomData_bmesh_free_block(olddata, &eed->head.data);
-                       eed->head.data= block;
+                       eed->head.data = block;
                }
        }
        else if (data == &bm->pdata || data == &bm->ldata) {
@@ -876,7 +882,7 @@ static void update_data_blocks(BMesh *bm, CustomData *olddata, CustomData *data)
                                CustomData_bmesh_set_default(data, &block);
                                CustomData_bmesh_copy_data(olddata, data, efa->head.data, &block);
                                CustomData_bmesh_free_block(olddata, &efa->head.data);
-                               efa->head.data= block;
+                               efa->head.data = block;
                        }
 
                        if (data == &bm->ldata) {
@@ -885,7 +891,7 @@ static void update_data_blocks(BMesh *bm, CustomData *olddata, CustomData *data)
                                        CustomData_bmesh_set_default(data, &block);
                                        CustomData_bmesh_copy_data(olddata, data, l->head.data, &block);
                                        CustomData_bmesh_free_block(olddata, &l->head.data);
-                                       l->head.data= block;
+                                       l->head.data = block;
                                }
                        }
                }
@@ -903,8 +909,8 @@ void BM_add_data_layer(BMesh *bm, CustomData *data, int type)
 {
        CustomData olddata;
 
-       olddata= *data;
-       olddata.layers= (olddata.layers)? MEM_dupallocN(olddata.layers): NULL;
+       olddata = *data;
+       olddata.layers = (olddata.layers) ? MEM_dupallocN(olddata.layers): NULL;
 
        /* the pool is now owned by olddata and must not be shared */
        data->pool = NULL;
@@ -919,8 +925,8 @@ void BM_add_data_layer_named(BMesh *bm, CustomData *data, int type, const char *
 {
        CustomData olddata;
 
-       olddata= *data;
-       olddata.layers= (olddata.layers)? MEM_dupallocN(olddata.layers): NULL;
+       olddata = *data;
+       olddata.layers = (olddata.layers) ? MEM_dupallocN(olddata.layers): NULL;
 
        /* the pool is now owned by olddata and must not be shared */
        data->pool = NULL;
@@ -935,8 +941,8 @@ void BM_free_data_layer(BMesh *bm, CustomData *data, int type)
 {
        CustomData olddata;
 
-       olddata= *data;
-       olddata.layers= (olddata.layers)? MEM_dupallocN(olddata.layers): NULL;
+       olddata = *data;
+       olddata.layers = (olddata.layers) ? MEM_dupallocN(olddata.layers): NULL;
 
        /* the pool is now owned by olddata and must not be shared */
        data->pool = NULL;
@@ -951,8 +957,8 @@ void BM_free_data_layer_n(BMesh *bm, CustomData *data, int type, int n)
 {
        CustomData olddata;
 
-       olddata= *data;
-       olddata.layers= (olddata.layers)? MEM_dupallocN(olddata.layers): NULL;
+       olddata = *data;
+       olddata.layers = (olddata.layers) ? MEM_dupallocN(olddata.layers): NULL;
 
        /* the pool is now owned by olddata and must not be shared */
        data->pool = NULL;
@@ -965,12 +971,12 @@ void BM_free_data_layer_n(BMesh *bm, CustomData *data, int type, int n)
 
 float BM_GetCDf(CustomData *cd, void *element, int type)
 {
-       float *f = CustomData_bmesh_get(cd, ((BMHeader*)element)->data, type);
+       float *f = CustomData_bmesh_get(cd, ((BMHeader *)element)->data, type);
        return f ? *f : 0.0f;
 }
 
 void BM_SetCDf(CustomData *cd, void *element, int type, float val)
 {
-       float *f = CustomData_bmesh_get(cd, ((BMHeader*)element)->data, type);
+       float *f = CustomData_bmesh_get(cd, ((BMHeader *)element)->data, type);
        if (f) *f = val;
 }
index 9f446eec1f8de4490b25e5808ff1f9f9565495d5..43e2a160caea507a26231164545f49627d78e52a 100644 (file)
@@ -42,14 +42,16 @@ void *BMIter_AtIndex(struct BMesh *bm, const char itype, void *data, int index)
        void *val;
        int i;
 
-       /*sanity check*/
-       if (index < 0) return NULL;
+       /* sanity check */
+       if (index < 0) {
+               return NULL;
+       }
 
-       val=BMIter_New(&iter, bm, itype, data);
+       val = BMIter_New(&iter, bm, itype, data);
 
        i = 0;
        while (i < index) {
-               val=BMIter_Step(&iter);
+               val = BMIter_Step(&iter);
                i++;
        }
 
@@ -66,16 +68,16 @@ void *BMIter_AtIndex(struct BMesh *bm, const char itype, void *data, int index)
 
 int BMIter_AsArray(struct BMesh *bm, const char type, void *data, void **array, const int len)
 {
-       int i= 0;
+       int i = 0;
 
-       /*sanity check*/
+       /* sanity check */
        if (len > 0) {
 
                BMIter iter;
                void *val;
 
                BM_ITER(val, &iter, bm, type, data) {
-                       array[i]= val;
+                       array[i] = val;
                        i++;
                        if (i == len) {
                                return len;
@@ -93,7 +95,7 @@ int BMIter_AsArray(struct BMesh *bm, const char type, void *data, void **array,
  * Clears the internal state of an iterator
  * For begin() callbacks.
  *
-*/
+ */
 
 static void init_iterator(BMIter *iter)
 {
@@ -124,7 +126,7 @@ static void init_iterator(BMIter *iter)
 /*
  * VERT OF MESH CALLBACKS
  *
-*/
+ */
 
 void bmiter__vert_of_mesh_begin(BMIter *iter)
 {
@@ -162,7 +164,7 @@ void  *bmiter__face_of_mesh_step(BMIter *iter)
 /*
  * EDGE OF VERT CALLBACKS
  *
-*/
+ */
 
 void  bmiter__edge_of_vert_begin(BMIter *iter)
 {
@@ -188,7 +190,7 @@ void  *bmiter__edge_of_vert_step(BMIter *iter)
 /*
  * FACE OF VERT CALLBACKS
  *
-*/
+ */
 
 void  bmiter__face_of_vert_begin(BMIter *iter)
 {
@@ -219,16 +221,14 @@ void  *bmiter__face_of_vert_step(BMIter *iter)
        
        if (!iter->count) iter->nextloop = NULL;
 
-       
-       if (current) return current->f;
-       return NULL;
+       return current ? current->f : NULL;
 }
 
 
 /*
  * LOOP OF VERT CALLBACKS
  *
-*/
+ */
 
 void  bmiter__loop_of_vert_begin(BMIter *iter)
 {
@@ -271,7 +271,7 @@ void  bmiter__loops_of_edge_begin(BMIter *iter)
 
        l = iter->edata->l;
 
-       /*note sure why this sets ldata. . .*/
+       /* note sure why this sets ldata ... */
        init_iterator(iter);
        
        iter->firstloop = iter->nextloop = l;
@@ -297,7 +297,7 @@ void  bmiter__loops_of_loop_begin(BMIter *iter)
 
        l = iter->ldata;
 
-       /*note sure why this sets ldata. . .*/
+       /* note sure why this sets ldata ... */
        init_iterator(iter);
 
        iter->firstloop = l;
@@ -321,7 +321,7 @@ void  *bmiter__loops_of_loop_step(BMIter *iter)
 /*
  * FACE OF EDGE CALLBACKS
  *
-*/
+ */
 
 void  bmiter__face_of_edge_begin(BMIter *iter)
 {
@@ -340,19 +340,19 @@ void  *bmiter__face_of_edge_step(BMIter *iter)
        if (iter->nextloop) iter->nextloop = bmesh_radial_nextloop(iter->nextloop);
 
        if (iter->nextloop == iter->firstloop) iter->nextloop = NULL;
-       if (current) return current->f;
-       return NULL;
+
+       return current ? current->f : NULL;
 }
 
 /*
  * VERT OF FACE CALLBACKS
  *
-*/
+ */
 
 void  bmiter__vert_of_face_begin(BMIter *iter)
 {
        init_iterator(iter);
-       iter->firstloop = iter->nextloop = ((BMLoopList*)iter->pdata->loops.first)->first;
+       iter->firstloop = iter->nextloop = ((BMLoopList *)iter->pdata->loops.first)->first;
 }
 
 void  *bmiter__vert_of_face_step(BMIter *iter)
@@ -362,19 +362,18 @@ void  *bmiter__vert_of_face_step(BMIter *iter)
        if (iter->nextloop) iter->nextloop = iter->nextloop->next;
        if (iter->nextloop == iter->firstloop) iter->nextloop = NULL;
 
-       if (current) return current->v;
-       return NULL;
+       return current ? current->v : NULL;
 }
 
 /*
  * EDGE OF FACE CALLBACKS
  *
-*/
+ */
 
 void  bmiter__edge_of_face_begin(BMIter *iter)
 {
        init_iterator(iter);
-       iter->firstloop = iter->nextloop = ((BMLoopList*)iter->pdata->loops.first)->first;
+       iter->firstloop = iter->nextloop = ((BMLoopList *)iter->pdata->loops.first)->first;
 }
 
 void  *bmiter__edge_of_face_step(BMIter *iter)
@@ -384,14 +383,13 @@ void  *bmiter__edge_of_face_step(BMIter *iter)
        if (iter->nextloop) iter->nextloop = iter->nextloop->next;
        if (iter->nextloop == iter->firstloop) iter->nextloop = NULL;
        
-       if (current) return current->e;
-       return NULL;
+       return current ? current->e : NULL;
 }
 
 /*
  * LOOP OF FACE CALLBACKS
  *
-*/
+ */
 
 void  bmiter__loop_of_face_begin(BMIter *iter)
 {
index cf621ee938f8fc3b2323fb7c50d24e66b350552a..eb04fe068a74475c28dcad552141ded6b4c08d7a 100644 (file)
@@ -39,7 +39,7 @@
  *
  *  Calls an iterators step fucntion to return
  *  the next element.
-*/
+ */
 
 BM_INLINE void *BMIter_Step(BMIter *iter)
 {
@@ -55,7 +55,7 @@ BM_INLINE void *BMIter_Step(BMIter *iter)
  * upon its type and then calls BMeshIter_step()
  * to return the first element of the iterator.
  *
-*/
+ */
 BM_INLINE void *BMIter_New(BMIter *iter, BMesh *bm, const char itype, void *data)
 {
        /* int argtype; */
index 7275648fd22e4f3cdb4a5e573c8762b0b537b236..8913f8339733c48609250a1a5c80b7b7752a4182 100644 (file)
@@ -52,7 +52,7 @@
  * should only be called by system and not
  * tool authors.
  *
-*/
+ */
 
 static void recount_totsels(BMesh *bm)
 {
@@ -62,15 +62,15 @@ static void recount_totsels(BMesh *bm)
        int *tots[3];
        int i;
 
-       /*recount tot*sel variables*/
+       /* recount tot*sel variables */
        bm->totvertsel = bm->totedgesel = bm->totfacesel = 0;
        tots[0] = &bm->totvertsel;
        tots[1] = &bm->totedgesel;
        tots[2] = &bm->totfacesel;
 
-       for (i=0; i<3; i++) {
+       for (i = 0; i < 3; i++) {
                ele = BMIter_New(&iter, bm, itypes[i], NULL);
-               for ( ; ele; ele=BMIter_Step(&iter)) {
+               for ( ; ele; ele = BMIter_Step(&iter)) {
                        if (BM_TestHFlag(ele, BM_SELECT)) *tots[i] += 1;
                }
        }
@@ -88,7 +88,7 @@ void BM_SelectMode_Flush(BMesh *bm)
        int totsel;
 
        if (bm->selectmode & SCE_SELECT_VERTEX) {
-               for (e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e= BMIter_Step(&edges)) {
+               for (e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)) {
                        if (BM_TestHFlag(e->v1, BM_SELECT) && BM_TestHFlag(e->v2, BM_SELECT) && !BM_TestHFlag(e, BM_HIDDEN)) {
                                BM_SetHFlag(e, BM_SELECT);
                        }
@@ -96,9 +96,9 @@ void BM_SelectMode_Flush(BMesh *bm)
                                BM_ClearHFlag(e, BM_SELECT);
                        }
                }
-               for (f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f= BMIter_Step(&faces)) {
+               for (f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces)) {
                        totsel = 0;
-                       l=(BMLoop*) bm_firstfaceloop(f);
+                       l = (BMLoop *) bm_firstfaceloop(f);
                        do {
                                if (BM_TestHFlag(l->v, BM_SELECT))
                                        totsel++;
@@ -114,14 +114,14 @@ void BM_SelectMode_Flush(BMesh *bm)
                }
        }
        else if (bm->selectmode & SCE_SELECT_EDGE) {
-               for (f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f= BMIter_Step(&faces)) {
+               for (f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces)) {
                        totsel = 0;
                        l = bm_firstfaceloop(f);
                        do {
                                if (BM_TestHFlag(&(l->e->head), BM_SELECT))
                                        totsel++;
                                l = l->next;
-                       } while (l!=bm_firstfaceloop(f));
+                       } while (l != bm_firstfaceloop(f));
                        
                        if (totsel == f->len && !BM_TestHFlag(f, BM_HIDDEN)) {
                                BM_SetHFlag(f, BM_SELECT);
@@ -132,7 +132,7 @@ void BM_SelectMode_Flush(BMesh *bm)
                }
        }
 
-       /*Remove any deselected elements from the BMEditSelection*/
+       /* Remove any deselected elements from the BMEditSelection */
        BM_validate_selections(bm);
 
        recount_totsels(bm);
@@ -144,7 +144,7 @@ void BM_SelectMode_Flush(BMesh *bm)
  * Changes selection state of a single vertex 
  * in a mesh
  *
-*/
+ */
 
 void BM_Select_Vert(BMesh *bm, BMVert *v, int select)
 {
@@ -175,7 +175,7 @@ void BM_Select_Vert(BMesh *bm, BMVert *v, int select)
  * Changes selection state of a single edge
  * in a mesh.
  *
-*/
+ */
 
 void BM_Select_Edge(BMesh *bm, BMEdge *e, int select)
 {
@@ -236,7 +236,7 @@ void BM_Select_Edge(BMesh *bm, BMEdge *e, int select)
  * Changes selection state of a single
  * face in a mesh.
  *
-*/
+ */
 
 void BM_Select_Face(BMesh *bm, BMFace *f, int select)
 {
@@ -250,7 +250,7 @@ void BM_Select_Face(BMesh *bm, BMFace *f, int select)
                if (!BM_TestHFlag(f, BM_SELECT)) bm->totfacesel += 1;
 
                BM_SetHFlag(&(f->head), BM_SELECT);
-               l=(BMLoop*) bm_firstfaceloop(f);
+               l = (BMLoop *) bm_firstfaceloop(f);
                do {
                        BM_Select_Vert(bm, l->v, TRUE);
                        BM_Select_Edge(bm, l->e, TRUE);
@@ -264,7 +264,7 @@ void BM_Select_Face(BMesh *bm, BMFace *f, int select)
                if (BM_TestHFlag(f, BM_SELECT)) bm->totfacesel -= 1;
                BM_ClearHFlag(&(f->head), BM_SELECT);
 
-               /*flush down to edges*/
+               /* flush down to edges */
                BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, f) {
                        BMIter fiter;
                        BMFace *f2;
@@ -279,7 +279,7 @@ void BM_Select_Face(BMesh *bm, BMFace *f, int select)
                        }
                }
 
-               /*flush down to verts*/
+               /* flush down to verts */
                BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, f) {
                        BMIter eiter;
                        BMEdge *e;
@@ -300,7 +300,7 @@ void BM_Select_Face(BMesh *bm, BMFace *f, int select)
  *
  * Sets the selection mode for the bmesh
  *
-*/
+ */
 
 void BM_Selectmode_Set(BMesh *bm, int selectmode)
 {
@@ -315,16 +315,16 @@ void BM_Selectmode_Set(BMesh *bm, int selectmode)
        bm->selectmode = selectmode;
 
        if (bm->selectmode & SCE_SELECT_VERTEX) {
-               for (e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e= BMIter_Step(&edges))
+               for (e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges))
                        BM_ClearHFlag(e, 0);
-               for (f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f= BMIter_Step(&faces))
+               for (f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces))
                        BM_ClearHFlag(f, 0);
                BM_SelectMode_Flush(bm);
        }
        else if (bm->selectmode & SCE_SELECT_EDGE) {
-               for (v= BMIter_New(&verts, bm, BM_VERTS_OF_MESH, bm); v; v= BMIter_Step(&verts))
+               for (v = BMIter_New(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BMIter_Step(&verts))
                        BM_ClearHFlag(v, 0);
-               for (e= BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e= BMIter_Step(&edges)) {
+               for (e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)) {
                        if (BM_TestHFlag(&(e->head), BM_SELECT)) {
                                BM_Select_Edge(bm, e, TRUE);
                        }
@@ -332,9 +332,9 @@ void BM_Selectmode_Set(BMesh *bm, int selectmode)
                BM_SelectMode_Flush(bm);
        }
        else if (bm->selectmode & SCE_SELECT_FACE) {
-               for (e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e= BMIter_Step(&edges))
+               for (e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges))
                        BM_ClearHFlag(e, 0);
-               for (f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f= BMIter_Step(&faces)) {
+               for (f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces)) {
                        if (BM_TestHFlag(&(f->head), BM_SELECT)) {
                                BM_Select_Face(bm, f, TRUE);
                        }
@@ -351,19 +351,19 @@ int BM_CountFlag(struct BMesh *bm, const char htype, const char hflag, int respe
        int tot = 0;
 
        if (htype & BM_VERT) {
-               for (head = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL); head; head=BMIter_Step(&iter)) {
+               for (head = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL); head; head = BMIter_Step(&iter)) {
                        if (respecthide && BM_TestHFlag(head, BM_HIDDEN)) continue;
                        if (BM_TestHFlag(head, hflag)) tot++;
                }
        }
        if (htype & BM_EDGE) {
-               for (head = BMIter_New(&iter, bm, BM_EDGES_OF_MESH, NULL); head; head=BMIter_Step(&iter)) {
+               for (head = BMIter_New(&iter, bm, BM_EDGES_OF_MESH, NULL); head; head = BMIter_Step(&iter)) {
                        if (respecthide && BM_TestHFlag(head, BM_HIDDEN)) continue;
                        if (BM_TestHFlag(head, hflag)) tot++;
                }
        }
        if (htype & BM_FACE) {
-               for (head = BMIter_New(&iter, bm, BM_FACES_OF_MESH, NULL); head; head=BMIter_Step(&iter)) {
+               for (head = BMIter_New(&iter, bm, BM_FACES_OF_MESH, NULL); head; head = BMIter_Step(&iter)) {
                        if (respecthide && BM_TestHFlag(head, BM_HIDDEN)) continue;
                        if (BM_TestHFlag(head, hflag)) tot++;
                }
@@ -372,14 +372,14 @@ int BM_CountFlag(struct BMesh *bm, const char htype, const char hflag, int respe
        return tot;
 }
 
-/*note: by design, this will not touch the editselection history stuff*/
+/* note: by design, this will not touch the editselection history stuff */
 void BM_Select(struct BMesh *bm, void *element, int select)
 {
        BMHeader *head = element;
 
-       if     (head->htype == BM_VERT) BM_Select_Vert(bm, (BMVert*)element, select);
-       else if (head->htype == BM_EDGE) BM_Select_Edge(bm, (BMEdge*)element, select);
-       else if (head->htype == BM_FACE) BM_Select_Face(bm, (BMFace*)element, select);
+       if      (head->htype == BM_VERT) BM_Select_Vert(bm, (BMVert *)element, select);
+       else if (head->htype == BM_EDGE) BM_Select_Edge(bm, (BMEdge *)element, select);
+       else if (head->htype == BM_FACE) BM_Select_Face(bm, (BMFace *)element, select);
 }
 
 int BM_Selected(BMesh *UNUSED(bm), const void *element)
@@ -403,17 +403,17 @@ BMFace *BM_get_actFace(BMesh *bm, int sloppy)
        }
        else if (sloppy) {
                BMIter iter;
-               BMFace *f= NULL;
+               BMFace *f = NULL;
                BMEditSelection *ese;
                
                /* Find the latest non-hidden face from the BMEditSelection */
                ese = bm->selected.last;
-               for ( ; ese; ese=ese->prev) {
+               for ( ; ese; ese = ese->prev) {
                        if (ese->htype == BM_FACE) {
-                               f= (BMFace *)ese->data;
+                               f = (BMFace *)ese->data;
                                
                                if (BM_TestHFlag(f, BM_HIDDEN)) {
-                                       f= NULL;
+                                       f = NULL;
                                }
                                else {
                                        break;
@@ -421,7 +421,7 @@ BMFace *BM_get_actFace(BMesh *bm, int sloppy)
                        }
                }
                /* Last attempt: try to find any selected face */
-               if (f==NULL) {
+               if (f == NULL) {
                        BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
                                if (BM_TestHFlag(f, BM_SELECT)) {
                                        break;
@@ -440,20 +440,20 @@ BMFace *BM_get_actFace(BMesh *bm, int sloppy)
  * - EM_editselection_center
  * - EM_editselection_normal
  * - EM_editselection_plane
-*/
+ */
 void BM_editselection_center(BMesh *bm, float r_center[3], BMEditSelection *ese)
 {
        if (ese->htype == BM_VERT) {
-               BMVert *eve= ese->data;
+               BMVert *eve = ese->data;
                copy_v3_v3(r_center, eve->co);
        }
        else if (ese->htype == BM_EDGE) {
-               BMEdge *eed= ese->data;
+               BMEdge *eed = ese->data;
                add_v3_v3v3(r_center, eed->v1->co, eed->v2->co);
                mul_v3_fl(r_center, 0.5);
        }
        else if (ese->htype == BM_FACE) {
-               BMFace *efa= ese->data;
+               BMFace *efa = ese->data;
                BM_Compute_Face_CenterBounds(bm, efa, r_center);
        }
 }
@@ -461,11 +461,11 @@ void BM_editselection_center(BMesh *bm, float r_center[3], BMEditSelection *ese)
 void BM_editselection_normal(float r_normal[3], BMEditSelection *ese)
 {
        if (ese->htype == BM_VERT) {
-               BMVert *eve= ese->data;
+               BMVert *eve = ese->data;
                copy_v3_v3(r_normal, eve->no);
        }
        else if (ese->htype == BM_EDGE) {
-               BMEdge *eed= ese->data;
+               BMEdge *eed = ese->data;
                float plane[3]; /* need a plane to correct the normal */
                float vec[3]; /* temp vec storage */
                
@@ -473,16 +473,16 @@ void BM_editselection_normal(float r_normal[3], BMEditSelection *ese)
                sub_v3_v3v3(plane, eed->v2->co, eed->v1->co);
                
                /* the 2 vertex normals will be close but not at rightangles to the edge
-               for rotate about edge we want them to be at right angles, so we need to
-               do some extra colculation to correct the vert normals,
-               we need the plane for this */
+                * for rotate about edge we want them to be at right angles, so we need to
+                * do some extra colculation to correct the vert normals,
+                * we need the plane for this */
                cross_v3_v3v3(vec, r_normal, plane);
                cross_v3_v3v3(r_normal, plane, vec);
                normalize_v3(r_normal);
                
        }
        else if (ese->htype == BM_FACE) {
-               BMFace *efa= ese->data;
+               BMFace *efa = ese->data;
                copy_v3_v3(r_normal, efa->no);
        }
 }
@@ -490,62 +490,64 @@ void BM_editselection_normal(float r_normal[3], BMEditSelection *ese)
 /* ref - editmesh_lib.cL:EM_editselection_plane() */
 
 /* Calculate a plane that is rightangles to the edge/vert/faces normal
-also make the plane run along an axis that is related to the geometry,
-because this is used for the manipulators Y axis.*/
+ * also make the plane run along an axis that is related to the geometry,
+ * because this is used for the manipulators Y axis. */
 void BM_editselection_plane(BMesh *bm, float r_plane[3], BMEditSelection *ese)
 {
        if (ese->htype == BM_VERT) {
-               BMVert *eve= ese->data;
-               float vec[3]={0,0,0};
+               BMVert *eve = ese->data;
+               float vec[3] = {0.0f, 0.0f, 0.0f};
                
-               if (ese->prev) { /*use previously selected data to make a useful vertex plane */
+               if (ese->prev) { /* use previously selected data to make a useful vertex plane */
                        BM_editselection_center(bm, vec, ese->prev);
                        sub_v3_v3v3(r_plane, vec, eve->co);
                }
                else {
                        /* make a fake  plane thats at rightangles to the normal
-                       we cant make a crossvec from a vec thats the same as the vec
-                       unlikely but possible, so make sure if the normal is (0,0,1)
-                       that vec isnt the same or in the same direction even.*/
-                       if (eve->no[0] < 0.5f)          vec[0]= 1.0f;
-                       else if (eve->no[1] < 0.5f)     vec[1]= 1.0f;
-                       else                                            vec[2]= 1.0f;
+                        * we cant make a crossvec from a vec thats the same as the vec
+                        * unlikely but possible, so make sure if the normal is (0, 0, 1)
+                        * that vec isnt the same or in the same direction even. */
+                       if (eve->no[0] < 0.5f)          vec[0] = 1.0f;
+                       else if (eve->no[1] < 0.5f)     vec[1] = 1.0f;
+                       else                                            vec[2] = 1.0f;
                        cross_v3_v3v3(r_plane, eve->no, vec);
                }
        }
        else if (ese->htype == BM_EDGE) {
-               BMEdge *eed= ese->data;
+               BMEdge *eed = ese->data;
 
                /* the plane is simple, it runs along the edge
-               however selecting different edges can swap the direction of the y axis.
-               this makes it less likely for the y axis of the manipulator
-               (running along the edge).. to flip less often.
-               at least its more pradictable */
-               if (eed->v2->co[1] > eed->v1->co[1]) /*check which to do first */
+                * however selecting different edges can swap the direction of the y axis.
+                * this makes it less likely for the y axis of the manipulator
+                * (running along the edge).. to flip less often.
+                * at least its more pradictable */
+               if (eed->v2->co[1] > eed->v1->co[1]) {  /* check which to do first */
                        sub_v3_v3v3(r_plane, eed->v2->co, eed->v1->co);
-               else
+               }
+               else {
                        sub_v3_v3v3(r_plane, eed->v1->co, eed->v2->co);
+               }
                
        }
        else if (ese->htype == BM_FACE) {
-               BMFace *efa= ese->data;
+               BMFace *efa = ese->data;
                float vec[3] = {0.0f, 0.0f, 0.0f};
                
-               /*for now, use face normal*/
+               /* for now, use face normal */
 
                /* make a fake plane thats at rightangles to the normal
-               we cant make a crossvec from a vec thats the same as the vec
-               unlikely but possible, so make sure if the normal is (0,0,1)
-               that vec isnt the same or in the same direction even.*/
+                * we cant make a crossvec from a vec thats the same as the vec
+                * unlikely but possible, so make sure if the normal is (0, 0, 1)
+                * that vec isnt the same or in the same direction even. */
                if (efa->len < 3) {
                        /* crappy fallback method */
-                       if      (efa->no[0] < 0.5f)     vec[0]= 1.0f;
-                       else if (efa->no[1] < 0.5f)     vec[1]= 1.0f;
-                       else                        vec[2]= 1.0f;
+                       if      (efa->no[0] < 0.5f)     vec[0] = 1.0f;
+                       else if (efa->no[1] < 0.5f)     vec[1] = 1.0f;
+                       else                        vec[2] = 1.0f;
                        cross_v3_v3v3(r_plane, efa->no, vec);
                }
                else {
-                       BMVert *verts[4]= {NULL};
+                       BMVert *verts[4] = {NULL};
 
                        BMIter_AsArray(bm, BM_VERTS_OF_FACE, efa, (void **)verts, 4);
 
@@ -558,7 +560,7 @@ void BM_editselection_plane(BMesh *bm, float r_plane[3], BMEditSelection *ese)
                                sub_v3_v3v3(vecA, verts[0]->co, verts[3]->co);
                                sub_v3_v3v3(vecB, verts[1]->co, verts[2]->co);
                                add_v3_v3v3(vec, vecA, vecB);
-                               /*use the biggest edge length*/
+                               /* use the biggest edge length */
                                if (dot_v3v3(r_plane, r_plane) < dot_v3v3(vec, vec)) {
                                        copy_v3_v3(r_plane, vec);
                                }
@@ -566,15 +568,15 @@ void BM_editselection_plane(BMesh *bm, float r_plane[3], BMEditSelection *ese)
                        else {
                                /* BMESH_TODO (not urgent, use longest ngon edge for alignment) */
 
-                               /*start with v1-2 */
+                               /* start with v1-2 */
                                sub_v3_v3v3(r_plane, verts[0]->co, verts[1]->co);
 
-                               /*test the edge between v2-3, use if longer */
+                               /* test the edge between v2-3, use if longer */
                                sub_v3_v3v3(vec, verts[1]->co, verts[2]->co);
                                if (dot_v3v3(r_plane, r_plane) < dot_v3v3(vec, vec))
                                        copy_v3_v3(r_plane, vec);
 
-                               /*test the edge between v1-3, use if longer */
+                               /* test the edge between v1-3, use if longer */
                                sub_v3_v3v3(vec, verts[2]->co, verts[0]->co);
                                if (dot_v3v3(r_plane, r_plane) < dot_v3v3(vec, vec)) {
                                        copy_v3_v3(r_plane, vec);
@@ -591,18 +593,20 @@ static int BM_check_selection(BMesh *bm, void *data)
        BMEditSelection *ese;
        
        for (ese = bm->selected.first; ese; ese = ese->next) {
-               if (ese->data == data) return 1;
+               if (ese->data == data) {
+                       return TRUE;
+               }
        }
        
-       return 0;
+       return FALSE;
 }
 
 void BM_remove_selection(BMesh *bm, void *data)
 {
        BMEditSelection *ese;
-       for (ese=bm->selected.first; ese; ese = ese->next) {
+       for (ese = bm->selected.first; ese; ese = ese->next) {
                if (ese->data == data) {
-                       BLI_freelinkN(&(bm->selected),ese);
+                       BLI_freelinkN(&(bm->selected), ese);
                        break;
                }
        }
@@ -618,10 +622,10 @@ void BM_store_selection(BMesh *bm, void *data)
 {
        BMEditSelection *ese;
        if (!BM_check_selection(bm, data)) {
-               ese = (BMEditSelection*) MEM_callocN(sizeof(BMEditSelection), "BMEdit Selection");
-               ese->htype = ((BMHeader*)data)->htype;
+               ese = (BMEditSelection *) MEM_callocN(sizeof(BMEditSelection), "BMEdit Selection");
+               ese->htype = ((BMHeader *)data)->htype;
                ese->data = data;
-               BLI_addtail(&(bm->selected),ese);
+               BLI_addtail(&(bm->selected), ese);
        }
 }
 
@@ -647,12 +651,13 @@ void BM_clear_flag_all(BMesh *bm, const char hflag)
        BMHeader *ele;
        int i;
 
-       if (hflag & BM_SELECT)
+       if (hflag & BM_SELECT) {
                BM_clear_selection_history(bm);
+       }
 
-       for (i=0; i<3; i++) {           
+       for (i = 0; i < 3; i++) {
                ele = BMIter_New(&iter, bm, itypes[i], NULL);
-               for ( ; ele; ele=BMIter_Step(&iter)) {
+               for ( ; ele; ele = BMIter_Step(&iter)) {
                        if (hflag & BM_SELECT) BM_Select(bm, ele, FALSE);
                        BM_ClearHFlag(ele, hflag);
                }
@@ -660,7 +665,7 @@ void BM_clear_flag_all(BMesh *bm, const char hflag)
 }
 
 
-/***************** Mesh Hiding stuff *************/
+/***************** Mesh Hiding stuff *********** */
 
 #define SETHIDE(ele) hide ? BM_SetHFlag(ele, BM_HIDDEN) : BM_ClearHFlag(ele, BM_HIDDEN);
 
@@ -692,7 +697,7 @@ static void edge_flush_hide(BMesh *bm, BMEdge *e)
 
 void BM_Hide_Vert(BMesh *bm, BMVert *v, int hide)
 {
-       /*vert hiding: vert + surrounding edges and faces*/
+       /* vert hiding: vert + surrounding edges and faces */
        BMIter iter, fiter;
        BMEdge *e;
        BMFace *f;
@@ -714,14 +719,14 @@ void BM_Hide_Edge(BMesh *bm, BMEdge *e, int hide)
        BMFace *f;
        /* BMVert *v; */
 
-       /*edge hiding: faces around the edge*/
+       /* edge hiding: faces around the edge */
        BM_ITER(f, &iter, bm, BM_FACES_OF_EDGE, e) {
                SETHIDE(f);
        }
        
        SETHIDE(e);
 
-       /*hide vertices if necassary*/
+       /* hide vertices if necassary */
        vert_flush_hide(bm, e->v1);
        vert_flush_hide(bm, e->v2);
 }
@@ -731,7 +736,6 @@ void BM_Hide_Face(BMesh *bm, BMFace *f, int hide)
        BMIter iter;
        BMLoop *l;
 
-       /**/
        SETHIDE(f);
 
        BM_ITER(l, &iter, bm, BM_LOOPS_OF_FACE, f) {
@@ -747,10 +751,11 @@ void BM_Hide(BMesh *bm, void *element, int hide)
 {
        BMHeader *h = element;
 
-       /*Follow convention of always deselecting before
-         hiding an element*/
-       if (hide)
+       /* Follow convention of always deselecting before
+        * hiding an element */
+       if (hide) {
                BM_Select(bm, element, FALSE);
+       }
 
        switch (h->htype) {
                case BM_VERT:
index 202a2fe7cfa8a9e29b4ac0bf9ebc164539f9cfa3..3fab6d6a5aa39ca5cfa2d06d61a72ea9a28776ca 100644 (file)
 #include "bmesh.h"
 #include "bmesh_private.h"
 
-/*bmesh_error stub*/
+/* bmesh_error stub */
 void bmesh_error(void)
 {
        printf("BM modelling error!\n");
 
        /* This placeholder assert makes modelling errors easier to catch
-          in the debugger, until bmesh_error is replaced with something
-          better. */
+        * in the debugger, until bmesh_error is replaced with something
+        * better. */
        BLI_assert(0);
 }
 
@@ -67,12 +67,12 @@ void bmesh_error(void)
  *  Returns -
  *  Pointer to a BM
  *
-*/
+ */
 
 BMesh *BM_Make_Mesh(struct Object *ob, int allocsize[4])
 {
-       /*allocate the structure*/
-       BMesh *bm = MEM_callocN(sizeof(BMesh),"BM");
+       /* allocate the structure */
+       BMesh *bm = MEM_callocN(sizeof(BMesh), __func__);
        int vsize, esize, lsize, fsize, lstsize;
 
        vsize = sizeof(BMVert);
@@ -83,14 +83,14 @@ BMesh *BM_Make_Mesh(struct Object *ob, int allocsize[4])
 
        bm->ob = ob;
        
-   /*allocate the memory pools for the mesh elements*/
+   /* allocate the memory pools for the mesh elements */
        bm->vpool = BLI_mempool_create(vsize, allocsize[0], allocsize[0], FALSE, TRUE);
        bm->epool = BLI_mempool_create(esize, allocsize[1], allocsize[1], FALSE, TRUE);
        bm->lpool = BLI_mempool_create(lsize, allocsize[2], allocsize[2], FALSE, FALSE);
        bm->looplistpool = BLI_mempool_create(lstsize, allocsize[3], allocsize[3], FALSE, FALSE);
        bm->fpool = BLI_mempool_create(fsize, allocsize[3], allocsize[3], FALSE, TRUE);
 
-       /*allocate one flag pool that we dont get rid of.*/
+       /* allocate one flag pool that we dont get rid of. */
        bm->toolflagpool = BLI_mempool_create(sizeof(BMFlagLayer), 512, 512, FALSE, FALSE);
        bm->stackdepth = 1;
        bm->totflags = 1;
@@ -102,7 +102,7 @@ BMesh *BM_Make_Mesh(struct Object *ob, int allocsize[4])
  *     BMESH FREE MESH
  *
  *     Frees a BMesh structure.
-*/
+ */
 
 void BM_Free_Mesh_Data(BMesh *bm)
 {
@@ -124,25 +124,25 @@ void BM_Free_Mesh_Data(BMesh *bm)
                for (l = BMIter_New(&loops, bm, BM_LOOPS_OF_FACE, f); l; l = BMIter_Step(&loops)) CustomData_bmesh_free_block(&(bm->ldata), &(l->head.data));
        }
 
-       /*Free custom data pools, This should probably go in CustomData_free?*/
+       /* Free custom data pools, This should probably go in CustomData_free? */
        if (bm->vdata.totlayer) BLI_mempool_destroy(bm->vdata.pool);
        if (bm->edata.totlayer) BLI_mempool_destroy(bm->edata.pool);
        if (bm->ldata.totlayer) BLI_mempool_destroy(bm->ldata.pool);
        if (bm->pdata.totlayer) BLI_mempool_destroy(bm->pdata.pool);
 
-       /*free custom data*/
-       CustomData_free(&bm->vdata,0);
-       CustomData_free(&bm->edata,0);
-       CustomData_free(&bm->ldata,0);
-       CustomData_free(&bm->pdata,0);
+       /* free custom data */
+       CustomData_free(&bm->vdata, 0);
+       CustomData_free(&bm->edata, 0);
+       CustomData_free(&bm->ldata, 0);
+       CustomData_free(&bm->pdata, 0);
 
-       /*destroy element pools*/
+       /* destroy element pools */
        BLI_mempool_destroy(bm->vpool);
        BLI_mempool_destroy(bm->epool);
        BLI_mempool_destroy(bm->lpool);
        BLI_mempool_destroy(bm->fpool);
 
-       /*destroy flag pool*/
+       /* destroy flag pool */
        BLI_mempool_destroy(bm->toolflagpool);
        BLI_mempool_destroy(bm->looplistpool);
 
@@ -159,18 +159,18 @@ void BM_Free_Mesh_Data(BMesh *bm)
 
 void BM_Clear_Mesh(BMesh *bm)
 {
-       /*allocate the structure*/
+       /* allocate the structure */
        int vsize, esize, lsize, fsize, lstsize;
-       /*I really need to make the allocation sizes defines, there's no reason why the API
-         should allow client code to mess around with this - joeedh*/
+       /* I really need to make the allocation sizes defines, there's no reason why the API
+        * should allow client code to mess around with this - joeedh */
        int allocsize[5] = {512, 512, 512, 2048, 512};
        Object *ob = bm->ob;
        
-       /*free old mesh*/
+       /* free old mesh */
        BM_Free_Mesh_Data(bm);
        memset(bm, 0, sizeof(BMesh));
        
-       /*re-initialize mesh*/
+       /* re-initialize mesh */
        vsize = sizeof(BMVert);
        esize = sizeof(BMEdge);
        lsize = sizeof(BMLoop);
@@ -179,14 +179,14 @@ void BM_Clear_Mesh(BMesh *bm)
 
        bm->ob = ob;
        
-   /*allocate the memory pools for the mesh elements*/
+   /* allocate the memory pools for the mesh elements */
        bm->vpool = BLI_mempool_create(vsize, allocsize[0], allocsize[0], FALSE, TRUE);
        bm->epool = BLI_mempool_create(esize, allocsize[1], allocsize[1], FALSE, TRUE);
        bm->lpool = BLI_mempool_create(lsize, allocsize[2], allocsize[2], FALSE, FALSE);
        bm->looplistpool = BLI_mempool_create(lstsize, allocsize[3], allocsize[3], FALSE, FALSE);
        bm->fpool = BLI_mempool_create(fsize, allocsize[4], allocsize[4], FALSE, TRUE);
 
-       /*allocate one flag pool that we dont get rid of.*/
+       /* allocate one flag pool that we dont get rid of. */
        bm->toolflagpool = BLI_mempool_create(sizeof(BMFlagLayer), 512, 512, FALSE, FALSE);
        bm->stackdepth = 1;
        bm->totflags = 1;
@@ -196,7 +196,7 @@ void BM_Clear_Mesh(BMesh *bm)
  *     BMESH FREE MESH
  *
  *     Frees a BMesh structure.
-*/
+ */
 
 void BM_Free_Mesh(BMesh *bm)
 {
@@ -210,7 +210,7 @@ void BM_Free_Mesh(BMesh *bm)
  *  Updates the normals of a mesh.
  *  Note that this can only be called  
  *
-*/
+ */
 
 void BM_Compute_Normals(BMesh *bm)
 {
@@ -227,7 +227,7 @@ void BM_Compute_Normals(BMesh *bm)
        float (*projectverts)[3];
        float (*edgevec)[3];
 
-       /*first, find out the largest face in mesh*/
+       /* first, find out the largest face in mesh */
        BM_ITER(f, &faces, bm, BM_FACES_OF_MESH, NULL) {
                if (BM_TestHFlag(f, BM_HIDDEN))
                        continue;
@@ -235,13 +235,13 @@ void BM_Compute_Normals(BMesh *bm)
                if (f->len > maxlength) maxlength = f->len;
        }
        
-       /*make sure we actually have something to do*/
+       /* make sure we actually have something to do */
        if (maxlength < 3) return;
 
-       /*allocate projectverts array*/
+       /* allocate projectverts array */
        projectverts = MEM_callocN(sizeof(float) * maxlength * 3, "BM normal computation array");
        
-       /*calculate all face normals*/
+       /* calculate all face normals */
        BM_ITER(f, &faces, bm, BM_FACES_OF_MESH, NULL) {
                if (BM_TestHFlag(f, BM_HIDDEN))
                        continue;
@@ -253,7 +253,7 @@ void BM_Compute_Normals(BMesh *bm)
                bmesh_update_face_normal(bm, f, f->no, projectverts);
        }
        
-       /*Zero out vertex normals*/
+       /* Zero out vertex normals */
        BM_ITER(v, &verts, bm, BM_VERTS_OF_MESH, NULL) {
                if (BM_TestHFlag(v, BM_HIDDEN))
                        continue;
@@ -281,7 +281,7 @@ void BM_Compute_Normals(BMesh *bm)
        }
        bm->elem_index_dirty &= ~BM_EDGE;
 
-       /*add weighted face normals to vertices*/
+       /* add weighted face normals to vertices */
        BM_ITER(f, &faces, bm, BM_FACES_OF_MESH, NULL) {
 
                if (BM_TestHFlag(f, BM_HIDDEN))
@@ -293,16 +293,16 @@ void BM_Compute_Normals(BMesh *bm)
                        float fac;
 
                        /* calculate the dot product of the two edges that
-                          meet at the loop's vertex */
+                        * meet at the loop's vertex */
                        e1diff = edgevec[BM_GetIndex(l->prev->e)];
                        e2diff = edgevec[BM_GetIndex(l->e)];
                        dotprod = dot_v3v3(e1diff, e2diff);
 
                        /* edge vectors are calculated from e->v1 to e->v2, so
-                          adjust the dot product if one but not both loops 
-                          actually runs from from e->v2 to e->v1 */
+                        * adjust the dot product if one but not both loops
+                        * actually runs from from e->v2 to e->v1 */
                        if ((l->prev->e->v1 == l->prev->v) ^ (l->e->v1 == l->v)) {
-                               dotprod= -dotprod;
+                               dotprod = -dotprod;
                        }
 
                        fac = saacos(-dotprod);
@@ -333,7 +333,7 @@ void BM_Compute_Normals(BMesh *bm)
  
  if undo is 0: calculate right normals
  if undo is 1: restore original normals
-*/
+ */
 //keep in sycn with utils.c!
 #define FACE_FLIP      8
 static void bmesh_rationalize_normals(BMesh *bm, int undo)
@@ -370,7 +370,7 @@ static void bmesh_rationalize_normals(BMesh *bm, int undo)
 
 static void bmesh_set_mdisps_space(BMesh *bm, int from, int to)
 {
-       /*switch multires data out of tangent space*/
+       /* switch multires data out of tangent space */
        if (CustomData_has_layer(&bm->ldata, CD_MDISPS)) {
                Object *ob = bm->ob;
                BMEditMesh *em = BMEdit_Create(bm, FALSE);
@@ -378,7 +378,7 @@ static void bmesh_set_mdisps_space(BMesh *bm, int from, int to)
                MDisps *mdisps;
                BMFace *f;
                BMIter iter;
-               // int i= 0; // UNUSED
+               // int i = 0; // UNUSED
                
                multires_set_space(dm, ob, from, to);
                
@@ -395,7 +395,7 @@ static void bmesh_set_mdisps_space(BMesh *bm, int from, int to)
                                }
                                
                                if (lmd->disps && lmd->totdisp == mdisps->totdisp) {
-                                       memcpy(lmd->disps, mdisps->disps, sizeof(float)*3*lmd->totdisp);
+                                       memcpy(lmd->disps, mdisps->disps, sizeof(float) * 3 * lmd->totdisp);
                                }
                                else if (mdisps->disps) {
                                        if (lmd->disps)
@@ -413,7 +413,7 @@ static void bmesh_set_mdisps_space(BMesh *bm, int from, int to)
                dm->needsFree = 1;
                dm->release(dm);
                
-               /*setting this to NULL prevents BMEdit_Free from freeing it*/
+               /* setting this to NULL prevents BMEdit_Free from freeing it */
                em->bm = NULL;
                BMEdit_Free(em);
                MEM_freeN(em);
@@ -430,7 +430,7 @@ static void bmesh_set_mdisps_space(BMesh *bm, int from, int to)
  *  Returns -
  *  Nothing
  *
-*/
+ */
 void bmesh_begin_edit(BMesh *bm, int flag)
 {
        bm->opflag = flag;
@@ -441,11 +441,11 @@ void bmesh_begin_edit(BMesh *bm, int flag)
           the mesh at all, which doesn't seem right. Turning off completely for now,
           until this is shown to be better for certain types of mesh edits. */
 #if BMOP_UNTAN_MULTIRES_ENABLED
-       /*switch multires data out of tangent space*/
+       /* switch multires data out of tangent space */
        if ((flag & BMOP_UNTAN_MULTIRES) && CustomData_has_layer(&bm->ldata, CD_MDISPS)) {
                bmesh_set_mdisps_space(bm, MULTIRES_SPACE_TANGENT, MULTIRES_SPACE_ABSOLUTE);
 
-               /*ensure correct normals, if possible*/
+               /* ensure correct normals, if possible */
                bmesh_rationalize_normals(bm, 0);
                BM_Compute_Normals(bm);
        }
@@ -463,9 +463,9 @@ void bmesh_end_edit(BMesh *bm, int flag)
 {
        /* BMOP_UNTAN_MULTIRES disabled for now, see comment above in bmesh_begin_edit. */
 #if BMOP_UNTAN_MULTIRES_ENABLED
-       /*switch multires data into tangent space*/
+       /* switch multires data into tangent space */
        if ((flag & BMOP_UNTAN_MULTIRES) && CustomData_has_layer(&bm->ldata, CD_MDISPS)) {
-               /*set normals to their previous winding*/
+               /* set normals to their previous winding */
                bmesh_rationalize_normals(bm, 1);
                bmesh_set_mdisps_space(bm, MULTIRES_SPACE_ABSOLUTE, MULTIRES_SPACE_TANGENT);
        }
@@ -480,7 +480,7 @@ void bmesh_end_edit(BMesh *bm, int flag)
 
        bm->opflag = 0;
 
-       /*compute normals, clear temp flags and flush selections*/
+       /* compute normals, clear temp flags and flush selections */
        BM_Compute_Normals(bm);
        BM_SelectMode_Flush(bm);
 }
@@ -496,7 +496,7 @@ void BM_ElemIndex_Ensure(BMesh *bm, const char hflag)
 
        if (hflag & BM_VERT) {
                if (bm->elem_index_dirty & BM_VERT) {
-                       int index= 0;
+                       int index = 0;
                        BM_ITER(ele, &iter, bm, BM_VERTS_OF_MESH, NULL) {
                                BM_SetIndex(ele, index); /* set_ok */
                                index++;
@@ -511,7 +511,7 @@ void BM_ElemIndex_Ensure(BMesh *bm, const char hflag)
 
        if (hflag & BM_EDGE) {
                if (bm->elem_index_dirty & BM_EDGE) {
-                       int index= 0;
+                       int index = 0;
                        BM_ITER(ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
                                BM_SetIndex(ele, index); /* set_ok */
                                index++;
@@ -526,7 +526,7 @@ void BM_ElemIndex_Ensure(BMesh *bm, const char hflag)
 
        if (hflag & BM_FACE) {
                if (bm->elem_index_dirty & BM_FACE) {
-                       int index= 0;
+                       int index = 0;
                        BM_ITER(ele, &iter, bm, BM_FACES_OF_MESH, NULL) {
                                BM_SetIndex(ele, index); /* set_ok */
                                index++;
@@ -556,24 +556,24 @@ void BM_ElemIndex_Validate(BMesh *bm, const char *location, const char *func, co
        BMIter iter;
        BMHeader *ele;
        int types[3] = {BM_VERTS_OF_MESH, BM_EDGES_OF_MESH, BM_FACES_OF_MESH};
-       const char *type_names[3]= {"vert", "edge", "face"};
-       const char type_flags[3]= {BM_VERT, BM_EDGE, BM_FACE};
+       const char *type_names[3] = {"vert", "edge", "face"};
+       const char type_flags[3] = {BM_VERT, BM_EDGE, BM_FACE};
        int i;
-       int is_any_error= 0;
+       int is_any_error = 0;
 
-       for (i=0; i<3; i++) {
-               const int is_dirty= (type_flags[i] & bm->elem_index_dirty);
-               int index= 0;
-               int is_error= FALSE;
-               int err_val= 0;
-               int err_idx= 0;
+       for (i = 0; i < 3; i++) {
+               const int is_dirty = (type_flags[i] & bm->elem_index_dirty);
+               int index = 0;
+               int is_error = FALSE;
+               int err_val = 0;
+               int err_idx = 0;
 
                BM_ITER(ele, &iter, bm, types[i], NULL) {
                        if (!is_dirty) {
                                if (BM_GetIndex(ele) != index) {
-                                       err_val= BM_GetIndex(ele);
-                                       err_idx= index;
-                                       is_error= TRUE;
+                                       err_val = BM_GetIndex(ele);
+                                       err_idx = index;
+                                       is_error = TRUE;
                                }
                        }
 
@@ -582,7 +582,7 @@ void BM_ElemIndex_Validate(BMesh *bm, const char *location, const char *func, co
                }
 
                if ((is_error == TRUE) && (is_dirty == FALSE)) {
-                       is_any_error= TRUE;
+                       is_any_error = TRUE;
                        fprintf(stderr,
                                "Invalid Index: at %s, %s, %s[%d] invalid index %d, '%s', '%s'\n",
                                location, func, type_names[i], err_idx, err_val, msg_a, msg_b);
index 09cdc80a76e5f7f1df20e5b5da88827a2027aed6..03d064edaec5d42b064e06985bcc0d59467ac15d 100644 (file)
@@ -68,12 +68,14 @@ int BM_Dissolve_Vert(BMesh *bm, BMVert *v)
 {
        BMIter iter;
        BMEdge *e;
-       int len=0;
+       int len = 0;
 
-       if (!v) return 0;
+       if (!v) {
+               return 0;
+       }
        
        e = BMIter_New(&iter, bm, BM_EDGES_OF_VERT, v);
-       for ( ; e; e=BMIter_Step(&iter)) {
+       for ( ; e; e = BMIter_Step(&iter)) {
                len++;
        }
        
@@ -103,18 +105,18 @@ int BM_Dissolve_Vert(BMesh *bm, BMVert *v)
 int BM_Dissolve_Disk(BMesh *bm, BMVert *v)
 {
        BMFace *f, *f2;
-       BMEdge *e, *keepedge=NULL, *baseedge=NULL;
-       int len= 0;
+       BMEdge *e, *keepedge = NULL, *baseedge = NULL;
+       int len = 0;
 
        if (BM_Nonmanifold_Vert(bm, v)) {
                return 0;
        }
        
        if (v->e) {
-               /*v->e we keep, what else?*/
+               /* v->e we keep, what else */
                e = v->e;
                do {
-                       e = bmesh_disk_nextedge(e,v);
+                       e = bmesh_disk_nextedge(e, v);
                        if (!(BM_Edge_Share_Faces(e, v->e))) {
                                keepedge = e;
                                baseedge = v->e;
@@ -124,12 +126,12 @@ int BM_Dissolve_Disk(BMesh *bm, BMVert *v)
                } while (e != v->e);
        }
        
-       /*this code for handling 2 and 3-valence verts
-         may be totally bad.*/
+       /* this code for handling 2 and 3-valence verts
+        * may be totally bad */
        if (keepedge == NULL && len == 3) {
-               /*handle specific case for three-valence.  solve it by
-                 increasing valence to four.  this may be hackish. . .*/
-               BMLoop *loop= e->l;
+               /* handle specific case for three-valence.  solve it by
+                * increasing valence to four.  this may be hackish. .  */
+               BMLoop *loop = e->l;
                if (loop->v == v) loop = loop->next;
                if (!BM_Split_Face(bm, loop->f, v, loop->v, NULL, NULL))
                        return 0;
@@ -140,14 +142,14 @@ int BM_Dissolve_Disk(BMesh *bm, BMVert *v)
                return 1;
        }
        else if (keepedge == NULL && len == 2) {
-               /*collapse the vertex*/
+               /* collapse the verte */
                e = BM_Collapse_Vert_Faces(bm, v->e, v, 1.0, TRUE);
 
                if (!e) {
                        return 0;
                }
 
-               /*handle two-valence*/
+               /* handle two-valenc */
                f = e->l->f;
                f2 = e->l->radial_next->f;
 
@@ -167,12 +169,14 @@ int BM_Dissolve_Disk(BMesh *bm, BMVert *v)
                        do {
                                f = NULL;
                                len = bmesh_radial_length(e->l);
-                               if (len == 2 && (e!=baseedge) && (e!=keepedge)) {
+                               if (len == 2 && (e != baseedge) && (e != keepedge)) {
                                        f = BM_Join_TwoFaces(bm, e->l->f, e->l->radial_next->f, e);
-                                       /*return if couldn't join faces in manifold
-                                         conditions.*/
+                                       /* return if couldn't join faces in manifold
+                                        * conditions */
                                        //!disabled for testing why bad things happen
-                                       if (!f) return 0;
+                                       if (!f) {
+                                               return 0;
+                                       }
                                }
 
                                if (f) {
@@ -183,19 +187,19 @@ int BM_Dissolve_Disk(BMesh *bm, BMVert *v)
                        } while (e != v->e);
                }
 
-               /*collapse the vertex*/
+               /* collapse the verte */
                e = BM_Collapse_Vert_Faces(bm, baseedge, v, 1.0, TRUE);
 
                if (!e) {
                        return 0;
                }
                
-               /*get remaining two faces*/
+               /* get remaining two face */
                f = e->l->f;
                f2 = e->l->radial_next->f;
 
                if (f != f2) {
-                       /*join two remaining faces*/
+                       /* join two remaining face */
                        if (!BM_Join_TwoFaces(bm, f, f2, e)) {
                                return 0;
                        }
@@ -217,15 +221,13 @@ void BM_Dissolve_Disk(BMesh *bm, BMVert *v)
                while (!done) {
                        done = 1;
                        
-                       /*loop the edges looking for an edge to dissolve*/
-                       for (e=BMIter_New(&iter, bm, BM_EDGES_OF_VERT, v); e;
+                       /* loop the edges looking for an edge to dissolv */
+                       for (e = BMIter_New(&iter, bm, BM_EDGES_OF_VERT, v); e;
                             e = BMIter_Step(&iter)) {
                                f = NULL;
                                len = bmesh_cycle_length(&(e->l->radial));
                                if (len == 2) {
-                                       f = BM_Join_TwoFaces(bm,e->l->f,((BMLoop*)
-                                             (e->l->radial_next))->f, 
-                                              e);
+                                       f = BM_Join_TwoFaces(bm, e->l->f, ((BMLoop *)(e->l->radial_next))->f, e);
                                }
                                if (f) {
                                        done = 0;
@@ -258,12 +260,12 @@ void BM_Dissolve_Disk(BMesh *bm, BMVert *v)
 BMFace *BM_Join_TwoFaces(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e)
 {
        BMLoop *l1, *l2;
-       BMEdge *jed=NULL;
+       BMEdge *jed = NULL;
        BMFace *faces[2] = {f1, f2};
        
        jed = e;
        if (!jed) {
-               /*search for an edge that has both these faces in its radial cycle*/
+               /* search for an edge that has both these faces in its radial cycl */
                l1 = bm_firstfaceloop(f1);
                do {
                        if (l1->radial_next->f == f2) {
@@ -271,7 +273,7 @@ BMFace *BM_Join_TwoFaces(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e)
                                break;
                        }
                        l1 = l1->next;
-               } while (l1!=bm_firstfaceloop(f1));
+               } while (l1 != bm_firstfaceloop(f1));
        }
 
        if (!jed) {
@@ -296,14 +298,14 @@ BMFace *BM_Join_TwoFaces(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e)
        return f1;
 }
 
-/*connects two verts together, automatically (if very naively) finding the
-  face they both share (if there is one) and splittling it.  use this at your 
-  own risk, as it doesn't handle the many complex cases it should (like zero-area faces,
-  multiple faces, etc).
-
-  this is really only meant for cases where you don't know before hand the face
-  the two verts belong to for splitting (e.g. the subdivision operator).
-*/
+/* connects two verts together, automatically (if very naively) finding the
+ * face they both share (if there is one) and splittling it.  use this at your
* own risk, as it doesn't handle the many complex cases it should (like zero-area faces,
* multiple faces, etc).
+ *
* this is really only meant for cases where you don't know before hand the face
* the two verts belong to for splitting (e.g. the subdivision operator).
+ */
 
 BMEdge *BM_Connect_Verts(BMesh *bm, BMVert *v1, BMVert *v2, BMFace **nf)
 {
@@ -312,9 +314,9 @@ BMEdge *BM_Connect_Verts(BMesh *bm, BMVert *v1, BMVert *v2, BMFace **nf)
        BMLoop *nl;
        BMFace *face;
 
-       /*be warned: this can do weird things in some ngon situation, see BM_LegalSplits*/
-       for (face = BMIter_New(&iter, bm, BM_FACES_OF_VERT, v1); face; face=BMIter_Step(&iter)) {
-               for (v=BMIter_New(&iter2, bm, BM_VERTS_OF_FACE, face); v; v=BMIter_Step(&iter2)) {
+       /* be warned: this can do weird things in some ngon situation, see BM_LegalSplit */
+       for (face = BMIter_New(&iter, bm, BM_FACES_OF_VERT, v1); face; face = BMIter_Step(&iter)) {
+               for (v = BMIter_New(&iter2, bm, BM_VERTS_OF_FACE, face); v; v = BMIter_Step(&iter2)) {
                        if (v == v2) {
                                face = BM_Split_Face(bm, face, v1, v2, &nl, NULL);
 
@@ -350,7 +352,7 @@ BMFace *BM_Split_Face(BMesh *bm, BMFace *f, BMVert *v1, BMVert *v2, BMLoop **nl,
        const int has_mdisp = CustomData_has_layer(&bm->ldata, CD_MDISPS);
        BMFace *nf, *of;
        
-       /*do we have a multires layer?*/
+       /* do we have a multires layer */
        if (has_mdisp) {
                of = BM_Copy_Face(bm, f, 0, 0);
        }
@@ -418,7 +420,7 @@ BMEdge* BM_Collapse_Vert_Faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac, con
        BMVert *tv2;
 
        BMIter iter;
-       BMLoop *l=NULL, *kvloop=NULL, *tvloop=NULL;
+       BMLoop *l = NULL, *kvloop = NULL, *tvloop = NULL;
 
        void *src[2];
        float w[2];
@@ -440,9 +442,9 @@ BMEdge* BM_Collapse_Vert_Faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac, con
 
                                src[0] = kvloop->head.data;
                                src[1] = tvloop->head.data;
-                               CustomData_bmesh_interp(&bm->ldata, src,w, NULL, 2, kvloop->head.data);
+                               CustomData_bmesh_interp(&bm->ldata, src, w, NULL, 2, kvloop->head.data);
                        }
-                       l= l->radial_next;
+                       l = l->radial_next;
                } while (l != ke->l);
        }
 
@@ -497,7 +499,7 @@ BMEdge* BM_Collapse_Vert_Faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac, con
 BMEdge *BM_Collapse_Vert_Edges(BMesh *bm, BMEdge *ke, BMVert *kv)
 {
        /* nice example implimentation but we want loops to have their customdata
-        * accounted for.*/
+        * accounted for */
 #if 0
        BMEdge *ne = NULL;
 
@@ -514,7 +516,7 @@ BMEdge *BM_Collapse_Vert_Edges(BMesh *bm, BMEdge *ke, BMVert *kv)
                                /* only action, other calls here only get the edge to return */
                                bmesh_jekv(bm, ke, kv);
 
-                               ne= BM_Edge_Exist(tv, tv2);
+                               ne = BM_Edge_Exist(tv, tv2);
                        }
                }
        }
@@ -548,11 +550,11 @@ BMVert *BM_Split_Edge(BMesh *bm, BMVert *v, BMEdge *e, BMEdge **ne, float percen
        BLI_array_staticdeclare(oldfaces, 32);
        SmallHash hash;
 
-       /*we need this for handling multires*/  
+       /* we need this for handling multire */
        if (!ne) 
                ne = &dummy;
 
-       /*do we have a multires layer?*/
+       /* do we have a multires layer */
        if (CustomData_has_layer(&bm->ldata, CD_MDISPS) && e->l) {
                BMLoop *l;
                int i;
@@ -563,17 +565,17 @@ BMVert *BM_Split_Edge(BMesh *bm, BMVert *v, BMEdge *e, BMEdge **ne, float percen
                        l = l->radial_next;
                } while (l != e->l);
                
-               /*create a hash so we can differentiate oldfaces from new faces*/
+               /* create a hash so we can differentiate oldfaces from new face */
                BLI_smallhash_init(&hash);
                
-               for (i=0; i<BLI_array_count(oldfaces); i++) {
+               for (i = 0; i < BLI_array_count(oldfaces); i++) {
                        oldfaces[i] = BM_Copy_Face(bm, oldfaces[i], 1, 1);
                        BLI_smallhash_insert(&hash, (intptr_t)oldfaces[i], NULL);
                }               
        }
 
-       v2 = bmesh_edge_getothervert(e,v);
-       nv = bmesh_semv(bm,v,e,ne);
+       v2 = bmesh_edge_getothervert(e, v);
+       nv = bmesh_semv(bm, v, e, ne);
        if (nv == NULL) return NULL;
 
        sub_v3_v3v3(nv->co, v2->co, v->co);
@@ -584,16 +586,16 @@ BMVert *BM_Split_Edge(BMesh *bm, BMVert *v, BMEdge *e, BMEdge **ne, float percen
                BM_Copy_Attributes(bm, bm, e, *ne);
        }
 
-       /*v->nv->v2*/
+       /* v->nv->v2 */
        BM_Data_Facevert_Edgeinterp(bm, v2, v, nv, e, percent); 
        BM_Data_Interp_From_Verts(bm, v, v2, nv, percent);
 
        if (CustomData_has_layer(&bm->ldata, CD_MDISPS) && e->l && nv) {
                int i, j;
 
-               /*interpolate new/changed loop data from copied old faces*/
-               for (j=0; j<2; j++) {
-                       for (i=0; i<BLI_array_count(oldfaces); i++) {
+               /* interpolate new/changed loop data from copied old face */
+               for (j = 0; j < 2; j++) {
+                       for (i = 0; i < BLI_array_count(oldfaces); i++) {
                                BMEdge *e1 = j ? *ne : e;
                                BMLoop *l, *l2;
                                
@@ -616,14 +618,14 @@ BMVert *BM_Split_Edge(BMesh *bm, BMVert *v, BMEdge *e, BMEdge **ne, float percen
                        }
                }
                
-               /*destroy the old faces*/
-               for (i=0; i<BLI_array_count(oldfaces); i++) {
+               /* destroy the old face */
+               for (i = 0; i < BLI_array_count(oldfaces); i++) {
                        BM_Kill_Face_Verts(bm, oldfaces[i]);
                }
                
-               /*fix boundaries a bit, doesn't work too well quite yet*/
+               /* fix boundaries a bit, doesn't work too well quite ye */
 #if 0
-               for (j=0; j<2; j++) {
+               for (j = 0; j < 2; j++) {
                        BMEdge *e1 = j ? *ne : e;
                        BMLoop *l, *l2;
                        
@@ -653,7 +655,7 @@ BMVert  *BM_Split_Edge_Multi(BMesh *bm, BMEdge *e, int numcuts)
        float percent;
        BMVert *nv = NULL;
        
-       for (i=0; i < numcuts; i++) {
+       for (i = 0; i < numcuts; i++) {
                percent = 1.0f / (float)(numcuts + 1 - i);
                nv = BM_Split_Edge(bm, e->v2, e, NULL, percent);
        }
@@ -673,9 +675,9 @@ int BM_Validate_Face(BMesh *bm, BMFace *face, FILE *err)
                fflush(err);
        }
 
-       for (l=BMIter_New(&iter, bm, BM_LOOPS_OF_FACE, face);l;l=BMIter_Step(&iter)) {
+       for (l = BMIter_New(&iter, bm, BM_LOOPS_OF_FACE, face); l; l = BMIter_Step(&iter)) {
                BLI_array_growone(verts);
-               verts[BLI_array_count(verts)-1] = l->v;
+               verts[BLI_array_count(verts) - 1] = l->v;
                
                if (l->e->v1 == l->e->v2) {
                        fprintf(err, "Found bmesh edge with identical verts!\n");
@@ -685,9 +687,12 @@ int BM_Validate_Face(BMesh *bm, BMFace *face, FILE *err)
                }
        }
 
-       for (i=0; i<BLI_array_count(verts); i++) {
-               for (j=0; j<BLI_array_count(verts); j++) {
-                       if (j == i) continue;
+       for (i = 0; i < BLI_array_count(verts); i++) {
+               for (j = 0; j < BLI_array_count(verts); j++) {
+                       if (j == i) {
+                               continue;
+                       }
+
                        if (verts[i] == verts[j]) {
                                fprintf(err, "Found duplicate verts in bmesh face!\n");
                                fprintf(err, "  face ptr: %p, vert: %p\n", face, verts[i]);
@@ -714,7 +719,7 @@ int BM_Validate_Face(BMesh *bm, BMFace *face, FILE *err)
 
     Returns NULL on error (e.g., if the edge isn't surrounded by exactly
     two faces).
-*/
+ */
 BMEdge *BM_Rotate_Edge(BMesh *bm, BMEdge *e, int ccw)
 {
        BMVert *v1, *v2;
index dfc241b6037d823f5d4dd6cd6aa9c15f45c4c343..4ff4e25d8092e87c04324ea3f33fd05dd8466504 100644 (file)
@@ -80,18 +80,18 @@ BMVert *BM_Make_Vert(BMesh *bm, const float co[3], const struct BMVert *example)
        /* 'v->no' is handled by BM_Copy_Attributes */
        if (co) copy_v3_v3(v->co, co);
        
-       /*allocate flags*/
+       /* allocate flag */
        v->head.flags = BLI_mempool_calloc(bm->toolflagpool);
 
        CustomData_bmesh_set_default(&bm->vdata, &v->head.data);
        
        if (example) {
-               BM_Copy_Attributes(bm, bm, (BMVert*)example, (BMVert*)v);
+               BM_Copy_Attributes(bm, bm, (BMVert *)example, (BMVert *)v);
        }
 
        BM_CHECK_ELEMENT(bm, v);
 
-       return (BMVert*) v;
+       return (BMVert *) v;
 }
 
 /**
@@ -122,8 +122,8 @@ BMEdge *BM_Make_Edge(BMesh *bm, BMVert *v1, BMVert *v2, const BMEdge *example, i
 {
        BMEdge *e;
        
-       if (nodouble && (e= BM_Edge_Exist(v1, v2)))
-               return (BMEdge*)e;
+       if (nodouble && (e = BM_Edge_Exist(v1, v2)))
+               return (BMEdge *)e;
        
        e = BLI_mempool_calloc(bm->epool);
 
@@ -139,11 +139,11 @@ BMEdge *BM_Make_Edge(BMesh *bm, BMVert *v1, BMVert *v2, const BMEdge *example, i
 
        e->head.htype = BM_EDGE;
        
-       /*allocate flags*/
+       /* allocate flag */
        e->head.flags = BLI_mempool_calloc(bm->toolflagpool);
 
-       e->v1 = (BMVert*) v1;
-       e->v2 = (BMVert*) v2;
+       e->v1 = (BMVert *) v1;
+       e->v2 = (BMVert *) v2;
        
        
        CustomData_bmesh_set_default(&bm->edata, &e->head.data);
@@ -152,16 +152,16 @@ BMEdge *BM_Make_Edge(BMesh *bm, BMVert *v1, BMVert *v2, const BMEdge *example, i
        bmesh_disk_append_edge(e, e->v2);
        
        if (example)
-               BM_Copy_Attributes(bm, bm, (BMEdge*)example, (BMEdge*)e);
+               BM_Copy_Attributes(bm, bm, (BMEdge *)example, (BMEdge *)e);
        
        BM_CHECK_ELEMENT(bm, e);
 
-       return (BMEdge*) e;
+       return (BMEdge *) e;
 }
 
 static BMLoop *bmesh_create_loop(BMesh *bm, BMVert *v, BMEdge *e, BMFace *f, const BMLoop *example)
 {
-       BMLoop *l=NULL;
+       BMLoop *l = NULL;
 
        l = BLI_mempool_calloc(bm->lpool);
        l->next = l->prev = NULL;
@@ -228,11 +228,11 @@ BMFace *BM_Copy_Face(BMesh *bm, BMFace *f, int copyedges, int copyverts)
                        
                        if (l->e->v1 == verts[i]) {
                                v1 = verts[i];
-                               v2 = verts[(i+1)%f->len];
+                               v2 = verts[(i + 1) % f->len];
                        }
                        else {
                                v2 = verts[i];
-                               v1 = verts[(i+1)%f->len];
+                               v1 = verts[(i + 1) % f->len];
                        }
                        
                        e = BM_Make_Edge(bm,  v1, v2, l->e, 0);
@@ -268,7 +268,7 @@ BMFace *BM_Make_Face(BMesh *bm, BMVert **verts, BMEdge **edges, const int len, i
        int i, overlap;
        
        if (len == 0) {
-               /*just return NULL for now*/
+               /* just return NULL for no */
                return NULL;
        }
 
@@ -297,14 +297,14 @@ BMFace *BM_Make_Face(BMesh *bm, BMVert **verts, BMEdge **edges, const int len, i
 
        f->head.htype = BM_FACE;
 
-       startl = lastl = BM_Add_FaceBoundary(bm, (BMFace*)f, verts[0], edges[0]);
+       startl = lastl = BM_Add_FaceBoundary(bm, (BMFace *)f, verts[0], edges[0]);
        
-       startl->v = (BMVert*) verts[0];
-       startl->e = (BMEdge*) edges[0];
-       for (i=1; i<len; i++) {
+       startl->v = (BMVert *) verts[0];
+       startl->e = (BMEdge *) edges[0];
+       for (i = 1; i < len; i++) {
                l = bmesh_create_loop(bm, verts[i], edges[i], (BMFace *)f, edges[i]->l);
                
-               l->f = (BMFace*) f;
+               l->f = (BMFace *) f;
                bmesh_radial_append(edges[i], l);
 
                l->prev = lastl;
@@ -312,7 +312,7 @@ BMFace *BM_Make_Face(BMesh *bm, BMVert **verts, BMEdge **edges, const int len, i
                lastl = l;
        }
        
-       /*allocate flags*/
+       /* allocate flag */
        f->head.flags = BLI_mempool_calloc(bm->toolflagpool);
 
        CustomData_bmesh_set_default(&bm->pdata, &f->head.data);
@@ -325,7 +325,7 @@ BMFace *BM_Make_Face(BMesh *bm, BMVert **verts, BMEdge **edges, const int len, i
        
        BM_CHECK_ELEMENT(bm, f);
 
-       return (BMFace*) f;
+       return (BMFace *) f;
 }
 
 int bmesh_check_element(BMesh *UNUSED(bm), void *element, const char htype)
@@ -377,12 +377,12 @@ int bmesh_check_element(BMesh *UNUSED(bm), void *element, const char htype)
                }
 
                if (l->radial_next == NULL || l->radial_prev == NULL)
-                       err |= (1<<12);
+                       err |= (1 << 12);
                if (l->f->len <= 0)
-                       err |= (1<<13);
+                       err |= (1 << 13);
 
-               /*validate boundary loop--invalid for hole loops, of course,
-                 but we won't be allowing those for a while yet*/
+               /* validate boundary loop--invalid for hole loops, of course,
+                 but we won't be allowing those for a while ye */
                l2 = l;
                i = 0;
                do {
@@ -394,47 +394,47 @@ int bmesh_check_element(BMesh *UNUSED(bm), void *element, const char htype)
                } while (l2 != l);
 
                if (i != l->f->len || l2 != l)
-                       err |= (1<<14);
+                       err |= (1 << 14);
 
                if (!bmesh_radial_validate(bmesh_radial_length(l), l))
-                       err |= (1<<15);
+                       err |= (1 << 15);
 
                break;
        }
        case BM_FACE: {
                BMFace *f = element;
                BMLoop *l;
-               int len=0;
+               int len = 0;
 
                if (!f->loops.first)
-                       err |= (1<<16);
+                       err |= (1 << 16);
                l = bm_firstfaceloop(f);
                do {
                        if (l->f != f) {
                                fprintf(stderr, "%s: loop inside one face points to another! (bmesh internal error)\n", __func__);
-                               err |= (1<<17);
+                               err |= (1 << 17);
                        }
 
                        if (!l->e)
-                               err |= (1<<18);
+                               err |= (1 << 18);
                        if (!l->v)
-                               err |= (1<<19);
+                               err |= (1 << 19);
                        if (!BM_Vert_In_Edge(l->e, l->v) || !BM_Vert_In_Edge(l->e, l->next->v)) {
-                               err |= (1<<20);
+                               err |= (1 << 20);
                        }
 
                        if (!bmesh_radial_validate(bmesh_radial_length(l), l))
-                               err |= (1<<21);
+                               err |= (1 << 21);
 
                        if (!bmesh_disk_count(l->v) || !bmesh_disk_count(l->next->v))
-                               err |= (1<<22);
+                               err |= (1 << 22);
 
                        len++;
                        l = l->next;
                } while (l != bm_firstfaceloop(f));
 
                if (len != f->len)
-                       err |= (1<<23);
+                       err |= (1 << 23);
        }
        }
 
@@ -515,7 +515,7 @@ void BM_Kill_Face_Edges(BMesh *bm, BMFace *f)
                l = l->next;
        } while (l != bm_firstfaceloop(f));
        
-       for (i=0; i<BLI_array_count(edges); i++) {
+       for (i = 0; i < BLI_array_count(edges); i++) {
                BM_Kill_Edge(bm, edges[i]);
        }
        
@@ -535,7 +535,7 @@ void BM_Kill_Face_Verts(BMesh *bm, BMFace *f)
                l = l->next;
        } while (l != bm_firstfaceloop(f));
        
-       for (i=0; i<BLI_array_count(verts); i++) {
+       for (i = 0; i < BLI_array_count(verts); i++) {
                BM_Kill_Vert(bm, verts[i]);
        }
        
@@ -548,7 +548,7 @@ void BM_Kill_Face(BMesh *bm, BMFace *f)
 
        BM_CHECK_ELEMENT(bm, f);
 
-       for (ls=f->loops.first; ls; ls=lsnext) {
+       for (ls = f->loops.first; ls; ls = lsnext) {
                BMLoop *l, *lnext;
 
                lsnext = ls->next;
@@ -575,7 +575,7 @@ void BM_Kill_Edge(BMesh *bm, BMEdge *e)
        bmesh_disk_remove_edge(e, e->v2);
                
        if (e->l) {
-               BMLoop *l = e->l, *lnext, *startl=e->l;
+               BMLoop *l = e->l, *lnext, *startl = e->l;
                        
                do {
                        lnext = l->radial_next;
@@ -611,7 +611,7 @@ void BM_Kill_Vert(BMesh *bm, BMVert *v)
        bmesh_kill_only_vert(bm, v);
 }
 
-/********** private disk and radial cycle functions ************/
+/********** private disk and radial cycle functions ********** */
 
 /**
  *                     bmesh_loop_reverse
@@ -651,14 +651,14 @@ static int bmesh_loop_reverse_loop(BMesh *bm, BMFace *f, BMLoopList *lst)
 
        len = bmesh_loop_length(l);
 
-       for (i=0, curloop = l; i< len; i++, curloop= curloop->next) {
+       for (i = 0, curloop = l; i < len; i++, curloop = curloop->next) {
                BMEdge *curedge = curloop->e;
                bmesh_radial_remove_loop(curloop, curedge);
                BLI_array_append(edar, curedge);
        }
 
-       /*actually reverse the loop.*/
-       for (i=0, curloop = l; i < len; i++) {
+       /* actually reverse the loop */
+       for (i = 0, curloop = l; i < len; i++) {
                oldnext = curloop->next;
                oldprev = curloop->prev;
                curloop->next = oldprev;
@@ -673,12 +673,12 @@ static int bmesh_loop_reverse_loop(BMesh *bm, BMFace *f, BMLoopList *lst)
                        if (!md->totdisp || !md->disps)
                                continue;
                                        
-                       sides= (int)sqrt(md->totdisp);
+                       sides = (int)sqrt(md->totdisp);
                        co = md->disps;
                        
-                       for (x=0; x<sides; x++) {
-                               for (y=0; y<x; y++) {
-                                       swap_v3_v3(co[y*sides+x], co[sides*x + y]);
+                       for (x = 0; x < sides; x++) {
+                               for (y = 0; y < x; y++) {
+                                       swap_v3_v3(co[y * sides + x], co[sides * x + y]);
                                }
                        }
                }
@@ -690,9 +690,9 @@ static int bmesh_loop_reverse_loop(BMesh *bm, BMFace *f, BMLoopList *lst)
                l->next->e = edar[0];
        }
        else {
-               for (i=0, curloop = l; i < len; i++, curloop = curloop->next) {
+               for (i = 0, curloop = l; i < len; i++, curloop = curloop->next) {
                        edok = 0;
-                       for (j=0; j < len; j++) {
+                       for (j = 0; j < len; j++) {
                                edok = bmesh_verts_in_edge(curloop->v, curloop->next->v, edar[j]);
                                if (edok) {
                                        curloop->e = edar[j];
@@ -701,12 +701,12 @@ static int bmesh_loop_reverse_loop(BMesh *bm, BMFace *f, BMLoopList *lst)
                        }
                }
        }
-       /*rebuild radial*/
-       for (i=0, curloop = l; i < len; i++, curloop = curloop->next)
+       /* rebuild radia */
+       for (i = 0, curloop = l; i < len; i++, curloop = curloop->next)
                bmesh_radial_append(curloop->e, curloop);
 
-       /*validate radial*/
-       for (i=0, curloop = l; i < len; i++, curloop = curloop->next) {
+       /* validate radia */
+       for (i = 0, curloop = l; i < len; i++, curloop = curloop->next) {
                BM_CHECK_ELEMENT(bm, curloop);
                BM_CHECK_ELEMENT(bm, curloop->e);
                BM_CHECK_ELEMENT(bm, curloop->v);
@@ -730,7 +730,7 @@ static void bmesh_systag_elements(BMesh *UNUSED(bm), void *veles, int tot, int f
        BMHeader **eles = veles;
        int i;
 
-       for (i=0; i<tot; i++) {
+       for (i = 0; i < tot; i++) {
                bmesh_api_setflag(eles[i], flag);
        }
 }
@@ -740,17 +740,17 @@ static void bmesh_clear_systag_elements(BMesh *UNUSED(bm), void *veles, int tot,
        BMHeader **eles = veles;
        int i;
 
-       for (i=0; i<tot; i++) {
+       for (i = 0; i < tot; i++) {
                bmesh_api_clearflag(eles[i], flag);
        }
 }
 
-#define FACE_MARK      (1<<10)
+#define FACE_MARK      (1 << 10)
 
 static int count_flagged_radial(BMesh *bm, BMLoop *l, int flag)
 {
        BMLoop *l2 = l;
-       int i = 0, c=0;
+       int i = 0, c = 0;
 
        do {
                if (!l2) {
@@ -777,7 +777,7 @@ error:
 static int UNUSED_FUNCTION(count_flagged_disk)(BMVert *v, int flag)
 {
        BMEdge *e = v->e;
-       int i=0;
+       int i = 0;
 
        if (!e)
                return 0;
@@ -844,10 +844,10 @@ BMFace *BM_Join_Faces(BMesh *bm, BMFace **faces, int totface)
        BLI_array_staticdeclare(edges,    BM_NGON_STACK_SIZE);
        BLI_array_staticdeclare(deledges, BM_NGON_STACK_SIZE);
        BLI_array_staticdeclare(delverts, BM_NGON_STACK_SIZE);
-       BMVert *v1=NULL, *v2=NULL;
+       BMVert *v1 = NULL, *v2 = NULL;
        ListBase holes = {NULL, NULL};
        const char *err = NULL;
-       int i, tote=0;
+       int i, tote = 0;
 
        if (!totface) {
                bmesh_error();
@@ -859,7 +859,7 @@ BMFace *BM_Join_Faces(BMesh *bm, BMFace **faces, int totface)
 
        bmesh_systag_elements(bm, faces, totface, _FLAG_JF);
 
-       for (i=0; i<totface; i++) {
+       for (i = 0; i < totface; i++) {
                f = faces[i];
                l = bm_firstfaceloop(f);
                do {
@@ -904,7 +904,7 @@ BMFace *BM_Join_Faces(BMesh *bm, BMFace **faces, int totface)
                        l = l->next;
                } while (l != bm_firstfaceloop(f));
 
-               for (lst=f->loops.first; lst; lst=lst->next) {
+               for (lst = f->loops.first; lst; lst = lst->next) {
                        if (lst == f->loops.first) continue;
                        
                        BLI_remlink(&f->loops, lst);
@@ -912,7 +912,7 @@ BMFace *BM_Join_Faces(BMesh *bm, BMFace **faces, int totface)
                }
        }
 
-       /*create region face*/
+       /* create region fac */
        newf = BM_Make_Ngon(bm, v1, v2, edges, tote, 0);
        if (!newf || BMO_HasError(bm)) {
                if (!BMO_HasError(bm)) 
@@ -920,7 +920,7 @@ BMFace *BM_Join_Faces(BMesh *bm, BMFace **faces, int totface)
                goto error;
        }
 
-       /*copy over loop data*/
+       /* copy over loop dat */
        l = bm_firstfaceloop(newf);
        do {
                BMLoop *l2 = l->radial_next;
@@ -932,7 +932,7 @@ BMFace *BM_Join_Faces(BMesh *bm, BMFace **faces, int totface)
                } while (l2 != l);
 
                if (l2 != l) {
-                       /*I think this is correct?*/
+                       /* I think this is correct */
                        if (l2->v != l->v) {
                                l2 = l2->next;
                        }
@@ -945,11 +945,11 @@ BMFace *BM_Join_Faces(BMesh *bm, BMFace **faces, int totface)
        
        BM_Copy_Attributes(bm, bm, faces[0], newf);
 
-       /*add holes*/
+       /* add hole */
        BLI_movelisttolist(&newf->loops, &holes);
 
-       /*update loop face pointers*/
-       for (lst=newf->loops.first; lst; lst=lst->next) {
+       /* update loop face pointer */
+       for (lst = newf->loops.first; lst; lst = lst->next) {
                l = lst->first;
                do {
                        l->f = newf;
@@ -960,11 +960,11 @@ BMFace *BM_Join_Faces(BMesh *bm, BMFace **faces, int totface)
        bmesh_clear_systag_elements(bm, faces, totface, _FLAG_JF);
        bmesh_api_clearflag(newf, _FLAG_JF);
 
-       /* handle multires data*/
+       /* handle multires dat */
        if (CustomData_has_layer(&bm->ldata, CD_MDISPS)) {
                l = bm_firstfaceloop(newf);
                do {
-                       for (i=0; i<totface; i++) {
+                       for (i = 0; i < totface; i++) {
                                BM_loop_interp_multires(bm, l, faces[i]);
                        }
                        
@@ -972,12 +972,12 @@ BMFace *BM_Join_Faces(BMesh *bm, BMFace **faces, int totface)
                } while (l != bm_firstfaceloop(newf));
        }       
 
-       /*delete old geometry*/
-       for (i=0; i<BLI_array_count(deledges); i++) {
+       /* delete old geometr */
+       for (i = 0; i < BLI_array_count(deledges); i++) {
                BM_Kill_Edge(bm, deledges[i]);
        }
 
-       for (i=0; i<BLI_array_count(delverts); i++) {
+       for (i = 0; i < BLI_array_count(delverts); i++) {
                BM_Kill_Vert(bm, delverts[i]);
        }
        
@@ -1020,7 +1020,7 @@ static BMFace *bmesh_addpolylist(BMesh *bm, BMFace *UNUSED(example))
 
        bm->totface++;
 
-       /*allocate flags*/
+       /* allocate flag */
        f->head.flags = BLI_mempool_calloc(bm->toolflagpool);
 
        CustomData_bmesh_set_default(&bm->pdata, &f->head.data);
@@ -1028,7 +1028,7 @@ static BMFace *bmesh_addpolylist(BMesh *bm, BMFace *UNUSED(example))
        f->len = 0;
        f->totbounds = 1;
 
-       return (BMFace*) f;
+       return (BMFace *) f;
 }
 
 /**
@@ -1073,12 +1073,12 @@ BMFace *bmesh_sfme(BMesh *bm, BMFace *f, BMVert *v1, BMVert *v2,
 {
 
        BMFace *f2;
-       BMLoop *v1loop = NULL, *v2loop = NULL, *curloop, *f1loop=NULL, *f2loop=NULL;
+       BMLoop *v1loop = NULL, *v2loop = NULL, *curloop, *f1loop = NULL, *f2loop = NULL;
        BMEdge *e;
        BMLoopList *lst, *lst2;
        int i, len, f1len, f2len;
 
-       /*verify that v1 and v2 are in face.*/
+       /* verify that v1 and v2 are in face */
        len = f->len;
        for (i = 0, curloop = bm_firstfaceloop(f); i < len; i++, curloop = curloop->next) {
                if (curloop->v == v1) v1loop = curloop;
@@ -1087,12 +1087,12 @@ BMFace *bmesh_sfme(BMesh *bm, BMFace *f, BMVert *v1, BMVert *v2,
 
        if (!v1loop || !v2loop) return NULL;
 
-       /*allocate new edge between v1 and v2*/
+       /* allocate new edge between v1 and v2 */
        e = BM_Make_Edge(bm, v1, v2, NULL, 0);
 
-       f2 = bmesh_addpolylist(bm,f);
-       f1loop = bmesh_create_loop(bm,v2,e,f,v2loop);
-       f2loop = bmesh_create_loop(bm,v1,e,f2,v1loop);
+       f2 = bmesh_addpolylist(bm, f);
+       f1loop = bmesh_create_loop(bm, v2, e, f, v2loop);
+       f2loop = bmesh_create_loop(bm, v1, e, f2, v1loop);
 
        f1loop->prev = v2loop->prev;
        f2loop->prev = v1loop->prev;
@@ -1110,10 +1110,10 @@ BMFace *bmesh_sfme(BMesh *bm, BMFace *f, BMVert *v1, BMVert *v2,
        lst2->first = lst2->last = f2loop;
        lst->first = lst->last = f1loop;
 
-       /*validate both loops*/
-       /*I dont know how many loops are supposed to be in each face at this point! FIXME!*/
+       /* validate both loop */
+       /* I dont know how many loops are supposed to be in each face at this point! FIXME */
 
-       /*go through all of f2's loops and make sure they point to it properly.*/
+       /* go through all of f2's loops and make sure they point to it properly */
        curloop = lst2->first;
        f2len = 0;
        do {
@@ -1123,7 +1123,7 @@ BMFace *bmesh_sfme(BMesh *bm, BMFace *f, BMVert *v1, BMVert *v2,
                f2len++;
        } while (curloop != lst2->first);
 
-       /*link up the new loops into the new edges radial*/
+       /* link up the new loops into the new edges radia */
        bmesh_radial_append(e, f1loop);
        bmesh_radial_append(e, f2loop);
 
@@ -1144,9 +1144,9 @@ BMFace *bmesh_sfme(BMesh *bm, BMFace *f, BMVert *v1, BMVert *v2,
                BLI_movelisttolist(&f2->loops, holes);
        }
        else {
-               /* this code is not significant until holes actually work ;) */
+               /* this code is not significant until holes actually work */
                //printf("warning: call to split face euler without holes argument; holes will be tossed.\n");
-               for (lst=f->loops.last; lst != f->loops.first; lst=lst2) {
+               for (lst = f->loops.last; lst != f->loops.first; lst = lst2) {
                        lst2 = lst->prev;
                        BLI_mempool_free(bm->looplistpool, lst);
                }
@@ -1172,22 +1172,24 @@ BMFace *bmesh_sfme(BMesh *bm, BMFace *f, BMVert *v1, BMVert *v2,
  *  Returns -
  *     BMVert pointer.
  *
-*/
+ */
 
 BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **re)
 {
        BMLoop *nextl;
        BMEdge *ne;
        BMVert *nv, *ov;
-       int i, edok, valence1=0, valence2=0;
+       int i, edok, valence1 = 0, valence2 = 0;
 
-       if (bmesh_vert_in_edge(e,tv) == 0) return NULL;
-       ov = bmesh_edge_getothervert(e,tv);
+       if (bmesh_vert_in_edge(e, tv) == 0) {
+               return NULL;
+       }
+       ov = bmesh_edge_getothervert(e, tv);
 
-       /*count valence of v1*/
+       /* count valence of v1 */
        valence1 = bmesh_disk_count(ov);
 
-       /*count valence of v2*/
+       /* count valence of v2 */
        valence2 = bmesh_disk_count(tv);
 
        nv = BM_Make_Vert(bm, tv->co, tv);
@@ -1196,22 +1198,22 @@ BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **re)
        bmesh_disk_remove_edge(ne, tv);
        bmesh_disk_remove_edge(ne, nv);
 
-       /*remove e from v2's disk cycle*/
+       /* remove e from v2's disk cycle */
        bmesh_disk_remove_edge(e, tv);
 
-       /*swap out tv for nv in e*/
+       /* swap out tv for nv in e */
        bmesh_edge_swapverts(e, tv, nv);
 
-       /*add e to nv's disk cycle*/
+       /* add e to nv's disk cycl */
        bmesh_disk_append_edge(e, nv);
 
-       /*add ne to nv's disk cycle*/
+       /* add ne to nv's disk cycl */
        bmesh_disk_append_edge(ne, nv);
 
-       /*add ne to tv's disk cycle*/
+       /* add ne to tv's disk cycl */
        bmesh_disk_append_edge(ne, tv);
 
-       /*verify disk cycles*/
+       /* verify disk cycle */
        edok = bmesh_disk_validate(valence1, ov->e, ov);
        if (!edok) bmesh_error();
        edok = bmesh_disk_validate(valence2, tv->e, tv);
@@ -1219,34 +1221,34 @@ BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **re)
        edok = bmesh_disk_validate(2, nv->e, nv);
        if (!edok) bmesh_error();
 
-       /*Split the radial cycle if present*/
+       /* Split the radial cycle if presen */
        nextl = e->l;
        e->l = NULL;
        if (nextl) {
                BMLoop *nl, *l;
                int radlen = bmesh_radial_length(nextl);
-               int first1=0, first2=0;
+               int first1 = 0, first2 = 0;
 
-               /*Take the next loop. Remove it from radial. Split it. Append to appropriate radials.*/
+               /* Take the next loop. Remove it from radial. Split it. Append to appropriate radials */
                while (nextl) {
-                       l=nextl;
+                       l = nextl;
                        l->f->len++;
-                       nextl = nextl!=nextl->radial_next ? nextl->radial_next : NULL;
+                       nextl = nextl != nextl->radial_next ? nextl->radial_next : NULL;
                        bmesh_radial_remove_loop(l, NULL);
 
-                       nl = bmesh_create_loop(bm,NULL,NULL,l->f,l);
+                       nl = bmesh_create_loop(bm, NULL, NULL, l->f, l);
                        nl->prev = l;
                        nl->next = (l->next);
                        nl->prev->next = nl;
                        nl->next->prev = nl;
                        nl->v = nv;
 
-                       /*assign the correct edge to the correct loop*/
+                       /* assign the correct edge to the correct loo */
                        if (bmesh_verts_in_edge(nl->v, nl->next->v, e)) {
                                nl->e = e;
                                l->e = ne;
 
-                               /*append l into ne's rad cycle*/
+                               /* append l into ne's rad cycl */
                                if (!first1) {
                                        first1 = 1;
                                        l->radial_next = l->radial_prev = NULL;
@@ -1264,7 +1266,7 @@ BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **re)
                                nl->e = ne;
                                l->e = e;
 
-                               /*append l into ne's rad cycle*/
+                               /* append l into ne's rad cycl */
                                if (!first1) {
                                        first1 = 1;
                                        l->radial_next = l->radial_prev = NULL;
@@ -1281,14 +1283,14 @@ BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **re)
 
                }
 
-               /*verify length of radial cycle*/
+               /* verify length of radial cycl */
                edok = bmesh_radial_validate(radlen, e->l);
                if (!edok) bmesh_error();
                edok = bmesh_radial_validate(radlen, ne->l);
                if (!edok) bmesh_error();
 
-               /*verify loop->v and loop->next->v pointers for e*/
-               for (i=0,l=e->l; i < radlen; i++, l = l->radial_next) {
+               /* verify loop->v and loop->next->v pointers for  */
+               for (i = 0, l = e->l; i < radlen; i++, l = l->radial_next) {
                        if (!(l->e == e)) bmesh_error();
                        //if (!(l->radial_next == l)) bmesh_error();
                        if (l->prev->e != ne && l->next->e != ne) bmesh_error();
@@ -1297,14 +1299,14 @@ BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **re)
                        if (l->v == l->next->v) bmesh_error();
                        if (l->e == l->next->e) bmesh_error();
 
-                       /*verify loop cycle for kloop->f*/
+                       /* verify loop cycle for kloop-> */
                        BM_CHECK_ELEMENT(bm, l);
                        BM_CHECK_ELEMENT(bm, l->v);
                        BM_CHECK_ELEMENT(bm, l->e);
                        BM_CHECK_ELEMENT(bm, l->f);
                }
-               /*verify loop->v and loop->next->v pointers for ne*/
-               for (i=0,l=ne->l; i < radlen; i++, l = l->radial_next) {
+               /* verify loop->v and loop->next->v pointers for n */
+               for (i = 0, l = ne->l; i < radlen; i++, l = l->radial_next) {
                        if (!(l->e == ne)) bmesh_error();
                        //if (!(l->radial_next == l)) bmesh_error();
                        if (l->prev->e != e && l->next->e != e) bmesh_error();
@@ -1366,40 +1368,43 @@ int bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv)
        BMEdge *oe;
        BMVert *ov, *tv;
        BMLoop *killoop, *l;
-       int len,radlen=0, halt = 0, i, valence1, valence2,edok;
+       int len, radlen = 0, halt = 0, i, valence1, valence2, edok;
+
+       if (bmesh_vert_in_edge(ke, kv) == 0) {
+               return 0;
+       }
 
-       if (bmesh_vert_in_edge(ke,kv) == 0) return 0;
        len = bmesh_disk_count(kv);
        
        if (len == 2) {
                oe = bmesh_disk_nextedge(ke, kv);
                tv = bmesh_edge_getothervert(ke, kv);
                ov = bmesh_edge_getothervert(oe, kv);           
-               halt = bmesh_verts_in_edge(kv, tv, oe); /*check for double edges*/
+               halt = bmesh_verts_in_edge(kv, tv, oe); /* check for double edge */
                
                if (halt) {
                        return 0;
                }
                else {
-                       /*For verification later, count valence of ov and tv*/
+                       /* For verification later, count valence of ov and t */
                        valence1 = bmesh_disk_count(ov);
                        valence2 = bmesh_disk_count(tv);
                        
-                       /*remove oe from kv's disk cycle*/
-                       bmesh_disk_remove_edge(oe,kv);
-                       /*relink oe->kv to be oe->tv*/
+                       /* remove oe from kv's disk cycl */
+                       bmesh_disk_remove_edge(oe, kv);
+                       /* relink oe->kv to be oe->t */
                        bmesh_edge_swapverts(oe, kv, tv);
-                       /*append oe to tv's disk cycle*/
+                       /* append oe to tv's disk cycl */
                        bmesh_disk_append_edge(oe, tv);
-                       /*remove ke from tv's disk cycle*/
+                       /* remove ke from tv's disk cycl */
                        bmesh_disk_remove_edge(ke, tv);
                
-                       /*deal with radial cycle of ke*/
+                       /* deal with radial cycle of k */
                        radlen = bmesh_radial_length(ke->l);
                        if (ke->l) {
-                               /*first step, fix the neighboring loops of all loops in ke's radial cycle*/
-                               for (i=0,killoop = ke->l; i<radlen; i++, killoop = bmesh_radial_nextloop(killoop)) {
-                                       /*relink loops and fix vertex pointer*/
+                               /* first step, fix the neighboring loops of all loops in ke's radial cycl */
+                               for (i = 0, killoop = ke->l; i < radlen; i++, killoop = bmesh_radial_nextloop(killoop)) {
+                                       /* relink loops and fix vertex pointer */
                                        if (killoop->next->v == kv) killoop->next->v = tv;
 
                                        killoop->next->prev = killoop->prev;
@@ -1409,10 +1414,10 @@ int bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv)
                                        killoop->next = NULL;
                                        killoop->prev = NULL;
 
-                                       /*fix len attribute of face*/
+                                       /* fix len attribute of fac */
                                        killoop->f->len--;
                                }
-                               /*second step, remove all the hanging loops attached to ke*/
+                               /* second step, remove all the hanging loops attached to k */
                                radlen = bmesh_radial_length(ke->l);
 
                                if (LIKELY(radlen)) {
@@ -1421,7 +1426,7 @@ int bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv)
 
                                        killoop = ke->l;
 
-                                       /*this should be wrapped into a bme_free_radial function to be used by bmesh_KF as well...*/
+                                       /* this should be wrapped into a bme_free_radial function to be used by bmesh_KF as well.. */
                                        for (i = 0; i < radlen; i++) {
                                                loops[i] = killoop;
                                                killoop = bmesh_radial_nextloop(killoop);
@@ -1433,26 +1438,27 @@ int bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv)
                                        BLI_array_fixedstack_free(loops);
                                }
 
-                               /*Validate radial cycle of oe*/
-                               edok = bmesh_radial_validate(radlen,oe->l);
-                               if (!edok) bmesh_error();
-
+                               /* Validate radial cycle of o */
+                               edok = bmesh_radial_validate(radlen, oe->l);
+                               if (!edok) {
+                                       bmesh_error();
+                               }
                        }
 
-                       /*deallocate edge*/
+                       /* deallocate edg */
                        bmesh_kill_only_edge(bm, ke);
 
-                       /*deallocate vertex*/
+                       /* deallocate verte */
                        bmesh_kill_only_vert(bm, kv);
 
-                       /*Validate disk cycle lengths of ov,tv are unchanged*/
+                       /* Validate disk cycle lengths of ov, tv are unchange */
                        edok = bmesh_disk_validate(valence1, ov->e, ov);
                        if (!edok) bmesh_error();
                        edok = bmesh_disk_validate(valence2, tv->e, tv);
                        if (!edok) bmesh_error();
 
-                       /*Validate loop cycle of all faces attached to oe*/
-                       for (i=0,l = oe->l; i<radlen; i++, l = bmesh_radial_nextloop(l)) {
+                       /* Validate loop cycle of all faces attached to o */
+                       for (i = 0, l = oe->l; i < radlen; i++, l = bmesh_radial_nextloop(l)) {
                                if (l->e != oe) bmesh_error();
                                edok = bmesh_verts_in_edge(l->v, l->next->v, oe);
                                if (!edok) bmesh_error();
@@ -1505,16 +1511,19 @@ int bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv)
  *
  *  Returns -
  *     A BMFace pointer
-*/
+ */
 BMFace *bmesh_jfke(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e)
 {
-       BMLoop *curloop, *f1loop=NULL, *f2loop=NULL;
-       int newlen = 0,i, f1len=0, f2len=0, radlen=0, edok, shared;
+       BMLoop *curloop, *f1loop = NULL, *f2loop = NULL;
+       int newlen = 0, i, f1len = 0, f2len = 0, radlen = 0, edok, shared;
        BMIter iter;
 
-       /*can't join a face to itself*/
-       if (f1 == f2) return NULL;
-       /*verify that e is in both f1 and f2*/
+       /* can't join a face to itsel */
+       if (f1 == f2) {
+               return NULL;
+       }
+
+       /* verify that e is in both f1 and f2 */
        f1len = f1->len;
        f2len = f2->len;
        BM_ITER(curloop, &iter, bm, BM_LOOPS_OF_FACE, f1) {
@@ -1529,77 +1538,90 @@ BMFace *bmesh_jfke(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e)
                        break;
                }
        }
-       if (!(f1loop && f2loop)) return NULL;
+       if (!(f1loop && f2loop)) {
+               return NULL;
+       }
        
-       /*validate that edge is 2-manifold edge*/
+       /* validate that edge is 2-manifold edg */
        radlen = bmesh_radial_length(f1loop);
-       if (radlen != 2) return NULL;
+       if (radlen != 2) {
+               return NULL;
+       }
 
-       /*validate direction of f2's loop cycle is compatible.*/
+       /* validate direction of f2's loop cycle is compatible */
        if (f1loop->v == f2loop->v) return NULL;
 
-       /*
-               validate that for each face, each vertex has another edge in its disk cycle that is 
-               not e, and not shared.
-       */
-       if (bmesh_radial_find_face(f1loop->next->e,f2)) return NULL;
-       if (bmesh_radial_find_face(f1loop->prev->e,f2)) return NULL;
-       if (bmesh_radial_find_face(f2loop->next->e,f1)) return NULL;
-       if (bmesh_radial_find_face(f2loop->prev->e,f1)) return NULL;
-       
-       /*validate only one shared edge*/
-       shared = BM_Face_Share_Edges(f1,f2);
-       if (shared > 1) return NULL;
+       /* validate that for each face, each vertex has another edge in its disk cycle that is
+        * not e, and not shared. */
+       if ( bmesh_radial_find_face(f1loop->next->e, f2) ||
+            bmesh_radial_find_face(f1loop->prev->e, f2) ||
+            bmesh_radial_find_face(f2loop->next->e, f1) ||
+            bmesh_radial_find_face(f2loop->prev->e, f1) )
+       {
+               return NULL;
+       }
 
-       /*validate no internal joins*/
-       for (i=0, curloop = bm_firstfaceloop(f1); i < f1len; i++, curloop = curloop->next)
+       /* validate only one shared edg */
+       shared = BM_Face_Share_Edges(f1, f2);
+       if (shared > 1) {
+               return NULL;
+       }
+
+       /* validate no internal join */
+       for (i = 0, curloop = bm_firstfaceloop(f1); i < f1len; i++, curloop = curloop->next) {
                bmesh_api_setindex(curloop->v, 0);
-       for (i=0, curloop = bm_firstfaceloop(f2); i < f2len; i++, curloop = curloop->next)
+       }
+       for (i = 0, curloop = bm_firstfaceloop(f2); i < f2len; i++, curloop = curloop->next) {
                bmesh_api_setindex(curloop->v, 0);
+       }
 
-       for (i=0, curloop = bm_firstfaceloop(f1); i < f1len; i++, curloop = curloop->next) {
-               if (curloop != f1loop)
+       for (i = 0, curloop = bm_firstfaceloop(f1); i < f1len; i++, curloop = curloop->next) {
+               if (curloop != f1loop) {
                        bmesh_api_setindex(curloop->v, bmesh_api_getindex(curloop->v) + 1);
+               }
        }
-       for (i=0, curloop = bm_firstfaceloop(f2); i < f2len; i++, curloop = curloop->next) {
-               if (curloop != f2loop)
+       for (i = 0, curloop = bm_firstfaceloop(f2); i < f2len; i++, curloop = curloop->next) {
+               if (curloop != f2loop) {
                        bmesh_api_setindex(curloop->v, bmesh_api_getindex(curloop->v) + 1);
+               }
        }
 
-       for (i=0, curloop = bm_firstfaceloop(f1); i < f1len; i++, curloop = curloop->next) {
-               if (bmesh_api_getindex(curloop->v) > 1)
+       for (i = 0, curloop = bm_firstfaceloop(f1); i < f1len; i++, curloop = curloop->next) {
+               if (bmesh_api_getindex(curloop->v) > 1) {
                        return NULL;
+               }
        }
        
-       for (i=0, curloop = bm_firstfaceloop(f2); i < f2len; i++, curloop = curloop->next) {
-               if (bmesh_api_getindex(curloop->v) > 1)
+       for (i = 0, curloop = bm_firstfaceloop(f2); i < f2len; i++, curloop = curloop->next) {
+               if (bmesh_api_getindex(curloop->v) > 1) {
                        return NULL;
+               }
        }
 
-       /*join the two loops*/
+       /* join the two loop */
        f1loop->prev->next = f2loop->next;
        f2loop->next->prev = f1loop->prev;
        
        f1loop->next->prev = f2loop->prev;
        f2loop->prev->next = f1loop->next;
        
-       /*if f1loop was baseloop, make f1loop->next the base.*/
+       /* if f1loop was baseloop, make f1loop->next the base. */
        if (bm_firstfaceloop(f1) == f1loop)
                bm_firstfaceloop(f1) = f1loop->next;
 
-       /*increase length of f1*/
+       /* increase length of f1 */
        f1->len += (f2->len - 2);
 
-       /*make sure each loop points to the proper face*/
+       /* make sure each loop points to the proper fac */
        newlen = f1->len;
        for (i = 0, curloop = bm_firstfaceloop(f1); i < newlen; i++, curloop = curloop->next)
                curloop->f = f1;
        
-       /*remove edge from the disk cycle of its two vertices.*/
+       /* remove edge from the disk cycle of its two vertices */
        bmesh_disk_remove_edge(f1loop->e, f1loop->e->v1);
        bmesh_disk_remove_edge(f1loop->e, f1loop->e->v2);
        
-       /*deallocate edge and its two loops as well as f2*/
+       /* deallocate edge and its two loops as well as f2 */
        BLI_mempool_free(bm->toolflagpool, f1loop->e->head.flags);
        BLI_mempool_free(bm->epool, f1loop->e);
        bm->totedge--;
@@ -1615,7 +1637,7 @@ BMFace *bmesh_jfke(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e)
 
        BM_CHECK_ELEMENT(bm, f1);
 
-       /*validate the new loop cycle*/
+       /* validate the new loop cycle */
        edok = bmesh_loop_validate(f1);
        if (!edok) bmesh_error();
        
index d0d85f7fb0dcec77ba14e95bde735e2d235473a8..eae81ab6954d3b524839439ac7b3c6488eee1a0a 100644 (file)
 #include <stdio.h>
 
 
-/*
-ok, I'm going to write a little docgen script. so all
-bmop comments must conform to the following template/rules:
-
-template (py quotes used because nested comments don't work
-on all C compilers):
-
-"""
-Region Extend.
-
-paragraph1, Extends bleh bleh bleh.
-Bleh Bleh bleh.
-
-Another paragraph.
-
-Another paragraph.
-"""
-
-so the first line is the "title" of the bmop.
-subsequent line blocks seperated by blank lines
-are paragraphs.  individual descriptions of slots 
-would be extracted from comments
-next to them, e.g.
-
-{BMOP_OPSLOT_ELEMENT_BUF, "geomout"}, //output slot, boundary region
-
-the doc generator would automatically detect the presence of "output slot"
-and flag the slot as an output.  the same happens for "input slot".  also
-note that "edges", "faces", "verts", "loops", and "geometry" are valid 
-substitutions for "slot". 
-
-note that slots default to being input slots.
-*/
+/* ok, I'm going to write a little docgen script. so all
+ * bmop comments must conform to the following template/rules:
+ * 
+ * template (py quotes used because nested comments don't work
+ * on all C compilers):
+ * 
+ * """
+ * Region Extend.
+ * 
+ * paragraph1, Extends bleh bleh bleh.
+ * Bleh Bleh bleh.
+ * 
+ * Another paragraph.
+ * 
+ * Another paragraph.
+ * """
+ * 
+ * so the first line is the "title" of the bmop.
+ * subsequent line blocks seperated by blank lines
+ * are paragraphs.  individual descriptions of slots 
+ * would be extracted from comments
+ * next to them, e.g.
+ * 
+ * {BMOP_OPSLOT_ELEMENT_BUF, "geomout"}, //output slot, boundary region
+ * 
+ * the doc generator would automatically detect the presence of "output slot"
+ * and flag the slot as an output.  the same happens for "input slot".  also
+ * note that "edges", "faces", "verts", "loops", and "geometry" are valid 
+ * substitutions for "slot". 
+ * 
+ * note that slots default to being input slots.
+ */
 
 /*
-  Vertex Smooth
-
-  Smoothes vertices by using a basic vertex averaging scheme.
-*/
* Vertex Smooth
+ *
* Smoothes vertices by using a basic vertex averaging scheme.
+ */
 static BMOpDefine def_vertexsmooth = {
        "vertexsmooth",
        {{BMOP_OPSLOT_ELEMENT_BUF, "verts"}, //input vertices
@@ -105,106 +104,106 @@ static BMOpDefine def_vertexsmooth = {
         {BMOP_OPSLOT_INT, "mirror_clip_y"}, //set vertices close to the y axis before the operation to 0
         {BMOP_OPSLOT_INT, "mirror_clip_z"}, //set vertices close to the z axis before the operation to 0
         {BMOP_OPSLOT_FLT, "clipdist"}, //clipping threshod for the above three slots
-       {0} /*null-terminating sentinel*/,
+       {0} /* null-terminating sentine */,
        },
        bmesh_vertexsmooth_exec,
        0
 };
 
 /*
-  Right-Hand Faces
-
-  Computes an "outside" normal for the specified input faces.
-*/
* Right-Hand Faces
+ *
* Computes an "outside" normal for the specified input faces.
+ */
 
 static BMOpDefine def_righthandfaces = {
        "righthandfaces",
        {{BMOP_OPSLOT_ELEMENT_BUF, "faces"},
         {BMOP_OPSLOT_INT, "doflip"}, //internal flag, used by bmesh_rationalize_normals
-       {0} /*null-terminating sentinel*/,
+       {0} /* null-terminating sentine */,
        },
        bmesh_righthandfaces_exec,
        BMOP_UNTAN_MULTIRES,
 };
 
 /*
-  Region Extend
-  
-  used to implement the select more/less tools.
-  this puts some geometry surrounding regions of
-  geometry in geom into geomout.
-  
-  if usefaces is 0 then geomout spits out verts and edges, 
-  otherwise it spits out faces.
 */
* Region Extend
+ * 
* used to implement the select more/less tools.
* this puts some geometry surrounding regions of
* geometry in geom into geomout.
+ * 
* if usefaces is 0 then geomout spits out verts and edges, 
* otherwise it spits out faces.
+ */
 static BMOpDefine def_regionextend = {
        "regionextend",
        {{BMOP_OPSLOT_ELEMENT_BUF, "geom"}, //input geometry
         {BMOP_OPSLOT_ELEMENT_BUF, "geomout"}, //output slot, computed boundary geometry.
         {BMOP_OPSLOT_INT, "constrict"}, //find boundary inside the regions, not outside.
         {BMOP_OPSLOT_INT, "usefaces"}, //extend from faces instead of edges
-       {0} /*null-terminating sentinel*/,
+       {0} /* null-terminating sentine */,
        },
        bmesh_regionextend_exec,
        0
 };
 
 /*
-  Edge Rotate
-
-  Rotates edges topologically.  Also known as "spin edge" to some people.
-  Simple example: [/] becomes [|] then [\].
-*/
* Edge Rotate
+ *
* Rotates edges topologically.  Also known as "spin edge" to some people.
* Simple example: [/] becomes [|] then [\].
+ */
 static BMOpDefine def_edgerotate = {
        "edgerotate",
        {{BMOP_OPSLOT_ELEMENT_BUF, "edges"}, //input edges
         {BMOP_OPSLOT_ELEMENT_BUF, "edgeout"}, //newly spun edges
         {BMOP_OPSLOT_INT, "ccw"}, //rotate edge counter-clockwise if true, othewise clockwise
-       {0} /*null-terminating sentinel*/,
+       {0} /* null-terminating sentine */,
        },
        bmesh_edgerotate_exec,
        BMOP_UNTAN_MULTIRES
 };
 
 /*
-  Reverse Faces
-
-  Reverses the winding (vertex order) of faces.  This has the effect of
-  flipping the normal.
-*/
* Reverse Faces
+ *
* Reverses the winding (vertex order) of faces.  This has the effect of
* flipping the normal.
+ */
 static BMOpDefine def_reversefaces = {
        "reversefaces",
        {{BMOP_OPSLOT_ELEMENT_BUF, "faces"}, //input faces
-       {0} /*null-terminating sentinel*/,
+       {0} /* null-terminating sentine */,
        },
        bmesh_reversefaces_exec,
        BMOP_UNTAN_MULTIRES,
 };
 
 /*
-  Edge Bisect
-
-  Splits input edges (but doesn't do anything else).
-  This creates a 2-valence vert.
-*/
* Edge Bisect
+ * 
* Splits input edges (but doesn't do anything else).
* This creates a 2-valence vert.
+ */
 static BMOpDefine def_edgebisect = {
        "edgebisect",
        {{BMOP_OPSLOT_ELEMENT_BUF, "edges"}, //input edges
        {BMOP_OPSLOT_INT, "numcuts"}, //number of cuts
        {BMOP_OPSLOT_ELEMENT_BUF, "outsplit"}, //newly created vertices and edges
-       {0} /*null-terminating sentinel*/,
+       {0} /* null-terminating sentine */,
        },
        esplit_exec,
        BMOP_UNTAN_MULTIRES
 };
 
 /*
-  Mirror
-
-  Mirrors geometry along an axis.  The resulting geometry is welded on using
-  mergedist.  Pairs of original/mirrored vertices are welded using the mergedist
-  parameter (which defines the minimum distance for welding to happen).
-*/
* Mirror
+ *
* Mirrors geometry along an axis.  The resulting geometry is welded on using
* mergedist.  Pairs of original/mirrored vertices are welded using the mergedist
* parameter (which defines the minimum distance for welding to happen).
+ */
 
 static BMOpDefine def_mirror = {
        "mirror",
@@ -215,167 +214,166 @@ static BMOpDefine def_mirror = {
         {BMOP_OPSLOT_INT,         "axis"}, //the axis to use, 0, 1, or 2 for x, y, z
         {BMOP_OPSLOT_INT,         "mirror_u"}, //mirror UVs across the u axis
         {BMOP_OPSLOT_INT,         "mirror_v"}, //mirror UVs across the v axis
-        {0, /*null-terminating sentinel*/}},
+        {0, /* null-terminating sentine */}},
        bmesh_mirror_exec,
        0,
 };
 
 /*
-  Find Doubles
-
-  Takes input verts and find vertices they should weld to.  Outputs a
-  mapping slot suitable for use with the weld verts bmop.
-*/
* Find Doubles
+ *
* Takes input verts and find vertices they should weld to.  Outputs a
* mapping slot suitable for use with the weld verts bmop.
+ */
 static BMOpDefine def_finddoubles = {
        "finddoubles",
        {{BMOP_OPSLOT_ELEMENT_BUF, "verts"}, //input vertices
         {BMOP_OPSLOT_ELEMENT_BUF, "keepverts"}, //list of verts to keep
         {BMOP_OPSLOT_FLT,         "dist"}, //minimum distance
         {BMOP_OPSLOT_MAPPING, "targetmapout"},
-        {0, /*null-terminating sentinel*/}},
+        {0, /* null-terminating sentine */}},
        bmesh_finddoubles_exec,
        0,
 };
 
 /*
-  Remove Doubles
-
-  Finds groups of vertices closer then dist and merges them together,
-  using the weld verts bmop.
-*/
* Remove Doubles
+ *
* Finds groups of vertices closer then dist and merges them together,
* using the weld verts bmop.
+ */
 static BMOpDefine def_removedoubles = {
        "removedoubles",
        {{BMOP_OPSLOT_ELEMENT_BUF, "verts"}, //input verts
         {BMOP_OPSLOT_FLT,         "dist"}, //minimum distance
-        {0, /*null-terminating sentinel*/}},
+        {0, /* null-terminating sentine */}},
        bmesh_removedoubles_exec,
        BMOP_UNTAN_MULTIRES,
 };
 
 /*
-  Auto Merge
-
-  Finds groups of vertices closer then dist and merges them together,
-  using the weld verts bmop.  The merges must go from a vert not in
-  verts to one in verts.
-*/
* Auto Merge
+ * 
* Finds groups of vertices closer then dist and merges them together,
* using the weld verts bmop.  The merges must go from a vert not in
* verts to one in verts.
+ */
 static BMOpDefine def_automerge = {
        "automerge",
        {{BMOP_OPSLOT_ELEMENT_BUF, "verts"}, //input verts
         {BMOP_OPSLOT_FLT,         "dist"}, //minimum distance
-        {0, /*null-terminating sentinel*/}},
+        {0, /* null-terminating sentine */}},
        bmesh_automerge_exec,
        BMOP_UNTAN_MULTIRES,
 };
 
 /*
-  Collapse Connected
-
-  Collapses connected vertices
-*/
* Collapse Connected
+ *
* Collapses connected vertices
+ */
 static BMOpDefine def_collapse = {
        "collapse",
-       {{BMOP_OPSLOT_ELEMENT_BUF, "edges"}, /*input edges*/
-        {0, /*null-terminating sentinel*/}},
+       {{BMOP_OPSLOT_ELEMENT_BUF, "edges"}, /* input edge */
+        {0, /* null-terminating sentine */}},
        bmesh_collapse_exec,
        BMOP_UNTAN_MULTIRES,
 };
 
 
 /*
-  Facedata point Merge
-
-  Merge uv/vcols at a specific vertex.
-*/
* Facedata point Merge
+ *
* Merge uv/vcols at a specific vertex.
+ */
 static BMOpDefine def_pointmerge_facedata = {
        "pointmerge_facedata",
-       {{BMOP_OPSLOT_ELEMENT_BUF, "verts"}, /*input vertices*/
-        {BMOP_OPSLOT_ELEMENT_BUF, "snapv"}, /*snap vertex*/
-        {0, /*null-terminating sentinel*/}},
+       {{BMOP_OPSLOT_ELEMENT_BUF, "verts"}, /* input vertice */
+        {BMOP_OPSLOT_ELEMENT_BUF, "snapv"}, /* snap verte */
+        {0, /* null-terminating sentine */}},
        bmesh_pointmerge_facedata_exec,
        0,
 };
 
 /*
-  Average Vertices Facevert Data
-
-  Merge uv/vcols associated with the input vertices at
-  the bounding box center. (I know, it's not averaging but
-  the vert_snap_to_bb_center is just too long).
-*/
* Average Vertices Facevert Data
+ *
* Merge uv/vcols associated with the input vertices at
* the bounding box center. (I know, it's not averaging but
* the vert_snap_to_bb_center is just too long).
+ */
 static BMOpDefine def_vert_average_facedata = {
        "vert_average_facedata",
-       {{BMOP_OPSLOT_ELEMENT_BUF, "verts"}, /*input vertices*/
-        {0, /*null-terminating sentinel*/}},
+       {{BMOP_OPSLOT_ELEMENT_BUF, "verts"}, /* input vertice */
+        {0, /* null-terminating sentine */}},
        bmesh_vert_average_facedata_exec,
        0,
 };
 
 /*
-  Point Merge
-
-  Merge verts together at a point.
-*/
* Point Merge
+ *
* Merge verts together at a point.
+ */
 static BMOpDefine def_pointmerge = {
        "pointmerge",
-       {{BMOP_OPSLOT_ELEMENT_BUF, "verts"}, /*input vertices*/
+       {{BMOP_OPSLOT_ELEMENT_BUF, "verts"}, /* input vertice */
         {BMOP_OPSLOT_VEC,         "mergeco"},
-        {0, /*null-terminating sentinel*/}},
+        {0, /* null-terminating sentine */}},
        bmesh_pointmerge_exec,
        BMOP_UNTAN_MULTIRES,
 };
 
 /*
-  Collapse Connected UVs
-
-  Collapses connected UV vertices.
-*/
* Collapse Connected UVs
+ *
* Collapses connected UV vertices.
+ */
 static BMOpDefine def_collapse_uvs = {
        "collapse_uvs",
-       {{BMOP_OPSLOT_ELEMENT_BUF, "edges"}, /*input edges*/
-        {0, /*null-terminating sentinel*/}},
+       {{BMOP_OPSLOT_ELEMENT_BUF, "edges"}, /* input edge */
+        {0, /* null-terminating sentine */}},
        bmesh_collapsecon_exec,
        0,
 };
 
 /*
-  Weld Verts
-
-  Welds verts together (kindof like remove doubles, merge, etc, all of which
-  use or will use this bmop).  You pass in mappings from vertices to the vertices
-  they weld with.
-*/
* Weld Verts
+ *
* Welds verts together (kindof like remove doubles, merge, etc, all of which
* use or will use this bmop).  You pass in mappings from vertices to the vertices
* they weld with.
+ */
 static BMOpDefine def_weldverts = {
        "weldverts",
-       {{BMOP_OPSLOT_MAPPING, "targetmap"}, /*maps welded vertices to verts they should weld to.*/
-        {0, /*null-terminating sentinel*/}},
+       {{BMOP_OPSLOT_MAPPING, "targetmap"}, /* maps welded vertices to verts they should weld to */
+        {0, /* null-terminating sentine */}},
        bmesh_weldverts_exec,
        BMOP_UNTAN_MULTIRES,
 };
 
 /*
-  Make Vertex
-
-  Creates a single vertex; this bmop was necassary
-  for click-create-vertex.
-*/
* Make Vertex
+ *
* Creates a single vertex; this bmop was necassary
* for click-create-vertex.
+ */
 static BMOpDefine def_makevert = {
        "makevert",
        {{BMOP_OPSLOT_VEC, "co"}, //the coordinate of the new vert
        {BMOP_OPSLOT_ELEMENT_BUF, "newvertout"}, //the new vert
-       {0, /*null-terminating sentinel*/}},
+       {0, /* null-terminating sentine */}},
        bmesh_makevert_exec,
        0,
 };
 
 /*
-  Join Triangles
-
-  Tries to intelligently join triangles according 
-  to various settings and stuff.
-
-  */
-static BMOpDefine def_join_triangles= {
+ * Join Triangles
+ *
+ * Tries to intelligently join triangles according
+ * to various settings and stuff.
+ */
+static BMOpDefine def_join_triangles = {
        "join_triangles",
        {{BMOP_OPSLOT_ELEMENT_BUF, "faces"}, //input geometry.
         {BMOP_OPSLOT_ELEMENT_BUF, "faceout"}, //joined faces
@@ -384,225 +382,224 @@ static BMOpDefine def_join_triangles= {
         {BMOP_OPSLOT_INT, "compare_vcols"},
         {BMOP_OPSLOT_INT, "compare_materials"},
         {BMOP_OPSLOT_FLT, "limit"},
-        {0, /*null-terminating sentinel*/}},
+        {0, /* null-terminating sentine */}},
        bmesh_jointriangles_exec,
        BMOP_UNTAN_MULTIRES,
 };
 
 /*
-  Contextual Create
-
-  This is basically fkey, it creates
-  new faces from vertices, makes stuff from edge nets,
-  makes wire edges, etc.  It also dissolves
-  faces.
-  
-  Three verts become a triangle, four become a quad.  Two
-  become a wire edge.
 */
-static BMOpDefine def_contextual_create= {
* Contextual Create
+ *
* This is basically fkey, it creates
* new faces from vertices, makes stuff from edge nets,
* makes wire edges, etc.  It also dissolves
* faces.
+ *
* Three verts become a triangle, four become a quad.  Two
* become a wire edge.
+ */
+static BMOpDefine def_contextual_create = {
        "contextual_create",
        {{BMOP_OPSLOT_ELEMENT_BUF, "geom"}, //input geometry.
         {BMOP_OPSLOT_ELEMENT_BUF, "faceout"}, //newly-made face(s)
-        {0, /*null-terminating sentinel*/}},
+        {0, /* null-terminating sentine */}},
        bmesh_contextual_create_exec,
        BMOP_UNTAN_MULTIRES,
 };
 
 /*
-
-       Bridge edge loops with faces
-*/
-static BMOpDefine def_bridge_loops= {
+ * Bridge edge loops with faces
+ */
+static BMOpDefine def_bridge_loops = {
        "bridge_loops",
-       {{BMOP_OPSLOT_ELEMENT_BUF, "edges"}, /*input edges*/
-        {BMOP_OPSLOT_ELEMENT_BUF, "faceout"}, /*new faces*/
-       {0, /*null-terminating sentinel*/}},
+       {{BMOP_OPSLOT_ELEMENT_BUF, "edges"}, /* input edge */
+        {BMOP_OPSLOT_ELEMENT_BUF, "faceout"}, /* new face */
+       {0, /* null-terminating sentine */}},
        bmesh_bridge_loops_exec,
        0,
 };
 
-static BMOpDefine def_edgenet_fill= {
+static BMOpDefine def_edgenet_fill = {
        "edgenet_fill",
-       {{BMOP_OPSLOT_ELEMENT_BUF, "edges"}, /*input edges*/
-        {BMOP_OPSLOT_MAPPING,     "restrict"}, /*restricts edges to groups.  maps edges to integers*/
+       {{BMOP_OPSLOT_ELEMENT_BUF, "edges"}, /* input edge */
+        {BMOP_OPSLOT_MAPPING,     "restrict"}, /* restricts edges to groups.  maps edges to integer */
         {BMOP_OPSLOT_INT,         "use_restrict"},
-        {BMOP_OPSLOT_ELEMENT_BUF, "excludefaces"}, /*list of faces to ignore for manifold checks*/
-        {BMOP_OPSLOT_MAPPING,     "faceout_groupmap"}, /*maps new faces to the group numbers they came from*/
-        {BMOP_OPSLOT_ELEMENT_BUF, "faceout"}, /*new faces*/
-       {0, /*null-terminating sentinel*/}},
+        {BMOP_OPSLOT_ELEMENT_BUF, "excludefaces"}, /* list of faces to ignore for manifold check */
+        {BMOP_OPSLOT_MAPPING,     "faceout_groupmap"}, /* maps new faces to the group numbers they came fro */
+        {BMOP_OPSLOT_ELEMENT_BUF, "faceout"}, /* new face */
+       {0, /* null-terminating sentine */}},
        bmesh_edgenet_fill_exec,
        0,
 };
 
 /*
-  Edgenet Prepare
-
-  Identifies several useful edge loop cases and modifies them so
-  they'll become a face when edgenet_fill is called.  The cases covered are:
-
 * One single loop; an edge is added to connect the ends
 * Two loops; two edges are added to connect the endpoints (based on the
-    shortest distance between each endpont).
-*/
-static BMOpDefine def_edgenet_prepare= {
* Edgenet Prepare
+ *
* Identifies several useful edge loop cases and modifies them so
* they'll become a face when edgenet_fill is called.  The cases covered are:
+ *
* - One single loop; an edge is added to connect the ends
* - Two loops; two edges are added to connect the endpoints (based on the
*   shortest distance between each endpont).
+ */
+static BMOpDefine def_edgenet_prepare = {
        "edgenet_prepare",
        {{BMOP_OPSLOT_ELEMENT_BUF, "edges"}, //input edges
         {BMOP_OPSLOT_ELEMENT_BUF, "edgeout"}, //new edges
-       {0, /*null-terminating sentinel*/}},
+       {0, /* null-terminating sentine */}},
        bmesh_edgenet_prepare,
        0,
 };
 
 /*
-  Rotate
-
-  Rotate vertices around a center, using a 3x3 rotation
-  matrix.  Equivilent of the old rotateflag function.
-*/
* Rotate
+ *
* Rotate vertices around a center, using a 3x3 rotation
* matrix.  Equivilent of the old rotateflag function.
+ */
 static BMOpDefine def_rotate = {
        "rotate",
        {{BMOP_OPSLOT_VEC, "cent"}, //center of rotation
         {BMOP_OPSLOT_MAT, "mat"}, //matrix defining rotation
        {BMOP_OPSLOT_ELEMENT_BUF, "verts"}, //input vertices
-       {0, /*null-terminating sentinel*/}},
+       {0, /* null-terminating sentine */}},
        bmesh_rotate_exec,
        0,
 };
 
 /*
-  Translate
-
-  Translate vertices by an offset.  Equivelent of the
-  old translateflag function.
-*/
-static BMOpDefine def_translate= {
* Translate
+ *
* Translate vertices by an offset.  Equivelent of the
* old translateflag function.
+ */
+static BMOpDefine def_translate = {
        "translate",
        {{BMOP_OPSLOT_VEC, "vec"}, //translation offset
        {BMOP_OPSLOT_ELEMENT_BUF, "verts"}, //input vertices
-       {0, /*null-terminating sentinel*/}},
+       {0, /* null-terminating sentine */}},
        bmesh_translate_exec,
        0,
 };
 
 /*
-  Scale
-
-  Scales vertices by an offset.
-*/
-static BMOpDefine def_scale= {
* Scale
+ *
* Scales vertices by an offset.
+ */
+static BMOpDefine def_scale = {
        "scale",
        {{BMOP_OPSLOT_VEC, "vec"}, //scale factor
        {BMOP_OPSLOT_ELEMENT_BUF, "verts"}, //input vertices
-       {0, /*null-terminating sentinel*/}},
+       {0, /* null-terminating sentine */}},
        bmesh_scale_exec,
        0,
 };
 
 
 /*
-  Transform
-
-  Transforms a set of vertices by a matrix.  Multiplies
-  the vertex coordinates with the matrix.
-*/
* Transform
+ *
* Transforms a set of vertices by a matrix.  Multiplies
* the vertex coordinates with the matrix.
+ */
 static BMOpDefine def_transform = {
        "transform",
        {{BMOP_OPSLOT_MAT, "mat"}, //transform matrix
        {BMOP_OPSLOT_ELEMENT_BUF, "verts"}, //input vertices
-       {0, /*null-terminating sentinel*/}},
+       {0, /* null-terminating sentine */}},
        bmesh_transform_exec,
        0,
 };
 
 /*
-  Object Load BMesh
-
-  Loads a bmesh into an object/mesh.  This is a "private"
-  bmop.
-*/
* Object Load BMesh
+ *
* Loads a bmesh into an object/mesh.  This is a "private"
* bmop.
+ */
 static BMOpDefine def_object_load_bmesh = {
        "object_load_bmesh",
        {{BMOP_OPSLOT_PNT, "scene"},
        {BMOP_OPSLOT_PNT, "object"},
-       {0, /*null-terminating sentinel*/}},
+       {0, /* null-terminating sentine */}},
        object_load_bmesh_exec,
        0,
 };
 
 
 /*
-  BMesh to Mesh
-
-  Converts a bmesh to a Mesh.  This is reserved for exiting editmode.
-*/
* BMesh to Mesh
+ *
* Converts a bmesh to a Mesh.  This is reserved for exiting editmode.
+ */
 static BMOpDefine def_bmesh_to_mesh = {
        "bmesh_to_mesh",
        {{BMOP_OPSLOT_PNT, "mesh"}, //pointer to a mesh structure to fill in
         {BMOP_OPSLOT_PNT, "object"}, //pointer to an object structure
         {BMOP_OPSLOT_INT, "notesselation"}, //don't calculate mfaces
-        {0, /*null-terminating sentinel*/}},
+        {0, /* null-terminating sentine */}},
        bmesh_to_mesh_exec,
        0,
 };
 
 /*
-  Mesh to BMesh
-
-  Load the contents of a mesh into the bmesh.  this bmop is private, it's
-  reserved exclusively for entering editmode.
-*/
* Mesh to BMesh
+ *
* Load the contents of a mesh into the bmesh.  this bmop is private, it's
* reserved exclusively for entering editmode.
+ */
 static BMOpDefine def_mesh_to_bmesh = {
        "mesh_to_bmesh",
        {{BMOP_OPSLOT_PNT, "mesh"}, //pointer to a Mesh structure
         {BMOP_OPSLOT_PNT, "object"}, //pointer to an Object structure
         {BMOP_OPSLOT_INT, "set_shapekey"}, //load active shapekey coordinates into verts
-        {0, /*null-terminating sentinel*/}},
+        {0, /* null-terminating sentine */}},
        mesh_to_bmesh_exec,
        0
 };
 
 /*
-  Individual Face Extrude
-
-  Extrudes faces individually.
-*/
* Individual Face Extrude
+ *
* Extrudes faces individually.
+ */
 static BMOpDefine def_extrude_indivface = {
        "extrude_face_indiv",
        {{BMOP_OPSLOT_ELEMENT_BUF, "faces"}, //input faces
        {BMOP_OPSLOT_ELEMENT_BUF, "faceout"}, //output faces
        {BMOP_OPSLOT_ELEMENT_BUF, "skirtout"}, //output skirt geometry, faces and edges
-       {0} /*null-terminating sentinel*/},
+       {0} /* null-terminating sentine */},
        bmesh_extrude_face_indiv_exec,
        0
 };
 
 /*
-  Extrude Only Edges
-
-  Extrudes Edges into faces, note that this is very simple, there's no fancy
-  winged extrusion.
-*/
* Extrude Only Edges
+ *
* Extrudes Edges into faces, note that this is very simple, there's no fancy
* winged extrusion.
+ */
 static BMOpDefine def_extrude_onlyedge = {
        "extrude_edge_only",
        {{BMOP_OPSLOT_ELEMENT_BUF, "edges"}, //input vertices
        {BMOP_OPSLOT_ELEMENT_BUF, "geomout"}, //output geometry
-       {0} /*null-terminating sentinel*/},
+       {0} /* null-terminating sentine */},
        bmesh_extrude_onlyedge_exec,
        0
 };
 
 /*
-  Individual Vertex Extrude
-
-  Extrudes wire edges from vertices.
-*/
* Individual Vertex Extrude
+ *
* Extrudes wire edges from vertices.
+ */
 static BMOpDefine def_extrudeverts_indiv = {
        "extrude_vert_indiv",
        {{BMOP_OPSLOT_ELEMENT_BUF, "verts"}, //input vertices
        {BMOP_OPSLOT_ELEMENT_BUF, "edgeout"}, //output wire edges
        {BMOP_OPSLOT_ELEMENT_BUF, "vertout"}, //output vertices
-       {0} /*null-terminating sentinel*/},
+       {0} /* null-terminating sentine */},
        extrude_vert_indiv_exec,
        0
 };
@@ -611,7 +608,7 @@ static BMOpDefine def_connectverts = {
        "connectverts",
        {{BMOP_OPSLOT_ELEMENT_BUF, "verts"},
        {BMOP_OPSLOT_ELEMENT_BUF, "edgeout"},
-       {0} /*null-terminating sentinel*/},
+       {0} /* null-terminating sentine */},
        connectverts_exec,
        BMOP_UNTAN_MULTIRES
 };
@@ -622,7 +619,7 @@ static BMOpDefine def_extrudefaceregion = {
        {BMOP_OPSLOT_MAPPING, "exclude"},
        {BMOP_OPSLOT_INT, "alwayskeeporig"},
        {BMOP_OPSLOT_ELEMENT_BUF, "geomout"},
-       {0} /*null-terminating sentinel*/},
+       {0} /* null-terminating sentine */},
        extrude_edge_context_exec,
        0
 };
@@ -630,7 +627,7 @@ static BMOpDefine def_extrudefaceregion = {
 static BMOpDefine def_dissolvevertsop = {
        "dissolveverts",
        {{BMOP_OPSLOT_ELEMENT_BUF, "verts"},
-       {0} /*null-terminating sentinel*/},
+       {0} /* null-terminating sentine */},
        dissolveverts_exec,
        BMOP_UNTAN_MULTIRES
 };
@@ -639,7 +636,7 @@ static BMOpDefine def_dissolveedgessop = {
        "dissolveedges",
        {{BMOP_OPSLOT_ELEMENT_BUF, "edges"},
        {BMOP_OPSLOT_ELEMENT_BUF, "regionout"},
-       {0} /*null-terminating sentinel*/},
+       {0} /* null-terminating sentine */},
        dissolveedges_exec,
        BMOP_UNTAN_MULTIRES
 };
@@ -648,7 +645,7 @@ static BMOpDefine def_dissolveedgeloopsop = {
        "dissolveedgeloop",
        {{BMOP_OPSLOT_ELEMENT_BUF, "edges"},
        {BMOP_OPSLOT_ELEMENT_BUF, "regionout"},
-       {0} /*null-terminating sentinel*/},
+       {0} /* null-terminating sentine */},
        dissolve_edgeloop_exec,
        BMOP_UNTAN_MULTIRES
 };
@@ -657,7 +654,7 @@ static BMOpDefine def_dissolvefacesop = {
        "dissolvefaces",
        {{BMOP_OPSLOT_ELEMENT_BUF, "faces"},
        {BMOP_OPSLOT_ELEMENT_BUF, "regionout"},
-       {0} /*null-terminating sentinel*/},
+       {0} /* null-terminating sentine */},
        dissolvefaces_exec,
        BMOP_UNTAN_MULTIRES
 };
@@ -669,7 +666,7 @@ static BMOpDefine def_triangop = {
        {BMOP_OPSLOT_ELEMENT_BUF, "edgeout"},
        {BMOP_OPSLOT_ELEMENT_BUF, "faceout"},
        {BMOP_OPSLOT_MAPPING, "facemap"},
-       {0} /*null-terminating sentinel*/},
+       {0} /* null-terminating sentine */},
        triangulate_exec,
        BMOP_UNTAN_MULTIRES
 };
@@ -685,16 +682,16 @@ static BMOpDefine def_subdop = {
        {BMOP_OPSLOT_MAPPING, "custompatterns"},
        {BMOP_OPSLOT_MAPPING, "edgepercents"},
        
-       /*these next three can have multiple types of elements in them.*/
+       /* these next three can have multiple types of elements in them */
        {BMOP_OPSLOT_ELEMENT_BUF, "outinner"},
        {BMOP_OPSLOT_ELEMENT_BUF, "outsplit"},
-       {BMOP_OPSLOT_ELEMENT_BUF, "geomout"}, /*contains all output geometry*/
+       {BMOP_OPSLOT_ELEMENT_BUF, "geomout"}, /* contains all output geometr */
 
        {BMOP_OPSLOT_INT, "quadcornertype"}, //quad corner type, see bmesh_operators.h
        {BMOP_OPSLOT_INT, "gridfill"}, //fill in fully-selected faces with a grid
        {BMOP_OPSLOT_INT, "singleedge"}, //tesselate the case of one edge selected in a quad or triangle
 
-       {0} /*null-terminating sentinel*/,
+       {0} /* null-terminating sentine */,
        },
        esubdivide_exec,
        BMOP_UNTAN_MULTIRES
@@ -703,7 +700,7 @@ static BMOpDefine def_subdop = {
 static BMOpDefine def_delop = {
        "del",
        {{BMOP_OPSLOT_ELEMENT_BUF, "geom"}, {BMOP_OPSLOT_INT, "context"},
-       {0} /*null-terminating sentinel*/},
+       {0} /* null-terminating sentine */},
        delop_exec,
        0
 };
@@ -713,13 +710,13 @@ static BMOpDefine def_dupeop = {
        {{BMOP_OPSLOT_ELEMENT_BUF, "geom"},
        {BMOP_OPSLOT_ELEMENT_BUF, "origout"},
        {BMOP_OPSLOT_ELEMENT_BUF, "newout"},
-       /*facemap maps from source faces to dupe
-         faces, and from dupe faces to source faces.*/
+       /* facemap maps from source faces to dupe
+        * faces, and from dupe faces to source faces */
        {BMOP_OPSLOT_MAPPING, "facemap"},
        {BMOP_OPSLOT_MAPPING, "boundarymap"},
        {BMOP_OPSLOT_MAPPING, "isovertmap"},
-       {BMOP_OPSLOT_PNT, "dest"}, /*destination bmesh, if NULL will use current one*/
-       {0} /*null-terminating sentinel*/},
+       {BMOP_OPSLOT_PNT, "dest"}, /* destination bmesh, if NULL will use current on */
+       {0} /* null-terminating sentine */},
        dupeop_exec,
        0
 };
@@ -730,18 +727,18 @@ static BMOpDefine def_splitop = {
        {BMOP_OPSLOT_ELEMENT_BUF, "geomout"},
        {BMOP_OPSLOT_MAPPING, "boundarymap"},
        {BMOP_OPSLOT_MAPPING, "isovertmap"},
-       {BMOP_OPSLOT_PNT, "dest"}, /*destination bmesh, if NULL will use current one*/
-       {0} /*null-terminating sentinel*/},
+       {BMOP_OPSLOT_PNT, "dest"}, /* destination bmesh, if NULL will use current on */
+       {0} /* null-terminating sentine */},
        splitop_exec,
        0
 };
 
 /*
-  Spin
-
-  Extrude or duplicate geometry a number of times,
-  rotating and possibly translating after each step
-*/
* Spin
+ *
* Extrude or duplicate geometry a number of times,
* rotating and possibly translating after each step
+ */
 static BMOpDefine def_spinop = {
        "spin",
        {{BMOP_OPSLOT_ELEMENT_BUF, "geom"},
@@ -752,146 +749,146 @@ static BMOpDefine def_spinop = {
        {BMOP_OPSLOT_FLT, "ang"}, /* total rotation angle (degrees) */
        {BMOP_OPSLOT_INT, "steps"}, /* number of steps */
        {BMOP_OPSLOT_INT, "dupli"}, /* duplicate or extrude? */
-       {0} /*null-terminating sentinel*/},
+       {0} /* null-terminating sentine */},
        spinop_exec,
        0
 };
 
 
 /*
-  Similar faces search
-
 Find similar faces (area/material/perimeter....).
-*/
* Similar faces search
+ *
* Find similar faces (area/material/perimeter, ...).
+ */
 static BMOpDefine def_similarfaces = {
        "similarfaces",
        {{BMOP_OPSLOT_ELEMENT_BUF, "faces"}, /* input faces */
         {BMOP_OPSLOT_ELEMENT_BUF, "faceout"}, /* output faces */
         {BMOP_OPSLOT_INT, "type"},                     /* type of selection */
         {BMOP_OPSLOT_FLT, "thresh"},           /* threshold of selection */
-        {0} /*null-terminating sentinel*/},
+        {0} /* null-terminating sentine */},
        bmesh_similarfaces_exec,
        0
 };
 
 /*
-  Similar edges search
-
 Find similar edges (length, direction, edge, seam,....).
-*/
* Similar edges search
+ *
*  Find similar edges (length, direction, edge, seam, ...).
+ */
 static BMOpDefine def_similaredges = {
        "similaredges",
        {{BMOP_OPSLOT_ELEMENT_BUF, "edges"}, /* input edges */
         {BMOP_OPSLOT_ELEMENT_BUF, "edgeout"}, /* output edges */
         {BMOP_OPSLOT_INT, "type"},                     /* type of selection */
         {BMOP_OPSLOT_FLT, "thresh"},           /* threshold of selection */
-        {0} /*null-terminating sentinel*/},
+        {0} /* null-terminating sentine */},
        bmesh_similaredges_exec,
        0
 };
 
 /*
-  Similar vertices search
-
 Find similar vertices (normal, face, vertex group,....).
-*/
* Similar vertices search
+ *
* Find similar vertices (normal, face, vertex group, ...).
+ */
 static BMOpDefine def_similarverts = {
        "similarverts",
        {{BMOP_OPSLOT_ELEMENT_BUF, "verts"}, /* input vertices */
         {BMOP_OPSLOT_ELEMENT_BUF, "vertout"}, /* output vertices */
         {BMOP_OPSLOT_INT, "type"},                     /* type of selection */
         {BMOP_OPSLOT_FLT, "thresh"},           /* threshold of selection */
-        {0} /*null-terminating sentinel*/},
+        {0} /* null-terminating sentine */},
        bmesh_similarverts_exec,
        0
 };
 
 /*
-** uv rotation
-** cycle the uvs
-*/
+ * uv rotation
+ * cycle the uvs
+ */
 static BMOpDefine def_meshrotateuvs = {
        "meshrotateuvs",
        {{BMOP_OPSLOT_ELEMENT_BUF, "faces"}, /* input faces */
         {BMOP_OPSLOT_INT, "dir"},                      /* direction */
-        {0} /*null-terminating sentinel*/},
+        {0} /* null-terminating sentine */},
        bmesh_rotateuvs_exec,
        0
 };
 
 /*
-** uv reverse
-** reverse the uvs
-*/
+ * uv reverse
+ * reverse the uvs
+ */
 static BMOpDefine def_meshreverseuvs = {
        "meshreverseuvs",
        {{BMOP_OPSLOT_ELEMENT_BUF, "faces"}, /* input faces */
-        {0} /*null-terminating sentinel*/},
+        {0} /* null-terminating sentine */},
        bmesh_reverseuvs_exec,
        0
 };
 
 /*
-** color rotation
-** cycle the colors
-*/
+ * color rotation
+ * cycle the colors
+ */
 static BMOpDefine def_meshrotatecolors = {
        "meshrotatecolors",
        {{BMOP_OPSLOT_ELEMENT_BUF, "faces"}, /* input faces */
         {BMOP_OPSLOT_INT, "dir"},                      /* direction */
-        {0} /*null-terminating sentinel*/},
+        {0} /* null-terminating sentine */},
        bmesh_rotatecolors_exec,
        0
 };
 
 /*
-** color reverse
-** reverse the colors
-*/
+ * color reverse
+ * reverse the colors
+ */
 static BMOpDefine def_meshreversecolors = {
        "meshreversecolors",
        {{BMOP_OPSLOT_ELEMENT_BUF, "faces"}, /* input faces */
-        {0} /*null-terminating sentinel*/},
+        {0} /* null-terminating sentine */},
        bmesh_reversecolors_exec,
        0
 };
 
 /*
-  Similar vertices search
-
 Find similar vertices (normal, face, vertex group,....).
-*/
* Similar vertices search
+ *
* Find similar vertices (normal, face, vertex group, ...).
+ */
 static BMOpDefine def_vertexshortestpath = {
        "vertexshortestpath",
        {{BMOP_OPSLOT_ELEMENT_BUF, "startv"}, /* start vertex */
         {BMOP_OPSLOT_ELEMENT_BUF, "endv"}, /* end vertex */
         {BMOP_OPSLOT_ELEMENT_BUF, "vertout"}, /* output vertices */
         {BMOP_OPSLOT_INT, "type"},                     /* type of selection */
-        {0} /*null-terminating sentinel*/},
+        {0} /* null-terminating sentine */},
        bmesh_vertexshortestpath_exec,
        0
 };
 
 /*
-  Edge Split
-
-  Disconnects faces along input edges.
* Edge Split
+ *
* Disconnects faces along input edges.
  */
 static BMOpDefine def_edgesplit = {
        "edgesplit",
        {{BMOP_OPSLOT_ELEMENT_BUF, "edges"}, /* input edges */
         {BMOP_OPSLOT_ELEMENT_BUF, "edgeout1"}, /* old output disconnected edges */
         {BMOP_OPSLOT_ELEMENT_BUF, "edgeout2"}, /* new output disconnected edges */
-        {0} /*null-terminating sentinel*/},
+        {0} /* null-terminating sentine */},
        bmesh_edgesplitop_exec,
        BMOP_UNTAN_MULTIRES
 };
 
 /*
-  Create Grid
-
-  Creates a grid with a variable number of subdivisions
-*/
* Create Grid
+ *
* Creates a grid with a variable number of subdivisions
+ */
 static BMOpDefine def_create_grid = {
        "create_grid",
        {{BMOP_OPSLOT_ELEMENT_BUF, "vertout"}, //output verts
@@ -899,16 +896,16 @@ static BMOpDefine def_create_grid = {
         {BMOP_OPSLOT_INT,         "ysegments"}, //number of y segments
         {BMOP_OPSLOT_FLT,         "size"}, //size of the grid
         {BMOP_OPSLOT_MAT,         "mat"}, //matrix to multiply the new geometry with
-        {0, /*null-terminating sentinel*/}},
+        {0, /* null-terminating sentine */}},
        bmesh_create_grid_exec,
        0,
 };
 
 /*
-  Create UV Sphere
-
-  Creates a grid with a variable number of subdivisions
-*/
* Create UV Sphere
+ *
* Creates a grid with a variable number of subdivisions
+ */
 static BMOpDefine def_create_uvsphere = {
        "create_uvsphere",
        {{BMOP_OPSLOT_ELEMENT_BUF, "vertout"}, //output verts
@@ -916,46 +913,46 @@ static BMOpDefine def_create_uvsphere = {
         {BMOP_OPSLOT_INT,         "revolutions"}, //number of v segment
         {BMOP_OPSLOT_FLT,         "diameter"}, //diameter
         {BMOP_OPSLOT_MAT,         "mat"}, //matrix to multiply the new geometry with--
-        {0, /*null-terminating sentinel*/}},
+        {0, /* null-terminating sentine */}},
        bmesh_create_uvsphere_exec,
        0,
 };
 
 /*
-  Create Ico Sphere
-
-  Creates a grid with a variable number of subdivisions
-*/
* Create Ico Sphere
+ *
* Creates a grid with a variable number of subdivisions
+ */
 static BMOpDefine def_create_icosphere = {
        "create_icosphere",
        {{BMOP_OPSLOT_ELEMENT_BUF, "vertout"}, //output verts
         {BMOP_OPSLOT_INT,         "subdivisions"}, //how many times to recursively subdivide the sphere
         {BMOP_OPSLOT_FLT,       "diameter"}, //diameter
         {BMOP_OPSLOT_MAT, "mat"}, //matrix to multiply the new geometry with
-        {0, /*null-terminating sentinel*/}},
+        {0, /* null-terminating sentine */}},
        bmesh_create_icosphere_exec,
        0,
 };
 
 /*
-  Create Suzanne
-
-  Creates a monkey.  Be wary.
-*/
* Create Suzanne
+ *
* Creates a monkey.  Be wary.
+ */
 static BMOpDefine def_create_monkey = {
        "create_monkey",
        {{BMOP_OPSLOT_ELEMENT_BUF, "vertout"}, //output verts
         {BMOP_OPSLOT_MAT, "mat"}, //matrix to multiply the new geometry with--
-        {0, /*null-terminating sentinel*/}},
+        {0, /* null-terminating sentine */}},
        bmesh_create_monkey_exec,
        0,
 };
 
 /*
-  Create Cone
-
-  Creates a cone with variable depth at both ends
-*/
* Create Cone
+ *
* Creates a cone with variable depth at both ends
+ */
 static BMOpDefine def_create_cone = {
        "create_cone",
        {{BMOP_OPSLOT_ELEMENT_BUF, "vertout"}, //output verts
@@ -966,14 +963,14 @@ static BMOpDefine def_create_cone = {
         {BMOP_OPSLOT_FLT, "diameter2"}, //diameter of the opposite
         {BMOP_OPSLOT_FLT, "depth"}, //distance between ends
         {BMOP_OPSLOT_MAT, "mat"}, //matrix to multiply the new geometry with--
-        {0, /*null-terminating sentinel*/}},
+        {0, /* null-terminating sentine */}},
        bmesh_create_cone_exec,
        0,
 };
 
 /*
-Creates a circle
-*/
+ * Creates a circle
+ */
 static BMOpDefine def_create_circle = {
   "create_circle",
   {{BMOP_OPSLOT_ELEMENT_BUF, "vertout"}, //output verts
@@ -982,81 +979,81 @@ static BMOpDefine def_create_circle = {
    {BMOP_OPSLOT_INT, "segments"},
    {BMOP_OPSLOT_FLT, "diameter"}, //diameter of one end
    {BMOP_OPSLOT_MAT, "mat"}, //matrix to multiply the new geometry with--
-   {0, /*null-terminating sentinel*/}},
+   {0, /* null-terminating sentine */}},
   bmesh_create_circle_exec,
   0,
 };
 
 /*
-  Create Cone
-
-  Creates a cone with variable depth at both ends
-*/
* Create Cone
+ *
* Creates a cone with variable depth at both ends
+ */
 static BMOpDefine def_create_cube = {
        "create_cube",
        {{BMOP_OPSLOT_ELEMENT_BUF, "vertout"}, //output verts
         {BMOP_OPSLOT_FLT, "size"}, //size of the cube
         {BMOP_OPSLOT_MAT, "mat"}, //matrix to multiply the new geometry with--
-        {0, /*null-terminating sentinel*/}},
+        {0, /* null-terminating sentine */}},
        bmesh_create_cube_exec,
        0,
 };
 
 /*
-  Bevel
-
-  Bevels edges and vertices
* Bevel
+ *
* Bevels edges and vertices
  */
 static BMOpDefine def_bevel = {
        "bevel",
        {{BMOP_OPSLOT_ELEMENT_BUF, "geom"}, /* input edges and vertices */
         {BMOP_OPSLOT_ELEMENT_BUF, "face_spans"}, /* new geometry */
         {BMOP_OPSLOT_ELEMENT_BUF, "face_holes"}, /* new geometry */
-        {BMOP_OPSLOT_INT, "use_lengths"}, /* grab edge lengths from a PROP_FLT customdata layer*/
+        {BMOP_OPSLOT_INT, "use_lengths"}, /* grab edge lengths from a PROP_FLT customdata laye */
         {BMOP_OPSLOT_INT, "use_even"}, /* corner vert placement: use shell/angle calculations  */
         {BMOP_OPSLOT_INT, "use_dist"}, /* corner vert placement: evaluate percent as a distance,
                                         * modifier uses this. We could do this as another float setting */
-        {BMOP_OPSLOT_INT, "lengthlayer"}, /* which PROP_FLT layer to use*/
-        {BMOP_OPSLOT_FLT, "percent"}, /* percentage to expand bevelled edges*/
-        {0} /*null-terminating sentinel*/},
+        {BMOP_OPSLOT_INT, "lengthlayer"}, /* which PROP_FLT layer to us */
+        {BMOP_OPSLOT_FLT, "percent"}, /* percentage to expand bevelled edge */
+        {0} /* null-terminating sentine */},
        bmesh_bevel_exec,
        BMOP_UNTAN_MULTIRES
 };
 
 /*
-  Beautify Fill
-
-  Makes triangle a bit nicer
* Beautify Fill
+ *
* Makes triangle a bit nicer
  */
 static BMOpDefine def_beautify_fill = {
 "beautify_fill",
        {{BMOP_OPSLOT_ELEMENT_BUF, "faces"}, /* input faces */
         {BMOP_OPSLOT_ELEMENT_BUF, "constrain_edges"}, /* edges that can't be flipped */
         {BMOP_OPSLOT_ELEMENT_BUF, "geomout"}, /* new flipped faces and edges */
-        {0} /*null-terminating sentinel*/},
+        {0} /* null-terminating sentine */},
        bmesh_beautify_fill_exec,
        BMOP_UNTAN_MULTIRES
 };
 
 /*
-  Triangle Fill 
-
-  Fill edges with triangles
+ * Triangle Fill
+ *
* Fill edges with triangles
  */
 static BMOpDefine def_triangle_fill = {
        "triangle_fill",
        {{BMOP_OPSLOT_ELEMENT_BUF, "edges"}, /* input edges */
         {BMOP_OPSLOT_ELEMENT_BUF, "geomout"}, /* new faces and edges */
-        {0} /*null-terminating sentinel*/},
+        {0} /* null-terminating sentine */},
        bmesh_triangle_fill_exec,
        BMOP_UNTAN_MULTIRES
 };
 
 /*
-  Solidify
-
-  Turns a mesh into a shell with thickness
-*/
* Solidify
+ *
* Turns a mesh into a shell with thickness
+ */
 static BMOpDefine def_solidify = {
        "solidify",
        {{BMOP_OPSLOT_ELEMENT_BUF, "geom"},
@@ -1135,4 +1132,4 @@ BMOpDefine *opdefines[] = {
        &def_solidify,
 };
 
-int bmesh_total_ops = (sizeof(opdefines) / sizeof(void*));
+int bmesh_total_ops = (sizeof(opdefines) / sizeof(void *));
index 4695cda4a3f8932b3a1d8c7b2f2e926b8106b169..dcc76ba74f5f58a28656a9ae190d45f5df275502 100644 (file)
@@ -42,7 +42,7 @@
 
 #include <string.h>
 
-/*forward declarations*/
+/* forward declarations */
 static void alloc_flag_layer(BMesh *bm);
 static void free_flag_layer(BMesh *bm);
 static void clear_flag_layer(BMesh *bm);
@@ -65,16 +65,16 @@ static const char *bmop_error_messages[] = {
 };
 
 
-/*operator slot type information - size of one element of the type given.*/
+/* operator slot type information - size of one element of the type given. */
 const int BMOP_OPSLOT_TYPEINFO[] = {
        0,
        sizeof(int),
        sizeof(float),
-       sizeof(void*),
+       sizeof(void *),
        0, /* unused */
        0, /* unused */
        0, /* unused */
-       sizeof(void*),  /* pointer buffer */
+       sizeof(void *), /* pointer buffer */
        sizeof(element_mapping)
 };
 
@@ -102,7 +102,7 @@ void BMO_push(BMesh *bm, BMOperator *UNUSED(op))
 {
        bm->stackdepth++;
 
-       /*add flag layer, if appropriate*/
+       /* add flag layer, if appropriate */
        if (bm->stackdepth > 1)
                alloc_flag_layer(bm);
        else
@@ -142,23 +142,23 @@ void BMO_Init_Op(BMesh *bm, BMOperator *op, const char *opname)
 #endif
 
        if (opcode == -1) {
-               opcode= 0; /* error!, already printed, have a better way to handle this? */
+               opcode = 0; /* error!, already printed, have a better way to handle this? */
        }
 
        memset(op, 0, sizeof(BMOperator));
        op->type = opcode;
        op->flag = opdefines[opcode]->flag;
        
-       /*initialize the operator slot types*/
+       /* initialize the operator slot types */
        for (i = 0; opdefines[opcode]->slottypes[i].type; i++) {
                op->slots[i].slottype = opdefines[opcode]->slottypes[i].type;
                op->slots[i].index = i;
        }
 
-       /*callback*/
+       /* callback */
        op->exec = opdefines[opcode]->exec;
 
-       /*memarena, used for operator's slot buffers*/
+       /* memarena, used for operator's slot buffers */
        op->arena = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, "bmesh operator");
        BLI_memarena_use_calloc (op->arena);
 }
@@ -198,7 +198,7 @@ void BMO_Finish_Op(BMesh *bm, BMOperator *op)
        BMOpSlot *slot;
        int i;
 
-       for (i=0; opdefines[op->type]->slottypes[i].type; i++) {
+       for (i = 0; opdefines[op->type]->slottypes[i].type; i++) {
                slot = &op->slots[i];
                if (slot->slottype == BMOP_OPSLOT_MAPPING) {
                        if (slot->data.ghash) 
@@ -262,7 +262,7 @@ void BMO_CopySlot(BMOperator *source_op, BMOperator *dest_op, const char *src, c
        
        if (dest_slot->slottype > BMOP_OPSLOT_VEC) {
                if (dest_slot->slottype != BMOP_OPSLOT_MAPPING) {
-                       /*do buffer copy*/
+                       /* do buffer copy */
                        dest_slot->data.buf = NULL;
                        dest_slot->len = source_slot->len;
                        if (dest_slot->len) {
@@ -274,7 +274,7 @@ void BMO_CopySlot(BMOperator *source_op, BMOperator *dest_op, const char *src, c
                        GHashIterator it;
                        element_mapping *srcmap, *dstmap;
 
-                       /*sanity check*/
+                       /* sanity check */
                        if (!source_slot->data.ghash) return;
                        
                        if (!dest_slot->data.ghash) {
@@ -284,7 +284,7 @@ void BMO_CopySlot(BMOperator *source_op, BMOperator *dest_op, const char *src, c
                        }
 
                        BLI_ghashIterator_init(&it, source_slot->data.ghash);
-                       for ( ; (srcmap=BLI_ghashIterator_getValue(&it));
+                       for ( ; (srcmap = BLI_ghashIterator_getValue(&it));
                              BLI_ghashIterator_step(&it))
                        {
                                dstmap = BLI_memarena_alloc(dest_op->arena, 
@@ -292,10 +292,10 @@ void BMO_CopySlot(BMOperator *source_op, BMOperator *dest_op, const char *src, c
 
                                dstmap->element = srcmap->element;
                                dstmap->len = srcmap->len;
-                               memcpy(dstmap+1, srcmap+1, srcmap->len);
-                               
+                               memcpy(dstmap + 1, srcmap + 1, srcmap->len);
+
                                BLI_ghash_insert(dest_slot->data.ghash,
-                                               dstmap->element, dstmap);                               
+                                                dstmap->element, dstmap);
                        }
                }
        }
@@ -309,8 +309,7 @@ void BMO_CopySlot(BMOperator *source_op, BMOperator *dest_op, const char *src, c
  *
  * Sets the value of a slot depending on it's type
  *
-*/
-
+ */
 
 void BMO_Set_Float(BMOperator *op, const char *slotname, float f)
 {
@@ -330,7 +329,7 @@ void BMO_Set_Int(BMOperator *op, const char *slotname, int i)
        slot->data.i = i;
 }
 
-/*only supports square mats*/
+/* only supports square mats */
 void BMO_Set_Mat(struct BMOperator *op, const char *slotname, float *mat, int size)
 {
        BMOpSlot *slot = BMO_GetSlot(op, slotname);
@@ -338,10 +337,10 @@ void BMO_Set_Mat(struct BMOperator *op, const char *slotname, float *mat, int si
                return;
 
        slot->len = 4;
-       slot->data.p = BLI_memarena_alloc(op->arena, sizeof(float)*4*4);
+       slot->data.p = BLI_memarena_alloc(op->arena, sizeof(float) * 4 * 4);
        
        if (size == 4) {
-               memcpy(slot->data.p, mat, sizeof(float)*4*4);
+               memcpy(slot->data.p, mat, sizeof(float) * 4 * 4);
        }
        else if (size == 3) {
                copy_m4_m3(slot->data.p, (float (*)[3])mat);
@@ -349,7 +348,7 @@ void BMO_Set_Mat(struct BMOperator *op, const char *slotname, float *mat, int si
        else {
                fprintf(stderr, "%s: invalid size argument %d (bmesh internal error)\n", __func__, size);
 
-               memset(slot->data.p, 0, sizeof(float)*4*4);
+               memset(slot->data.p, 0, sizeof(float) * 4 * 4);
                return;
        }
 }
@@ -360,7 +359,7 @@ void BMO_Get_Mat4(struct BMOperator *op, const char *slotname, float mat[4][4])
        if (!(slot->slottype == BMOP_OPSLOT_MAT))
                return;
 
-       memcpy(mat, slot->data.p, sizeof(float)*4*4);
+       memcpy(mat, slot->data.p, sizeof(float) * 4 * 4);
 }
 
 void BMO_Get_Mat3(struct BMOperator *op, const char *slotname, float mat[3][3])
@@ -434,7 +433,7 @@ void BMO_Get_Vec(BMOperator *op, const char *slotname, float r_vec[3])
  * Counts the number of elements of a certain type that
  * have a specific flag set.
  *
-*/
+ */
 
 int BMO_CountFlag(BMesh *bm, int flag, const char htype)
 {
@@ -468,18 +467,15 @@ void BMO_Clear_Flag_All(BMesh *bm, BMOperator *UNUSED(op), const char htype, int
 {
        BMIter iter;
        BMHeader *ele;
-       int i=0, types[3] = {BM_VERTS_OF_MESH, BM_EDGES_OF_MESH, BM_FACES_OF_MESH};
-
-       for (i=0; i<3; i++) {
-               if (i==0 && !(htype & BM_VERT))
-                       continue;
-               if (i==1 && !(htype & BM_EDGE))
-                       continue;
-               if (i==2 && !(htype & BM_FACE))
-                       continue;
+       int types[3] = {BM_VERTS_OF_MESH, BM_EDGES_OF_MESH, BM_FACES_OF_MESH};
+       int flags[3] = {BM_VERT, BM_EDGE, BM_FACE};
+       int i;
 
-               BM_ITER(ele, &iter, bm, types[i], NULL) {
-                       BMO_ClearFlag(bm, ele, flag);
+       for (i = 0; i < 3; i++) {
+               if (htype & flags[i]) {
+                       BM_ITER(ele, &iter, bm, types[i], NULL) {
+                               BMO_ClearFlag(bm, ele, flag);
+                       }
                }
        }
 }
@@ -488,7 +484,7 @@ int BMO_CountSlotBuf(struct BMesh *UNUSED(bm), struct BMOperator *op, const char
 {
        BMOpSlot *slot = BMO_GetSlot(op, slotname);
        
-       /*check if its actually a buffer*/
+       /* check if its actually a buffer */
        if (!(slot->slottype > BMOP_OPSLOT_VEC))
                return 0;
 
@@ -499,7 +495,7 @@ int BMO_CountSlotMap(BMesh *UNUSED(bm), BMOperator *op, const char *slotname)
 {
        BMOpSlot *slot = BMO_GetSlot(op, slotname);
        
-       /*check if its actually a buffer*/
+       /* check if its actually a buffer */
        if (!(slot->slottype == BMOP_OPSLOT_MAPPING))
                return 0;
 
@@ -512,13 +508,13 @@ void *BMO_Grow_Array(BMesh *bm, BMOperator *op, int slotcode, int totadd)
        BMOpSlot *slot = &op->slots[slotcode];
        void *tmp;
        
-       /*check if its actually a buffer*/
+       /* check if its actually a buffer */
        if (!(slot->slottype > BMOP_OPSLOT_VEC))
                return NULL;
 
        if (slot->flag & BMOS_DYNAMIC_ARRAY) {
                if (slot->len >= slot->size) {
-                       slot->size = (slot->size+1+totadd)*2;
+                       slot->size = (slot->size + 1 + totadd) * 2;
 
                        tmp = slot->data.buf;
                        slot->data.buf = MEM_callocN(BMOP_OPSLOT_TYPEINFO[opdefines[op->type]->slottypes[slotcode].type] * slot->size, "opslot dynamic array");
@@ -531,7 +527,7 @@ void *BMO_Grow_Array(BMesh *bm, BMOperator *op, int slotcode, int totadd)
        else {
                slot->flag |= BMOS_DYNAMIC_ARRAY;
                slot->len += totadd;
-               slot->size = slot->len+2;
+               slot->size = slot->len + 2;
                tmp = slot->data.buf;
                slot->data.buf = MEM_callocN(BMOP_OPSLOT_TYPEINFO[opdefines[op->type]->slottypes[slotcode].type] * slot->len, "opslot dynamic array");
                memcpy(slot->data.buf, tmp, BMOP_OPSLOT_TYPEINFO[opdefines[op->type]->slottypes[slotcode].type] * slot->len);
@@ -548,12 +544,12 @@ void BMO_Mapping_To_Flag(struct BMesh *bm, struct BMOperator *op,
        BMOpSlot *slot = BMO_GetSlot(op, slotname);
        BMHeader *ele;
 
-       /*sanity check*/
+       /* sanity check */
        if (slot->slottype != BMOP_OPSLOT_MAPPING) return;
        if (!slot->data.ghash) return;
 
        BLI_ghashIterator_init(&it, slot->data.ghash);
-       for ( ; (ele=BLI_ghashIterator_getKey(&it)); BLI_ghashIterator_step(&it)) {
+       for ( ; (ele = BLI_ghashIterator_getKey(&it)); BLI_ghashIterator_step(&it)) {
                BMO_SetFlag(bm, ele, flag);
        }
 }
@@ -562,7 +558,7 @@ static void *alloc_slot_buffer(BMOperator *op, const char *slotname, int len)
 {
        BMOpSlot *slot = BMO_GetSlot(op, slotname);
 
-       /*check if its actually a buffer*/
+       /* check if its actually a buffer */
        if (!(slot->slottype > BMOP_OPSLOT_VEC))
                return NULL;
        
@@ -572,21 +568,19 @@ static void *alloc_slot_buffer(BMOperator *op, const char *slotname, int len)
        return slot->data.buf;
 }
 
-
 /*
- *
  * BMO_ALL_TO_SLOT
  *
  * Copies all elements of a certain type into an operator slot.
  *
-*/
+ */
 
 static void BMO_All_To_Slot(BMesh *bm, BMOperator *op, const char *slotname, const char htype)
 {
        BMIter elements;
        BMHeader *e;
        BMOpSlot *output = BMO_GetSlot(op, slotname);
-       int totelement=0, i=0;
+       int totelement = 0, i = 0;
        
        if (htype & BM_VERT) totelement += bm->totvert;
        if (htype & BM_EDGE) totelement += bm->totedge;
@@ -597,21 +591,21 @@ static void BMO_All_To_Slot(BMesh *bm, BMOperator *op, const char *slotname, con
 
                if (htype & BM_VERT) {
                        for (e = BMIter_New(&elements, bm, BM_VERTS_OF_MESH, bm); e; e = BMIter_Step(&elements)) {
-                               ((BMHeader**)output->data.p)[i] = e;
+                               ((BMHeader **)output->data.p)[i] = e;
                                i++;
                        }
                }
 
                if (htype & BM_EDGE) {
                        for (e = BMIter_New(&elements, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&elements)) {
-                               ((BMHeader**)output->data.p)[i] = e;
+                               ((BMHeader **)output->data.p)[i] = e;
                                i++;
                        }
                }
 
                if (htype & BM_FACE) {
                        for (e = BMIter_New(&elements, bm, BM_FACES_OF_MESH, bm); e; e = BMIter_Step(&elements)) {
-                               ((BMHeader**)output->data.p)[i] = e;
+                               ((BMHeader **)output->data.p)[i] = e;
                                i++;
                        }
                }
@@ -619,13 +613,11 @@ static void BMO_All_To_Slot(BMesh *bm, BMOperator *op, const char *slotname, con
 }
 
 /*
- *
  * BMO_HEADERFLAG_TO_SLOT
  *
  * Copies elements of a certain type, which have a certain header flag set 
  * into a slot for an operator.
- *
-*/
+ */
 
 void BMO_HeaderFlag_To_Slot(BMesh *bm, BMOperator *op, const char *slotname,
                             const char hflag, const char htype)
@@ -633,7 +625,7 @@ void BMO_HeaderFlag_To_Slot(BMesh *bm, BMOperator *op, const char *slotname,
        BMIter elements;
        BMHeader *e;
        BMOpSlot *output = BMO_GetSlot(op, slotname);
-       int totelement=0, i=0;
+       int totelement = 0, i = 0;
        
        totelement = BM_CountFlag(bm, htype, hflag, 1);
 
@@ -643,7 +635,7 @@ void BMO_HeaderFlag_To_Slot(BMesh *bm, BMOperator *op, const char *slotname,
                if (htype & BM_VERT) {
                        for (e = BMIter_New(&elements, bm, BM_VERTS_OF_MESH, bm); e; e = BMIter_Step(&elements)) {
                                if (!BM_TestHFlag(e, BM_HIDDEN) && BM_TestHFlag(e, hflag)) {
-                                       ((BMHeader**)output->data.p)[i] = e;
+                                       ((BMHeader **)output->data.p)[i] = e;
                                        i++;
                                }
                        }
@@ -652,7 +644,7 @@ void BMO_HeaderFlag_To_Slot(BMesh *bm, BMOperator *op, const char *slotname,
                if (htype & BM_EDGE) {
                        for (e = BMIter_New(&elements, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&elements)) {
                                if (!BM_TestHFlag(e, BM_HIDDEN) && BM_TestHFlag(e, hflag)) {
-                                       ((BMHeader**)output->data.p)[i] = e;
+                                       ((BMHeader **)output->data.p)[i] = e;
                                        i++;
                                }
                        }
@@ -661,7 +653,7 @@ void BMO_HeaderFlag_To_Slot(BMesh *bm, BMOperator *op, const char *slotname,
                if (htype & BM_FACE) {
                        for (e = BMIter_New(&elements, bm, BM_FACES_OF_MESH, bm); e; e = BMIter_Step(&elements)) {
                                if (!BM_TestHFlag(e, BM_HIDDEN) && BM_TestHFlag(e, hflag)) {
-                                       ((BMHeader**)output->data.p)[i] = e;
+                                       ((BMHeader **)output->data.p)[i] = e;
                                        i++;
                                }
                        }
@@ -685,7 +677,7 @@ void BMO_Flag_To_Slot(BMesh *bm, BMOperator *op, const char *slotname,
        BMIter elements;
        BMHeader *e;
        BMOpSlot *output = BMO_GetSlot(op, slotname);
-       int totelement = BMO_CountFlag(bm, flag, htype), i=0;
+       int totelement = BMO_CountFlag(bm, flag, htype), i = 0;
 
        if (totelement) {
                alloc_slot_buffer(op, slotname, totelement);
@@ -693,7 +685,7 @@ void BMO_Flag_To_Slot(BMesh *bm, BMOperator *op, const char *slotname,
                if (htype & BM_VERT) {
                        for (e = BMIter_New(&elements, bm, BM_VERTS_OF_MESH, bm); e; e = BMIter_Step(&elements)) {
                                if (BMO_TestFlag(bm, e, flag)) {
-                                       ((BMHeader**)output->data.p)[i] = e;
+                                       ((BMHeader **)output->data.p)[i] = e;
                                        i++;
                                }
                        }
@@ -702,7 +694,7 @@ void BMO_Flag_To_Slot(BMesh *bm, BMOperator *op, const char *slotname,
                if (htype & BM_EDGE) {
                        for (e = BMIter_New(&elements, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&elements)) {
                                if (BMO_TestFlag(bm, e, flag)) {
-                                       ((BMHeader**)output->data.p)[i] = e;
+                                       ((BMHeader **)output->data.p)[i] = e;
                                        i++;
                                }
                        }
@@ -711,7 +703,7 @@ void BMO_Flag_To_Slot(BMesh *bm, BMOperator *op, const char *slotname,
                if (htype & BM_FACE) {
                        for (e = BMIter_New(&elements, bm, BM_FACES_OF_MESH, bm); e; e = BMIter_Step(&elements)) {
                                if (BMO_TestFlag(bm, e, flag)) {
-                                       ((BMHeader**)output->data.p)[i] = e;
+                                       ((BMHeader **)output->data.p)[i] = e;
                                        i++;
                                }
                        }
@@ -774,14 +766,14 @@ void BMO_UnHeaderFlag_Buffer(BMesh *bm, BMOperator *op, const char *slotname,
 }
 int BMO_Vert_CountEdgeFlags(BMesh *bm, BMVert *v, int toolflag)
 {
-       int count= 0;
+       int count = 0;
 
        if (v->e) {
                BMEdge *curedge;
-               const int len= bmesh_disk_count(v);
+               const int len = bmesh_disk_count(v);
                int i;
                
-               for (i = 0, curedge=v->e; i<len; i++) {
+               for (i = 0, curedge = v->e; i < len; i++) {
                        if (BMO_TestFlag(bm, curedge, toolflag))
                                count++;
                        curedge = bmesh_disk_nextedge(curedge, v);
@@ -856,19 +848,19 @@ static void alloc_flag_layer(BMesh *bm)
        int i;
 
        BMIter iter;
-       BLI_mempool *oldpool = bm->toolflagpool;                /*old flag pool*/
+       BLI_mempool *oldpool = bm->toolflagpool;                /* old flag pool */
        BLI_mempool *newpool;
        void *oldflags;
 
        /* store memcpy size for reuse */
-       const size_t old_totflags_size= (bm->totflags * sizeof(BMFlagLayer));
+       const size_t old_totflags_size = (bm->totflags * sizeof(BMFlagLayer));
        
        bm->totflags++;
 
-       /*allocate new flag pool*/
-       bm->toolflagpool= newpool= BLI_mempool_create(sizeof(BMFlagLayer)*bm->totflags, 512, 512, FALSE, FALSE);
+       /* allocate new flag poo */
+       bm->toolflagpool = newpool = BLI_mempool_create(sizeof(BMFlagLayer)*bm->totflags, 512, 512, FALSE, FALSE);
        
-       /*now go through and memcpy all the flags. Loops don't get a flag layer at this time...*/
+       /* now go through and memcpy all the flags. Loops don't get a flag layer at this time.. */
        for (ele = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, bm), i = 0; ele; ele = BMIter_Step(&iter), i++) {
                oldflags = ele->flags;
                ele->flags = BLI_mempool_calloc(newpool);
@@ -906,14 +898,14 @@ static void free_flag_layer(BMesh *bm)
        void *oldflags;
        
        /* store memcpy size for reuse */
-       const size_t new_totflags_size= ((bm->totflags-1) * sizeof(BMFlagLayer));
+       const size_t new_totflags_size = ((bm->totflags - 1) * sizeof(BMFlagLayer));
 
-       /*de-increment the totflags first...*/
+       /* de-increment the totflags first.. */
        bm->totflags--;
-       /*allocate new flag pool*/
-       bm->toolflagpool= newpool= BLI_mempool_create(new_totflags_size, 512, 512, TRUE, FALSE);
+       /* allocate new flag poo */
+       bm->toolflagpool = newpool = BLI_mempool_create(new_totflags_size, 512, 512, TRUE, FALSE);
        
-       /*now go through and memcpy all the flags*/
+       /* now go through and memcpy all the flag */
        for (ele = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, bm), i = 0; ele; ele = BMIter_Step(&iter), i++) {
                oldflags = ele->flags;
                ele->flags = BLI_mempool_calloc(newpool);
@@ -948,15 +940,15 @@ static void clear_flag_layer(BMesh *bm)
        BMIter edges;
        BMIter faces;
        
-       /*now go through and memcpy all the flags*/
+       /* now go through and memcpy all the flag */
        for (v = BMIter_New(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BMIter_Step(&verts)) {
-               memset(v->head.flags+(bm->totflags-1), 0, sizeof(BMFlagLayer));
+               memset(v->head.flags + (bm->totflags - 1), 0, sizeof(BMFlagLayer));
        }
        for (e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)) {
-               memset(e->head.flags+(bm->totflags-1), 0, sizeof(BMFlagLayer));
+               memset(e->head.flags + (bm->totflags - 1), 0, sizeof(BMFlagLayer));
        }
        for (f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces)) {
-               memset(f->head.flags+(bm->totflags-1), 0, sizeof(BMFlagLayer));
+               memset(f->head.flags + (bm->totflags - 1), 0, sizeof(BMFlagLayer));
        }
 }
 
@@ -967,7 +959,7 @@ void *BMO_FirstElem(BMOperator *op, const char *slotname)
        if (slot->slottype != BMOP_OPSLOT_ELEMENT_BUF)
                return NULL;
 
-       return slot->data.buf ? *(void**)slot->data.buf : NULL;
+       return slot->data.buf ? *(void **)slot->data.buf : NULL;
 }
 
 void *BMO_IterNew(BMOIter *iter, BMesh *UNUSED(bm), BMOperator *op,
@@ -982,9 +974,12 @@ void *BMO_IterNew(BMOIter *iter, BMesh *UNUSED(bm), BMOperator *op,
        iter->restrictmask = restrictmask;
 
        if (iter->slot->slottype == BMOP_OPSLOT_MAPPING) {
-               if (iter->slot->data.ghash)
+               if (iter->slot->data.ghash) {
                        BLI_ghashIterator_init(&iter->giter, slot->data.ghash);
-               else return NULL;
+               }
+               else {
+                       return NULL;
+               }
        }
 
        return BMO_IterStep(iter);
@@ -995,12 +990,17 @@ void *BMO_IterStep(BMOIter *iter)
        if (iter->slot->slottype == BMOP_OPSLOT_ELEMENT_BUF) {
                BMHeader *h;
 
-               if (iter->cur >= iter->slot->len) return NULL;
+               if (iter->cur >= iter->slot->len) {
+                       return NULL;
+               }
 
-               h = ((void**)iter->slot->data.buf)[iter->cur++];
+               h = ((void **)iter->slot->data.buf)[iter->cur++];
                while (!(iter->restrictmask & h->htype)) {
-                       if (iter->cur >= iter->slot->len) return NULL;
-                       h = ((void**)iter->slot->data.buf)[iter->cur++];
+                       if (iter->cur >= iter->slot->len) {
+                               return NULL;
+                       }
+
+                       h = ((void **)iter->slot->data.buf)[iter->cur++];
                }
 
                return h;
@@ -1020,7 +1020,7 @@ void *BMO_IterStep(BMOIter *iter)
        return NULL;
 }
 
-/*used for iterating over mappings*/
+/* used for iterating over mapping */
 void *BMO_IterMapVal(BMOIter *iter)
 {
        return iter->val;
@@ -1028,15 +1028,15 @@ void *BMO_IterMapVal(BMOIter *iter)
 
 void *BMO_IterMapValp(BMOIter *iter)
 {
-       return *((void**)iter->val);
+       return *((void **)iter->val);
 }
 
 float BMO_IterMapValf(BMOIter *iter)
 {
-       return *((float*)iter->val);
+       return *((float *)iter->val);
 }
 
-/*error system*/
+/* error syste */
 typedef struct bmop_error {
        struct bmop_error *next, *prev;
        int errorcode;
@@ -1066,11 +1066,13 @@ int BMO_HasError(BMesh *bm)
        return bm->errorstack.first != NULL;
 }
 
-/*returns error code or 0 if no error*/
+/* returns error code or 0 if no erro */
 int BMO_GetError(BMesh *bm, const char **msg, BMOperator **op)
 {
        bmop_error *err = bm->errorstack.first;
-       if (!err) return 0;
+       if (!err) {
+               return 0;
+       }
 
        if (msg) *msg = err->msg;
        if (op) *op = err->op;
@@ -1092,7 +1094,7 @@ int BMO_PopError(BMesh *bm, const char **msg, BMOperator **op)
        return errorcode;
 }
 
-/*
+#if 0
 typedef struct bflag {
        const char *str;
        int flag;
@@ -1120,22 +1122,21 @@ int bmesh_str_to_flag(const char *str)
 
        return -1;
 }
-*/
+#endif
 
-//example:
-//BMO_CallOp(bm, "del %d %hv", DEL_ONLYFACES, BM_SELECT);
-/*
-  d - int
-  i - int
-  f - float
-  hv - header flagged verts
-  he - header flagged edges
-  hf - header flagged faces
-  fv - flagged verts
-  fe - flagged edges
-  ff - flagged faces
-  
-*/
+/* example:
+ * BMO_CallOp(bm, "del %d %hv", DEL_ONLYFACES, BM_SELECT);
+ *
+ *  d - int
+ *  i - int
+ *  f - float
+ *  hv - header flagged verts
+ *  he - header flagged edges
+ *  hf - header flagged faces
+ *  fv - flagged verts
+ *  fe - flagged edges
+ *  ff - flagged faces
+ */
 
 #define nextc(fmt) ((fmt)[0] != 0 ? (fmt)[1] : 0)
 
@@ -1143,8 +1144,10 @@ static int bmesh_name_to_slotcode(BMOpDefine *def, const char *name)
 {
        int i;
 
-       for (i=0; def->slottypes[i].type; i++) {
-               if (!strncmp(name, def->slottypes[i].name, MAX_SLOTNAME)) return i;
+       for (i = 0; def->slottypes[i].type; i++) {
+               if (!strncmp(name, def->slottypes[i].name, MAX_SLOTNAME)) {
+                       return i;
+               }
        }
 
        return -1;
@@ -1164,8 +1167,10 @@ static int bmesh_opname_to_opcode(const char *opname)
 {
        int i;
 
-       for (i=0; i<bmesh_total_ops; i++) {
-               if (!strcmp(opname, opdefines[i]->name)) return i;
+       for (i = 0; i < bmesh_total_ops; i++) {
+               if (!strcmp(opname, opdefines[i]->name)) {
+                       return i;
+               }
        }
 
        fprintf(stderr, "%s: ! could not find bmesh slot for name %s! (bmesh internal error)\n", __func__, opname);
@@ -1177,19 +1182,19 @@ int BMO_VInitOpf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist)
        BMOpDefine *def;
        char *opname, *ofmt, *fmt;
        char slotname[64] = {0};
-       int i /*, n=strlen(fmt) */, stop /*, slotcode = -1 */, ret, type, state;
-       int noslot=0;
+       int i /*, n = strlen(fmt) */, stop /*, slotcode = -1 */, ret, type, state;
+       int noslot = 0;
 
 
        /* basic useful info to help find where bmop formatting strings fail */
-       int lineno= -1;
-#   define GOTO_ERROR { lineno= __LINE__; goto error; }
+       int lineno = -1;
+#   define GOTO_ERROR { lineno = __LINE__; goto error; }
 
 
-       /*we muck around in here, so dup it*/
+       /* we muck around in here, so dup i */
        fmt = ofmt = BLI_strdup(_fmt);
        
-       /*find operator name*/
+       /* find operator nam */
        i = strcspn(fmt, " \t");
 
        opname = fmt;
@@ -1198,7 +1203,7 @@ int BMO_VInitOpf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist)
 
        fmt += i + (noslot ? 0 : 1);
        
-       i= bmesh_opname_to_opcode(opname);
+       i = bmesh_opname_to_opcode(opname);
 
        if (i == -1) {
                MEM_freeN(ofmt);
@@ -1213,17 +1218,17 @@ int BMO_VInitOpf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist)
 
        while (*fmt) {
                if (state) {
-                       /*jump past leading whitespace*/
+                       /* jump past leading whitespac */
                        i = strspn(fmt, " \t");
                        fmt += i;
                        
-                       /*ignore trailing whitespace*/
+                       /* ignore trailing whitespac */
                        if (!fmt[i])
                                break;
 
-                       /*find end of slot name.  currently this is
-                         a little flexible, allowing "slot=%f", 
-                         "slot %f", "slot%f", and "slot\t%f". */
+                       /* find end of slot name.  currently this is
+                        * a little flexible, allowing "slot=%f",
+                        * "slot %f", "slot%f", and "slot\t%f". */
                        i = strcspn(fmt, "= \t%");
                        if (!fmt[i]) GOTO_ERROR;
 
@@ -1253,29 +1258,29 @@ int BMO_VInitOpf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist)
                                else if (c == '4') size = 4;
                                else GOTO_ERROR;
 
-                               BMO_Set_Mat(op, slotname, va_arg(vlist, void*), size);
+                               BMO_Set_Mat(op, slotname, va_arg(vlist, void *), size);
                                state = 1;
                                break;
                        }
                        case 'v': {
-                               BMO_Set_Vec(op, slotname, va_arg(vlist, float*));
+                               BMO_Set_Vec(op, slotname, va_arg(vlist, float *));
                                state = 1;
                                break;
                        }
                        case 'e': {
-                               BMHeader *ele = va_arg(vlist, void*);
+                               BMHeader *ele = va_arg(vlist, void *);
                                BMOpSlot *slot = BMO_GetSlot(op, slotname);
 
-                               slot->data.buf = BLI_memarena_alloc(op->arena, sizeof(void*)*4);
+                               slot->data.buf = BLI_memarena_alloc(op->arena, sizeof(void *) * 4);
                                slot->len = 1;
-                               *((void**)slot->data.buf) = ele;
+                               *((void **)slot->data.buf) = ele;
 
                                state = 1;
                                break;
                        }
                        case 's': {
-                               BMOperator *op2 = va_arg(vlist, void*);
-                               const char *slotname2 = va_arg(vlist, char*);
+                               BMOperator *op2 = va_arg(vlist, void *);
+                               const char *slotname2 = va_arg(vlist, char *);
 
                                BMO_CopySlot(op2, op, slotname2, slotname);
                                state = 1;
@@ -1287,7 +1292,7 @@ int BMO_VInitOpf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist)
                                state = 1;
                                break;
                        case 'p':
-                               BMO_Set_Pnt(op, slotname, va_arg(vlist, void*));
+                               BMO_Set_Pnt(op, slotname, va_arg(vlist, void *));
                                state = 1;
                                break;
                        case 'f':
@@ -1295,19 +1300,17 @@ int BMO_VInitOpf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist)
                        case 'a':
                                type = *fmt;
 
-                               if (nextc(fmt) == ' ' || nextc(fmt) == '\t' || 
-                                   nextc(fmt)==0) 
-                               {
-                                       BMO_Set_Float(op,slotname,va_arg(vlist,double));
+                               if (nextc(fmt) == ' ' || nextc(fmt) == '\t' || nextc(fmt) == '\0') {
+                                       BMO_Set_Float(op, slotname, va_arg(vlist, double));
                                }
                                else {
                                        ret = 0;
                                        stop = 0;
                                        while (1) {
                                        switch (nextc(fmt)) {
-                                               case 'f': ret |= BM_FACE;break;
-                                               case 'e': ret |= BM_EDGE;break;
-                                               case 'v': ret |= BM_VERT;break;
+                                               case 'f': ret |= BM_FACE; break;
+                                               case 'e': ret |= BM_EDGE; break;
+                                               case 'v': ret |= BM_VERT; break;
                                                default:
                                                        stop = 1;
                                                        break;
@@ -1401,7 +1404,7 @@ int BMO_CallOpf(BMesh *bm, const char *fmt, ...)
 static void BMO_ToggleFlag(BMesh *bm, void *element, int flag)
 {
        BMHeader *head = element;
-       head->flags[bm->stackdepth-1].f ^= flag;
+       head->flags[bm->stackdepth - 1].f ^= flag;
 }
 
 /*
@@ -1414,8 +1417,8 @@ static void BMO_ToggleFlag(BMesh *bm, void *element, int flag)
 #endif
 static void BMO_SetFlag(BMesh *bm, void *element, const int flag)
 {
-       BMHeader *head= element;
-       head->flags[bm->stackdepth-1].f |= flag;
+       BMHeader *head = element;
+       head->flags[bm->stackdepth - 1].f |= flag;
 }
 
 /*
@@ -1428,8 +1431,8 @@ static void BMO_SetFlag(BMesh *bm, void *element, const int flag)
 #endif
 static void BMO_ClearFlag(BMesh *bm, void *element, const int flag)
 {
-       BMHeader *head= element;
-       head->flags[bm->stackdepth-1].f &= ~flag;
+       BMHeader *head = element;
+       head->flags[bm->stackdepth - 1].f &= ~flag;
 }
 
 /*
@@ -1444,7 +1447,7 @@ static void BMO_ClearFlag(BMesh *bm, void *element, const int flag)
 static int BMO_TestFlag(BMesh *bm, void *element, int flag)
 {
        BMHeader *head = element;
-       if (head->flags[bm->stackdepth-1].f & flag)
+       if (head->flags[bm->stackdepth - 1].f & flag)
                return 1;
        return 0;
 }
index dd163d3e248667fdc85ee85f965ca69006a23873..758fceb6c4c181866ae7fafdb1d9ed2d2c16c9d3 100644 (file)
  * Point in triangle tests stolen from scanfill.c.
  * Used for tesselator
  *
-*/
+ */
 
 static short testedgeside(const double v1[2], const double v2[2], const double v3[2])
-/* is v3 to the right of v1-v2 ? With exception: v3==v1 || v3==v2 */
 {
+       /* is v3 to the right of v1-v2 ? With exception: v3 == v1 || v3 == v2 */
        double inp;
 
-       //inp= (v2[cox]-v1[cox])*(v1[coy]-v3[coy]) +(v1[coy]-v2[coy])*(v1[cox]-v3[cox]);
-       inp= (v2[0]-v1[0])*(v1[1]-v3[1]) +(v1[1]-v2[1])*(v1[0]-v3[0]);
+       //inp = (v2[cox] - v1[cox]) * (v1[coy] - v3[coy]) + (v1[coy] - v2[coy]) * (v1[cox] - v3[cox]);
+       inp = (v2[0]-v1[0]) * (v1[1]-v3[1]) + (v1[1] - v2[1]) * (v1[0] - v3[0]);
 
-       if (inp<0.0) return 0;
-       else if (inp==0) {
-               if (v1[0]==v3[0] && v1[1]==v3[1]) return 0;
-               if (v2[0]==v3[0] && v2[1]==v3[1]) return 0;
+       if (inp < 0.0) return 0;
+       else if (inp == 0) {
+               if (v1[0] == v3[0] && v1[1] == v3[1]) return 0;
+               if (v2[0] == v3[0] && v2[1] == v3[1]) return 0;
        }
        return 1;
 }
 
 static short testedgesidef(const float v1[2], const float v2[2], const float v3[2])
-/* is v3 to the right of v1-v2 ? With exception: v3==v1 || v3==v2 */
 {
+       /* is v3 to the right of v1-v2 ? With exception: v3 == v1 || v3 == v2 */
        double inp;
 
-       //inp= (v2[cox]-v1[cox])*(v1[coy]-v3[coy]) +(v1[coy]-v2[coy])*(v1[cox]-v3[cox]);
-       inp= (v2[0]-v1[0])*(v1[1]-v3[1]) +(v1[1]-v2[1])*(v1[0]-v3[0]);
+       //inp = (v2[cox]-v1[cox])*(v1[coy]-v3[coy]) + (v1[coy]-v2[coy])*(v1[cox]-v3[cox]);
+       inp = (v2[0] - v1[0]) * (v1[1] - v3[1]) + (v1[1] - v2[1]) * (v1[0] - v3[0]);
 
-       if (inp<0.0) return 0;
-       else if (inp==0) {
-               if (v1[0]==v3[0] && v1[1]==v3[1]) return 0;
-               if (v2[0]==v3[0] && v2[1]==v3[1]) return 0;
+       if (inp < 0.0) {
+               return 0;
+       }
+       else if (inp == 0) {
+               if (v1[0] == v3[0] && v1[1] == v3[1]) return 0;
+               if (v2[0] == v3[0] && v2[1] == v3[1]) return 0;
        }
        return 1;
 }
 
 static int point_in_triangle(const double v1[2], const double v2[2], const double v3[2], const double pt[2])
 {
-       if (testedgeside(v1,v2,pt) && testedgeside(v2,v3,pt) && testedgeside(v3,v1,pt))
+       if (testedgeside(v1, v2, pt) && testedgeside(v2, v3, pt) && testedgeside(v3, v1, pt))
                return 1;
        return 0;
 }
@@ -104,23 +106,23 @@ static int point_in_triangle(const double v1[2], const double v2[2], const doubl
  * polygon See Graphics Gems for 
  * computing newell normal.
  *
-*/
+ */
 
 static void compute_poly_normal(float normal[3], float (*verts)[3], int nverts)
 {
 
-       float u[3], v[3], w[3];/*, *w, v1[3], v2[3];*/
-       float n[3]= {0.0f, 0.0f, 0.0f} /*, l, v1[3], v2[3] */;
+       float u[3], v[3], w[3]; /*, *w, v1[3], v2[3]; */
+       float n[3] = {0.0f, 0.0f, 0.0f} /*, l, v1[3], v2[3] */;
        /* double l2; */
-       int i /*, s=0 */;
+       int i /*, s = 0 */;
 
-       /*this fixes some weird numerical error*/
+       /* this fixes some weird numerical erro */
        add_v3_fl(verts[0], 0.0001f);
 
        for (i = 0; i < nverts; i++) {
                copy_v3_v3(u, verts[i]);
-               copy_v3_v3(v, verts[(i+1) % nverts]);
-               copy_v3_v3(w, verts[(i+2) % nverts]);
+               copy_v3_v3(v, verts[(i + 1) % nverts]);
+               copy_v3_v3(w, verts[(i + 2) % nverts]);
                
 #if 0
                sub_v3_v3v3(v1, w, v);
@@ -129,7 +131,7 @@ static void compute_poly_normal(float normal[3], float (*verts)[3], int nverts)
                normalize_v3(v2);
 
                l = dot_v3v3(v1, v2);
-               if (fabsf(l-1.0) < 0.1f) {
+               if (fabsf(l - 1.0) < 0.1f) {
                        continue;
                }
 #endif
@@ -156,12 +158,12 @@ static void compute_poly_normal(float normal[3], float (*verts)[3], int nverts)
 
 #if 0
        l = len_v3(n);
-       /*fast square root, newton/babylonian method:
-       l2 = l*0.1;
+       /* fast square root, newton/babylonian method:
+       l2 = l * 0.1;
 
-       l2 = (l/l2 + l2)*0.5;
-       l2 = (l/l2 + l2)*0.5;
-       l2 = (l/l2 + l2)*0.5;
+       l2 = (l / l2 + l2) * 0.5;
+       l2 = (l / l2 + l2) * 0.5;
+       l2 = (l / l2 + l2) * 0.5;
        */
 
        if (l == 0.0) {
@@ -188,19 +190,19 @@ static void compute_poly_normal(float normal[3], float (*verts)[3], int nverts)
  * area of a polygon in the X/Y
  * plane.
  *
-*/
+ */
 
 static int compute_poly_center(float center[3], float *r_area, float (*verts)[3], int nverts)
 {
        int i, j;
-       float atmp = 0.0, xtmp = 0.0, ytmp = 0.0, ai;
+       float atmp = 0.0f, xtmp = 0.0f, ytmp = 0.0f, ai;
 
        zero_v3(center);
 
        if (nverts < 3)
                return 0;
 
-       i = nverts-1;
+       i = nverts - 1;
        j = 0;
        
        while (j < nverts) {
@@ -246,10 +248,10 @@ float BM_Compute_Face_Area(BMesh *bm, BMFace *f)
 
        return area;
 }
-/*
-computes center of face in 3d.  uses center of bounding box.
-*/
 
+/*
+ * computes center of face in 3d.  uses center of bounding box.
+ */
 void BM_Compute_Face_CenterBounds(BMesh *bm, BMFace *f, float r_cent[3])
 {
        BMIter iter;
@@ -259,7 +261,7 @@ void BM_Compute_Face_CenterBounds(BMesh *bm, BMFace *f, float r_cent[3])
 
        INIT_MINMAX(min, max);
        l = BMIter_New(&iter, bm, BM_LOOPS_OF_FACE, f);
-       for (i=0; l; l=BMIter_Step(&iter), i++) {
+       for (i = 0; l; l = BMIter_Step(&iter), i++) {
                DO_MINMAX(l->v->co, min, max);
        }
 
@@ -275,7 +277,7 @@ void BM_Compute_Face_CenterMean(BMesh *bm, BMFace *f, float r_cent[3])
        zero_v3(r_cent);
 
        l = BMIter_New(&iter, bm, BM_LOOPS_OF_FACE, f);
-       for (i=0; l; l=BMIter_Step(&iter), i++) {
+       for (i = 0; l; l = BMIter_Step(&iter), i++) {
                add_v3_v3(r_cent, l->v->co);
        }
 
@@ -289,7 +291,7 @@ void BM_Compute_Face_CenterMean(BMesh *bm, BMFace *f, float r_cent[3])
  * a plane defined by the average
  * of its edges cross products
  *
-*/
+ */
 
 void compute_poly_plane(float (*verts)[3], int nverts)
 {
@@ -306,14 +308,14 @@ void compute_poly_plane(float (*verts)[3], int nverts)
 
        for (i = 0; i < nverts; i++) {
                v1 = verts[i];
-               v2 = verts[(i+1) % nverts];
-               v3 = verts[(i+2) % nverts];
-               normal_tri_v3(norm,v1, v2, v3);
+               v2 = verts[(i + 1) % nverts];
+               v3 = verts[(i + 2) % nverts];
+               normal_tri_v3(norm, v1, v2, v3);
 
                add_v3_v3(avgn, norm);
        }
 
-       /*what was this bit for?*/
+       /* what was this bit for */
        if (is_zero_v3(avgn)) {
                avgn[0] = 0.0f;
                avgn[1] = 0.0f;
@@ -336,12 +338,12 @@ void compute_poly_plane(float (*verts)[3], int nverts)
 }
 
 /*
-  BM LEGAL EDGES
-
-  takes in a face and a list of edges, and sets to NULL any edge in
-  the list that bridges a concave region of the face or intersects
-  any of the faces's edges.
-*/
* BM LEGAL EDGES
+ *
* takes in a face and a list of edges, and sets to NULL any edge in
* the list that bridges a concave region of the face or intersects
* any of the faces's edges.
+ */
 #if 0 /* needs BLI math double versions of these functions */
 static void shrink_edged(double *v1, double *v2, double fac)
 {
@@ -383,12 +385,12 @@ static void shrink_edgef(float v1[3], float v2[3], const float fac)
  * Rotates a polygon so that it's
  * normal is pointing towards the mesh Z axis
  *
-*/
+ */
 
 void poly_rotate_plane(const float normal[3], float (*verts)[3], const int nverts)
 {
 
-       float up[3] = {0.0f,0.0f,1.0f}, axis[3], q[4];
+       float up[3] = {0.0f, 0.0f, 1.0f}, axis[3], q[4];
        float mat[3][3];
        double angle;
        int i;
@@ -415,7 +417,7 @@ void poly_rotate_plane(const float normal[3], float (*verts)[3], const int nvert
  * coordinates for all of the face's vertices
  * is passed in as well.
  *
-*/
+ */
 
 void BM_Face_UpdateNormal(BMesh *bm, BMFace *f)
 {
@@ -449,7 +451,7 @@ void BM_Edge_UpdateNormals(BMesh *bm, BMEdge *e)
        BMFace *f;
        
        f = BMIter_New(&iter, bm, BM_FACES_OF_EDGE, e);
-       for ( ; f; f=BMIter_Step(&iter)) {
+       for ( ; f; f = BMIter_Step(&iter)) {
                BM_Face_UpdateNormal(bm, f);
        }
 
@@ -463,7 +465,7 @@ void BM_Vert_UpdateNormal(BMesh *bm, BMVert *v)
        BMEdge *e;
        BMLoop *l;
        float vec1[3], vec2[3], fac;
-       int len=0;
+       int len = 0;
 
        zero_v3(v->no);
 
@@ -494,10 +496,10 @@ void BM_Vert_UpdateAllNormals(BMesh *bm, BMVert *v)
 {
        BMIter iter;
        BMFace *f;
-       int len=0;
+       int len = 0;
 
        f = BMIter_New(&iter, bm, BM_FACES_OF_VERT, v);
-       for ( ; f; f=BMIter_Step(&iter), len++) {
+       for ( ; f; f = BMIter_Step(&iter), len++) {
                BM_Face_UpdateNormal(bm, f);
        }
 
@@ -606,7 +608,7 @@ void bmesh_update_face_normal_vertex_cos(BMesh *bm, BMFace *f, float no[3],
  *  Reverses the winding of a face.
  *  Note that this updates the calculated 
  *  normal.
-*/
+ */
 void BM_flip_normal(BMesh *bm, BMFace *f)
 {      
        bmesh_loop_reverse(bm, f);
@@ -614,41 +616,41 @@ void BM_flip_normal(BMesh *bm, BMFace *f)
 }
 
 /* detects if two line segments cross each other (intersects).
  note, there could be more winding cases then there needs to be. */
* note, there could be more winding cases then there needs to be. */
 static int UNUSED_FUNCTION(linecrosses)(const double v1[2], const double v2[2], const double v3[2], const double v4[2])
 {
        int w1, w2, w3, w4, w5;
        
-       /*w1 = winding(v1, v3, v4);
+       /* w1 = winding(v1, v3, v4);
        w2 = winding(v2, v3, v4);
        w3 = winding(v3, v1, v2);
        w4 = winding(v4, v1, v2);
        
-       return (w1 == w2) && (w3 == w4);*/
+       return (w1 == w2) && (w3 == w4); */
 
        w1 = testedgeside(v1, v3, v2);
        w2 = testedgeside(v2, v4, v1);
        w3 = !testedgeside(v1, v2, v3);
        w4 = testedgeside(v3, v2, v4);
        w5 = !testedgeside(v3, v1, v4);
-       return w1 == w2 && w2 == w3 && w3 == w4 && w4==w5;
+       return w1 == w2 && w2 == w3 && w3 == w4 && w4 == w5;
 }
 
 /* detects if two line segments cross each other (intersects).
  note, there could be more winding cases then there needs to be. */
* note, there could be more winding cases then there needs to be. */
 static int linecrossesf(const float v1[2], const float v2[2], const float v3[2], const float v4[2])
 {
-       int w1, w2, w3, w4, w5 /*, ret*/;
+       int w1, w2, w3, w4, w5 /*, re */;
        float mv1[2], mv2[2], mv3[2], mv4[2];
        
-       /*now test winding*/
+       /* now test windin */
        w1 = testedgesidef(v1, v3, v2);
        w2 = testedgesidef(v2, v4, v1);
        w3 = !testedgesidef(v1, v2, v3);
        w4 = testedgesidef(v3, v2, v4);
        w5 = !testedgesidef(v3, v1, v4);
        
-       if (w1 == w2 && w2 == w3 && w3 == w4 && w4==w5)
+       if (w1 == w2 && w2 == w3 && w3 == w4 && w4 == w5)
                return 1;
        
 #define GETMIN2_AXIS(a, b, ma, mb, axis) ma[axis] = MIN2(a[axis], b[axis]), mb[axis] = MAX2(a[axis], b[axis])
@@ -657,16 +659,16 @@ static int linecrossesf(const float v1[2], const float v2[2], const float v3[2],
        GETMIN2(v1, v2, mv1, mv2);
        GETMIN2(v3, v4, mv3, mv4);
        
-       /*do an interval test on the x and y axes*/
-       /*first do x axis*/
-       #define T FLT_EPSILON*15
+       /* do an interval test on the x and y axe */
+       /* first do x axi */
+       #define T FLT_EPSILON * 15
        if (ABS(v1[1]-v2[1]) < T && ABS(v3[1]-v4[1]) < T &&
            ABS(v1[1]-v3[1]) < T) 
        {
                return (mv4[0] >= mv1[0] && mv3[0] <= mv2[0]);
        }
 
-       /*now do y axis*/
+       /* now do y axi */
        if (ABS(v1[0]-v2[0]) < T && ABS(v3[0]-v4[0]) < T &&
            ABS(v1[0]-v3[0]) < T)
        {
@@ -677,22 +679,22 @@ static int linecrossesf(const float v1[2], const float v2[2], const float v3[2],
 }
 
 /*
-   BM POINT IN FACE
-   
-  Projects co onto face f, and returns true if it is inside
-  the face bounds.  Note that this uses a best-axis projection
-  test, instead of projecting co directly into f's orientation
-  space, so there might be accuracy issues.
-*/
*  BM POINT IN FACE
+ *
* Projects co onto face f, and returns true if it is inside
* the face bounds.  Note that this uses a best-axis projection
* test, instead of projecting co directly into f's orientation
* space, so there might be accuracy issues.
+ */
 int BM_Point_In_Face(BMesh *bm, BMFace *f, const float co[3])
 {
        int ax, ay;
-       float co2[3], cent[3] = {0.0f, 0.0f, 0.0f}, out[3] = {FLT_MAX*0.5f, FLT_MAX*0.5f, 0};
+       float co2[3], cent[3] = {0.0f, 0.0f, 0.0f}, out[3] = {FLT_MAX * 0.5f, FLT_MAX * 0.5f, 0};
        BMLoop *l;
        int crosses = 0;
-       float eps = 1.0f+(float)FLT_EPSILON*150.0f;
+       float eps = 1.0f + (float)FLT_EPSILON * 150.0f;
        
-       if (dot_v3v3(f->no, f->no) <= FLT_EPSILON*10)
+       if (dot_v3v3(f->no, f->no) <= FLT_EPSILON * 10)
                BM_Face_UpdateNormal(bm, f);
        
        /* find best projection of face XY, XZ or YZ: barycentric weights of
@@ -714,18 +716,18 @@ int BM_Point_In_Face(BMesh *bm, BMFace *f, const float co[3])
                l = l->next;
        } while (l != bm_firstfaceloop(f));
        
-       mul_v2_fl(cent, 1.0f/(float)f->len);
+       mul_v2_fl(cent, 1.0f / (float)f->len);
        
        l = bm_firstfaceloop(f);
        do {
                float v1[3], v2[3];
                
-               v1[0] = (l->prev->v->co[ax] - cent[ax])*eps + cent[ax];
-               v1[1] = (l->prev->v->co[ay] - cent[ay])*eps + cent[ay];
+               v1[0] = (l->prev->v->co[ax] - cent[ax]) * eps + cent[ax];
+               v1[1] = (l->prev->v->co[ay] - cent[ay]) * eps + cent[ay];
                v1[2] = 0.0f;
                
-               v2[0] = (l->v->co[ax] - cent[ax])*eps + cent[ax];
-               v2[1] = (l->v->co[ay] - cent[ay])*eps + cent[ay];
+               v2[0] = (l->v->co[ax] - cent[ax]) * eps + cent[ax];
+               v2[1] = (l->v->co[ay] - cent[ay]) * eps + cent[ay];
                v2[2] = 0.0f;
                
                crosses += linecrossesf(v1, v2, co2, out) != 0;
@@ -733,7 +735,7 @@ int BM_Point_In_Face(BMesh *bm, BMFace *f, const float co[3])
                l = l->next;
        } while (l != bm_firstfaceloop(f));