code cleanup: change C naming convention (so py and C api match), eg:
authorCampbell Barton <ideasman42@gmail.com>
Mon, 23 Apr 2012 01:19:50 +0000 (01:19 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Mon, 23 Apr 2012 01:19:50 +0000 (01:19 +0000)
    C: BM_face_calc_area(f), Py: BMFace.calc_area()

19 files changed:
source/blender/bmesh/intern/bmesh_marking.c
source/blender/bmesh/intern/bmesh_mesh.c
source/blender/bmesh/intern/bmesh_mesh.h
source/blender/bmesh/intern/bmesh_mods.c
source/blender/bmesh/intern/bmesh_mods.h
source/blender/bmesh/intern/bmesh_polygon.c
source/blender/bmesh/intern/bmesh_polygon.h
source/blender/bmesh/intern/bmesh_private.h
source/blender/bmesh/intern/bmesh_queries.c
source/blender/bmesh/intern/bmesh_queries.h
source/blender/bmesh/operators/bmo_dissolve.c
source/blender/bmesh/operators/bmo_inset.c
source/blender/bmesh/operators/bmo_utils.c
source/blender/bmesh/tools/BME_bevel.c
source/blender/editors/mesh/editmesh_rip.c
source/blender/editors/space_view3d/drawobject.c
source/blender/editors/transform/transform_conversions.c
source/blender/editors/uvedit/uvedit_draw.c
source/blender/python/bmesh/bmesh_py_types.c

index b0a39326fe8e847ded64fa9ba5a0c0ee1e747c7e..9200d7d2a98e7f4b23f8e0d4b583b27d8280660a 100644 (file)
@@ -579,7 +579,7 @@ void BM_editselection_center(float r_center[3], BMEditSelection *ese)
        }
        else if (ese->htype == BM_FACE) {
                BMFace *efa = (BMFace *)ese->ele;
-               BM_face_center_bounds_calc(efa, r_center);
+               BM_face_calc_center_bounds(efa, r_center);
        }
 }
 
index 0a5e3bab804447529e71cff2426feed286c158bb..6c208b46244ab06ff04e372e8bd43868fb17f3d6 100644 (file)
@@ -584,6 +584,18 @@ void BM_mesh_elem_index_validate(BMesh *bm, const char *location, const char *fu
 
 }
 
+/**
+ * Return the amount of element of type 'type' in a given bmesh.
+ */
+int BM_mesh_elem_count(BMesh *bm, const char htype)
+{
+       if (htype == BM_VERT) return bm->totvert;
+       else if (htype == BM_EDGE) return bm->totedge;
+       else if (htype == BM_FACE) return bm->totface;
+
+       return 0;
+}
+
 /**
  * Remaps the vertices, edges and/or faces of the bmesh as indicated by vert/edge/face_idx arrays
  * (xxx_idx[org_index] = new_index).
index 970db6339c3a178d18cd66c02e79efdff29cf67b..0441f38b42967218be935d9a2084d4b786d0099a 100644 (file)
@@ -43,6 +43,8 @@ void bmesh_edit_end(BMesh *bm, int flag);
 void BM_mesh_elem_index_ensure(BMesh *bm, const char hflag);
 void BM_mesh_elem_index_validate(BMesh *bm, const char *location, const char *func,
                                  const char *msg_a, const char *msg_b);
+int  BM_mesh_elem_count(BMesh *bm, const char htype);
+
 void BM_mesh_remap(BMesh *bm, int *vert_idx, int *edge_idx, int *face_idx);
 
 BMVert *BM_vert_at_index(BMesh *bm, const int index);
index 21654097219ea043c325bd9751ac88843fb7a11c..3474d4b3194729be3526c03be58ff2719c118eec 100644 (file)
@@ -817,7 +817,7 @@ int BM_face_validate(BMesh *bm, BMFace *face, FILE *err)
  *
  * \note #BM_edge_rotate_check must have already run.
  */
-void BM_edge_rotate_calc(BMEdge *e, int ccw,
+void BM_edge_calc_rotate(BMEdge *e, int ccw,
                          BMLoop **r_l1, BMLoop **r_l2)
 {
        BMVert *v1, *v2;
@@ -889,7 +889,7 @@ int BM_edge_rotate_check(BMEdge *e)
  * 2) does the newly formed edge cause a zero area corner (or close enough to be almost zero)
  *
  * \param l1,l2 are the loops of the proposed verts to rotate too and should
- * be the result of calling #BM_edge_rotate_calc
+ * be the result of calling #BM_edge_calc_rotate
  */
 int BM_edge_rotate_check_degenerate(BMEdge *e, BMLoop *l1, BMLoop *l2)
 {
@@ -1016,7 +1016,7 @@ BMEdge *BM_edge_rotate(BMesh *bm, BMEdge *e, const short ccw, const short check_
                return NULL;
        }
 
-       BM_edge_rotate_calc(e, ccw, &l1, &l2);
+       BM_edge_calc_rotate(e, ccw, &l1, &l2);
 
        /* the loops will be freed so assign verts */
        v1 = l1->v;
index ba6acac1a2759224bcf849ae3a2dc16a23d43d24..2cb599f75d33914a8a7c10b4815e91ce14246924 100644 (file)
@@ -59,7 +59,7 @@ BMVert *BM_edge_split_n(BMesh *bm, BMEdge *e, int numcuts);
 
 int     BM_face_validate(BMesh *bm, BMFace *face, FILE *err);
 
-void    BM_edge_rotate_calc(BMEdge *e, int ccw,
+void    BM_edge_calc_rotate(BMEdge *e, int ccw,
                             BMLoop **r_l1, BMLoop **r_l2);
 int     BM_edge_rotate_check(BMEdge *e);
 int     BM_edge_rotate_check_degenerate(BMEdge *e,
index e7ee5cb605d624d1f9a7ed0d35e30bd4d8b606d3..2e41d4b923c9e4554a0d33bbcee7ffe02452c654 100644 (file)
@@ -75,7 +75,7 @@ static short testedgesidef(const float v1[2], const float v2[2], const float v3[
  * polygon See Graphics Gems for
  * computing newell normal.
  */
-static void compute_poly_normal(float normal[3], float verts[][3], int nverts)
+static void calc_poly_normal(float normal[3], float verts[][3], int nverts)
 {
        float const *v_prev = verts[nverts - 1];
        float const *v_curr = verts[0];
@@ -95,9 +95,9 @@ static void compute_poly_normal(float normal[3], float verts[][3], int nverts)
 /**
  * \brief COMPUTE POLY NORMAL (BMFace)
  *
- * Same as #compute_poly_normal but operates directly on a bmesh face.
+ * Same as #calc_poly_normal but operates directly on a bmesh face.
  */
-static void bm_face_compute_poly_normal(BMFace *f)
+static void bm_face_calc_poly_normal(BMFace *f)
 {
        BMLoop *l_first = BM_FACE_FIRST_LOOP(f);
        BMLoop *l_iter  = l_first;
@@ -123,11 +123,11 @@ static void bm_face_compute_poly_normal(BMFace *f)
 /**
  * \brief COMPUTE POLY NORMAL (BMFace)
  *
- * Same as #compute_poly_normal and #bm_face_compute_poly_normal
+ * Same as #calc_poly_normal and #bm_face_calc_poly_normal
  * but takes an array of vertex locations.
  */
-static void bm_face_compute_poly_normal_vertex_cos(BMFace *f, float n[3],
-                                                   float const (*vertexCos)[3])
+static void bm_face_calc_poly_normal_vertex_cos(BMFace *f, float n[3],
+                                                float const (*vertexCos)[3])
 {
        BMLoop *l_first = BM_FACE_FIRST_LOOP(f);
        BMLoop *l_iter  = l_first;
@@ -153,7 +153,7 @@ static void bm_face_compute_poly_normal_vertex_cos(BMFace *f, float n[3],
 /**
  * get the area of the face
  */
-float BM_face_area_calc(BMFace *f)
+float BM_face_calc_area(BMFace *f)
 {
        BMLoop *l;
        BMIter iter;
@@ -175,7 +175,7 @@ float BM_face_area_calc(BMFace *f)
                area = area_quad_v3(verts[0], verts[1], verts[2], verts[3]);
        }
        else {
-               compute_poly_normal(normal, verts, f->len);
+               calc_poly_normal(normal, verts, f->len);
                area = area_poly_v3(f->len, verts, normal);
        }
 
@@ -187,7 +187,7 @@ float BM_face_area_calc(BMFace *f)
 /**
  * compute the perimeter of an ngon
  */
-float BM_face_perimeter_calc(BMFace *f)
+float BM_face_calc_perimeter(BMFace *f)
 {
        BMLoop *l_iter, *l_first;
        float perimeter = 0.0f;
@@ -203,7 +203,7 @@ float BM_face_perimeter_calc(BMFace *f)
 /**
  * computes center of face in 3d.  uses center of bounding box.
  */
-void BM_face_center_bounds_calc(BMFace *f, float r_cent[3])
+void BM_face_calc_center_bounds(BMFace *f, float r_cent[3])
 {
        BMLoop *l_iter;
        BMLoop *l_first;
@@ -222,7 +222,7 @@ void BM_face_center_bounds_calc(BMFace *f, float r_cent[3])
 /**
  * computes the center of a face, using the mean average
  */
-void BM_face_center_mean_calc(BMFace *f, float r_cent[3])
+void BM_face_calc_center_mean(BMFace *f, float r_cent[3])
 {
        BMLoop *l_iter;
        BMLoop *l_first;
@@ -245,7 +245,7 @@ void BM_face_center_mean_calc(BMFace *f, float r_cent[3])
  * a plane defined by the average
  * of its edges cross products
  */
-void compute_poly_plane(float (*verts)[3], const int nverts)
+void calc_poly_plane(float (*verts)[3], const int nverts)
 {
        
        float avgc[3], norm[3], mag, avgn[3];
@@ -432,7 +432,7 @@ void BM_face_normal_update(BMFace *f)
                }
                default:
                {
-                       bm_face_compute_poly_normal(f);
+                       bm_face_calc_poly_normal(f);
                        break;
                }
        }
@@ -474,7 +474,7 @@ void BM_face_normal_update_vcos(BMesh *bm, BMFace *f, float no[3],
                }
                default:
                {
-                       bm_face_compute_poly_normal_vertex_cos(f, no, vertexCos);
+                       bm_face_calc_poly_normal_vertex_cos(f, no, vertexCos);
                        break;
                }
        }
@@ -610,9 +610,9 @@ int BM_face_point_inside_test(BMFace *f, const float co[3])
        return crosses % 2 != 0;
 }
 
-static int goodline(float const (*projectverts)[3], BMFace *f,
-                    int v1i, int v2i, int v3i,
-                    int UNUSED(nvert))
+static int bm_face_goodline(float const (*projectverts)[3], BMFace *f,
+                            int v1i, int v2i, int v3i,
+                            int UNUSED(nvert))
 {
        BMLoop *l_iter;
        BMLoop *l_first;
@@ -697,9 +697,9 @@ static BMLoop *find_ear(BMFace *f, float (*verts)[3], const int nvert, const int
                        if (BM_edge_exists(v1, v3)) {
                                isear = FALSE;
                        }
-                       else if (!goodline((float const (*)[3])verts, f,
-                                          BM_elem_index_get(v1), BM_elem_index_get(v2), BM_elem_index_get(v3),
-                                          nvert))
+                       else if (!bm_face_goodline((float const (*)[3])verts, f,
+                                                  BM_elem_index_get(v1), BM_elem_index_get(v2), BM_elem_index_get(v3),
+                                                  nvert))
                        {
                                isear = FALSE;
                        }
@@ -765,12 +765,12 @@ void BM_face_triangulate(BMesh *bm, BMFace *f, float (*projectverts)[3],
 
        ///bmesh_face_normal_update(bm, f, f->no, projectverts);
 
-       compute_poly_normal(f->no, projectverts, f->len);
+       calc_poly_normal(f->no, projectverts, f->len);
        poly_rotate_plane(f->no, projectverts, i);
 
        nvert = f->len;
 
-       //compute_poly_plane(projectverts, i);
+       //calc_poly_plane(projectverts, i);
        for (i = 0; i < nvert; i++) {
                projectverts[i][2] = 0.0f;
        }
@@ -879,7 +879,7 @@ void BM_face_legal_splits(BMesh *bm, BMFace *f, BMLoop *(*loops)[2], int len)
                a++;
        }
        
-       compute_poly_normal(no, projverts, f->len);
+       calc_poly_normal(no, projverts, f->len);
        poly_rotate_plane(no, projverts, f->len);
        poly_rotate_plane(no, edgeverts, len * 2);
 
index 117a47d34f20453774815ba476cce7a3b56199c5..e5777d3611b760e5d6103f38ccafd7a3d3f12e38 100644 (file)
  *  \ingroup bmesh
  */
 
-float BM_face_area_calc(BMFace *f);
-float BM_face_perimeter_calc(BMFace *f);
-void  BM_face_center_bounds_calc(BMFace *f, float center[3]);
-void  BM_face_center_mean_calc(BMFace *f, float center[3]);
+float BM_face_calc_area(BMFace *f);
+float BM_face_calc_perimeter(BMFace *f);
+void  BM_face_calc_center_bounds(BMFace *f, float center[3]);
+void  BM_face_calc_center_mean(BMFace *f, float center[3]);
 
 void  BM_face_normal_update(BMFace *f);
 void  BM_face_normal_update_vcos(BMesh *bm, BMFace *f, float no[3],
index f963425e1bd4b7baaa9ae1c31e5edc9bfe190bd6..6297e20d9d2e6c486ec3c87994e588620310e371 100644 (file)
@@ -65,7 +65,7 @@ int bmesh_disk_count(BMVert *v);
 #define BM_ELEM_API_FLAG_DISABLE(element, f) ((element)->oflags[0].pflag &= ~(f))
 #define BM_ELEM_API_FLAG_TEST(element, f)    ((element)->oflags[0].pflag &   (f))
 
-void compute_poly_plane(float (*verts)[3], const int nverts);
+void calc_poly_plane(float (*verts)[3], const int nverts);
 void poly_rotate_plane(const float normal[3], float (*verts)[3], const int nverts);
 
 /* include the rest of our private declarations */
index 37935f3352157e055ea4515fe65b61477f26dfde..3543fd952bb954a1b035633ba8ea520c0792a569 100644 (file)
 
 #define BM_OVERLAP (1 << 13)
 
-/**
- * Return the amount of element of type 'type' in a given bmesh.
- */
-int BM_mesh_elem_count(BMesh *bm, const char htype)
-{
-       if (htype == BM_VERT) return bm->totvert;
-       else if (htype == BM_EDGE) return bm->totedge;
-       else if (htype == BM_FACE) return bm->totface;
-
-       return 0;
-}
-
 /**
  * Returns whether or not a given vertex is
  * is part of a given edge.
@@ -364,7 +352,7 @@ BMEdge *BM_vert_other_disk_edge(BMVert *v, BMEdge *e_first)
 /**
  * Returms edge length
  */
-float BM_edge_length_calc(BMEdge *e)
+float BM_edge_calc_length(BMEdge *e)
 {
        return len_v3v3(e->v1->co, e->v2->co);
 }
@@ -779,7 +767,7 @@ void BM_edge_ordered_verts(BMEdge *edge, BMVert **r_v1, BMVert **r_v2)
  *
  * \return angle in radians
  */
-float BM_loop_face_angle(BMLoop *l)
+float BM_loop_calc_face_angle(BMLoop *l)
 {
        return angle_v3v3v3(l->prev->v->co,
                            l->v->co,
@@ -787,7 +775,7 @@ float BM_loop_face_angle(BMLoop *l)
 }
 
 /**
- * \brief BM_loop_face_normal
+ * \brief BM_loop_calc_face_normal
  *
  * Calculate the normal at this loop corner or fallback to the face normal on straignt lines.
  *
@@ -795,7 +783,7 @@ float BM_loop_face_angle(BMLoop *l)
  * \param l The loop to calculate the normal at
  * \param r_normal Resulting normal
  */
-void BM_loop_face_normal(BMLoop *l, float r_normal[3])
+void BM_loop_calc_face_normal(BMLoop *l, float r_normal[3])
 {
        if (normal_tri_v3(r_normal,
                          l->prev->v->co,
@@ -810,7 +798,7 @@ void BM_loop_face_normal(BMLoop *l, float r_normal[3])
 }
 
 /**
- * \brief BM_loop_face_tangent
+ * \brief BM_loop_calc_face_tangent
  *
  * Calculate the tangent at this loop corner or fallback to the face normal on straignt lines.
  * This vector always points inward into the face.
@@ -819,7 +807,7 @@ void BM_loop_face_normal(BMLoop *l, float r_normal[3])
  * \param l The loop to calculate the tangent at
  * \param r_tangent Resulting tangent
  */
-void BM_loop_face_tangent(BMLoop *l, float r_tangent[3])
+void BM_loop_calc_face_tangent(BMLoop *l, float r_tangent[3])
 {
        float v_prev[3];
        float v_next[3];
@@ -853,7 +841,7 @@ void BM_loop_face_tangent(BMLoop *l, float r_tangent[3])
  *
  * \return angle in radians
  */
-float BM_edge_face_angle(BMEdge *e)
+float BM_edge_calc_face_angle(BMEdge *e)
 {
        if (BM_edge_is_manifold(e)) {
                BMLoop *l1 = e->l;
@@ -871,13 +859,13 @@ float BM_edge_face_angle(BMEdge *e)
  * Calculate the tangent at this loop corner or fallback to the face normal on straignt lines.
  * This vector always points inward into the face.
  *
- * \brief BM_edge_face_tangent
+ * \brief BM_edge_calc_face_tangent
  * \param e
  * \param e_loop The loop to calculate the tangent at,
  * used to get the face and winding direction.
  */
 
-void BM_edge_face_tangent(BMEdge *e, BMLoop *e_loop, float r_tangent[3])
+void BM_edge_calc_face_tangent(BMEdge *e, BMLoop *e_loop, float r_tangent[3])
 {
        float tvec[3];
        BMVert *v1, *v2;
@@ -897,7 +885,7 @@ void BM_edge_face_tangent(BMEdge *e, BMLoop *e_loop, float r_tangent[3])
  *
  * \returns the angle in radians
  */
-float BM_vert_edge_angle(BMVert *v)
+float BM_vert_calc_edge_angle(BMVert *v)
 {
        BMEdge *e1, *e2;
 
@@ -905,9 +893,9 @@ float BM_vert_edge_angle(BMVert *v)
         * get the edges and count them both at once */
 
        if ((e1 = v->e) &&
-               (e2 =  bmesh_disk_edge_next(e1, v)) &&
+           (e2 =  bmesh_disk_edge_next(e1, v)) &&
            /* make sure we come full circle and only have 2 connected edges */
-               (e1 == bmesh_disk_edge_next(e2, v)))
+           (e1 == bmesh_disk_edge_next(e2, v)))
        {
                BMVert *v1 = BM_edge_other_vert(e1, v);
                BMVert *v2 = BM_edge_other_vert(e2, v);
@@ -923,7 +911,7 @@ float BM_vert_edge_angle(BMVert *v)
  * \note this isn't optimal to run on an array of verts,
  * see 'solidify_add_thickness' for a function which runs on an array.
  */
-float BM_vert_shell_factor(BMVert *v)
+float BM_vert_calc_shell_factor(BMVert *v)
 {
        BMIter iter;
        BMLoop *l;
@@ -931,7 +919,7 @@ float BM_vert_shell_factor(BMVert *v)
        float accum_angle = 0.0f;
 
        BM_ITER_ELEM (l, &iter, v, BM_LOOPS_OF_VERT) {
-               const float face_angle = BM_loop_face_angle(l);
+               const float face_angle = BM_loop_calc_face_angle(l);
                accum_shell += shell_angle_to_dist(angle_normalized_v3v3(v->no, l->f->no)) * face_angle;
                accum_angle += face_angle;
        }
index 5178311eea42868fe65feb3c8a2da4dba18d1da3..aefeb80c4f39d316dfd9c5981ace06a23b534833 100644 (file)
@@ -27,8 +27,6 @@
  *  \ingroup bmesh
  */
 
-int     BM_mesh_elem_count(BMesh *bm, const char htype);
-
 int     BM_vert_in_face(BMFace *f, BMVert *v);
 int     BM_verts_in_face(BMesh *bm, BMFace *f, BMVert **varr, int len);
 
@@ -37,7 +35,7 @@ int     BM_edge_in_face(BMFace *f, BMEdge *e);
 int     BM_vert_in_edge(BMEdge *e, BMVert *v);
 int     BM_verts_in_edge(BMVert *v1, BMVert *v2, BMEdge *e);
 
-float   BM_edge_length_calc(BMEdge *e);
+float   BM_edge_calc_length(BMEdge *e);
 int     BM_edge_face_pair(BMEdge *e, BMFace **r_fa, BMFace **r_fb);
 int     BM_edge_loop_pair(BMEdge *e, BMLoop **r_la, BMLoop **r_lb);
 BMVert *BM_edge_other_vert(BMEdge *e, BMVert *v);
@@ -58,15 +56,15 @@ int     BM_vert_is_manifold(BMVert *v);
 int     BM_edge_is_manifold(BMEdge *e);
 int     BM_edge_is_boundary(BMEdge *e);
 
-float   BM_loop_face_angle(BMLoop *l);
-void    BM_loop_face_normal(BMLoop *l, float r_normal[3]);
-void    BM_loop_face_tangent(BMLoop *l, float r_tangent[3]);
+float   BM_loop_calc_face_angle(BMLoop *l);
+void    BM_loop_calc_face_normal(BMLoop *l, float r_normal[3]);
+void    BM_loop_calc_face_tangent(BMLoop *l, float r_tangent[3]);
 
-float   BM_edge_face_angle(BMEdge *e);
-void    BM_edge_face_tangent(BMEdge *e, BMLoop *e_loop, float r_tangent[3]);
+float   BM_edge_calc_face_angle(BMEdge *e);
+void    BM_edge_calc_face_tangent(BMEdge *e, BMLoop *e_loop, float r_tangent[3]);
 
-float   BM_vert_edge_angle(BMVert *v);
-float   BM_vert_shell_factor(BMVert *v);
+float   BM_vert_calc_edge_angle(BMVert *v);
+float   BM_vert_calc_shell_factor(BMVert *v);
 
 BMEdge *BM_edge_exists(BMVert *v1, BMVert *v2);
 
index fe9e40aad440c03a6798e53d9a690d1fd09bdaeb..8e7723fefdddc405e2a654110360d16491ec3135 100644 (file)
@@ -486,10 +486,10 @@ void dummy_exec(BMesh *bm, BMOperator *op)
  * convert angles [0-PI/2] -> [0-1], multiply together, then convert back to radians. */
 float bm_vert_edge_face_angle(BMVert *v)
 {
-       const float angle = BM_vert_edge_angle(v);
+       const float angle = BM_vert_calc_edge_angle(v);
        /* note: could be either edge, it doesn't matter */
        if (v->e && BM_edge_is_manifold(v->e)) {
-               return ((angle * ANGLE_TO_UNIT) * (BM_edge_face_angle(v->e) * ANGLE_TO_UNIT)) * UNIT_TO_ANGLE;
+               return ((angle * ANGLE_TO_UNIT) * (BM_edge_calc_face_angle(v->e) * ANGLE_TO_UNIT)) * UNIT_TO_ANGLE;
        }
        else {
                return angle;
@@ -528,7 +528,7 @@ void bmo_dissolve_limit_exec(BMesh *bm, BMOperator *op)
        /* go through and split edge */
        for (i = 0, tot_found = 0; i < einput->len; i++) {
                BMEdge *e = ((BMEdge **)einput->data.p)[i];
-               const float angle = BM_edge_face_angle(e);
+               const float angle = BM_edge_calc_face_angle(e);
 
                if (angle < angle_limit) {
                        tot_found++;
@@ -546,7 +546,7 @@ void bmo_dissolve_limit_exec(BMesh *bm, BMOperator *op)
                        if (/* may have become non-manifold */
                            BM_edge_is_manifold(e) &&
                            /* check twice because cumulative effect could dissolve over angle limit */
-                           (BM_edge_face_angle(e) < angle_limit))
+                           (BM_edge_calc_face_angle(e) < angle_limit))
                        {
                                BMFace *nf = BM_faces_join_pair(bm, e->l->f,
                                                                e->l->radial_next->f,
index 1e131fa4b7bac5fffd65a978bd370b976e6fef96..6e3024c0fa113c2014c87ba3d94793eaf62ec267 100644 (file)
@@ -90,7 +90,7 @@ float bm_vert_avg_tag_dist(BMVert *v)
        BM_ITER_ELEM_INDEX (e, &iter, v, BM_EDGES_OF_VERT, tot) {
                BMVert *v_other = BM_edge_other_vert(e, v);
                if (BM_elem_flag_test(v_other, BM_ELEM_TAG)) {
-                       length += BM_edge_length_calc(e);
+                       length += BM_edge_calc_length(e);
                }
        }
 
@@ -173,7 +173,7 @@ void bmo_inset_exec(BMesh *bm, BMOperator *op)
                i = BM_elem_index_get(e);
                if (i != -1) {
                        /* calc edge-split info */
-                       es->length = BM_edge_length_calc(e);
+                       es->length = BM_edge_calc_length(e);
                        es->e_old = e;
                        es++;
                        /* initialize no and e_new after */
@@ -194,7 +194,7 @@ void bmo_inset_exec(BMesh *bm, BMOperator *op)
 
                /* calc edge-split info */
                es->e_new = es->l->e;
-               BM_edge_face_tangent(es->e_new, es->l, es->no);
+               BM_edge_calc_face_tangent(es->e_new, es->l, es->no);
 
                if (es->e_new == es->e_old) { /* happens on boundary edges */
                        /* take care here, we're creating this double edge which _must_ have its verts replaced later on */
@@ -516,7 +516,7 @@ void bmo_inset_exec(BMesh *bm, BMOperator *op)
                }
 
                /* do in 2 passes so moving the verts doesn't feed back into face angle checks
-                * which BM_vert_shell_factor uses. */
+                * which BM_vert_calc_shell_factor uses. */
 
                /* over allocate */
                varr_co = MEM_callocN(sizeof(*varr_co) * bm->totvert, __func__);
@@ -525,7 +525,7 @@ void bmo_inset_exec(BMesh *bm, BMOperator *op)
                        if (BM_elem_flag_test(v, BM_ELEM_TAG)) {
                                const float fac = (depth *
                                                                   (use_relative_offset ? bm_vert_avg_tag_dist(v) : 1.0f) *
-                                                                  (use_even_boundry    ? BM_vert_shell_factor(v) : 1.0f));
+                                                                  (use_even_boundry    ? BM_vert_calc_shell_factor(v) : 1.0f));
                                madd_v3_v3v3fl(varr_co[i], v->co, v->no, fac);
                        }
                }
index 818eedffc001a5942fff93a592ba87d6a95b94ef..801fa2012cf774e6ca679f5946a967cb71363efa 100644 (file)
@@ -322,7 +322,7 @@ void bmo_righthandfaces_exec(BMesh *bm, BMOperator *op)
 
                if (!startf) startf = f;
 
-               BM_face_center_bounds_calc(f, cent);
+               BM_face_calc_center_bounds(f, cent);
 
                if ((maxx_test = dot_v3v3(cent, cent)) > maxx) {
                        maxx = maxx_test;
@@ -332,7 +332,7 @@ void bmo_righthandfaces_exec(BMesh *bm, BMOperator *op)
 
        if (!startf) return;
 
-       BM_face_center_bounds_calc(startf, cent);
+       BM_face_calc_center_bounds(startf, cent);
 
        /* make sure the starting face has the correct winding */
        if (dot_v3v3(cent, startf->no) < 0.0f) {
@@ -473,7 +473,7 @@ static float ngon_fake_area(BMFace *f)
        float   v[3], sv[3], c[3];
        float   area = 0.0f;
 
-       BM_face_center_mean_calc(f, c);
+       BM_face_calc_center_mean(f, c);
 
        BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
                if (num_verts == 0) {
@@ -563,12 +563,12 @@ void bmo_similarfaces_exec(BMesh *bm, BMOperator *op)
                        switch (type) {
                                case SIMFACE_PERIMETER:
                                        /* set the perimeter */
-                                       f_ext[i].perim = BM_face_perimeter_calc(f_ext[i].f);
+                                       f_ext[i].perim = BM_face_calc_perimeter(f_ext[i].f);
                                        break;
 
                                case SIMFACE_COPLANAR:
                                        /* compute the center of the polygon */
-                                       BM_face_center_mean_calc(f_ext[i].f, f_ext[i].c);
+                                       BM_face_calc_center_mean(f_ext[i].f, f_ext[i].c);
 
                                        /* normalize the polygon normal */
                                        copy_v3_v3(t_no, f_ext[i].f->no);
@@ -740,7 +740,7 @@ void bmo_similaredges_exec(BMesh *bm, BMOperator *op)
                                case SIMEDGE_FACE_ANGLE:
                                        e_ext[i].faces = BM_edge_face_count(e_ext[i].e);
                                        if (e_ext[i].faces == 2)
-                                               e_ext[i].angle = BM_edge_face_angle(e_ext[i].e);
+                                               e_ext[i].angle = BM_edge_calc_face_angle(e_ext[i].e);
                                        break;
                        }
                }
index 0d177f5ab18474f879637fecd54806b5cd32d206..925bd48026a2ac613da078f03158db5a1de83afe 100644 (file)
@@ -789,15 +789,15 @@ static float UNUSED_FUNCTION(BME_bevel_get_angle_vert)(BMVert *v)
 
 
        BM_ITER_ELEM (l, &iter, v, BM_LOOPS_OF_VERT) {
-               BM_loop_face_normal(l, n_tmp);
-               madd_v3_v3fl(n, n_tmp, BM_loop_face_angle(l));
+               BM_loop_calc_face_normal(l, n_tmp);
+               madd_v3_v3fl(n, n_tmp, BM_loop_calc_face_angle(l));
        }
        normalize_v3(n);
 
        BM_ITER_ELEM (l, &iter, v, BM_LOOPS_OF_VERT) {
                /* could cache from before */
-               BM_loop_face_normal(l, n_tmp);
-               angle_diff += angle_normalized_v3v3(n, n_tmp) * (BM_loop_face_angle(l) * (float)(M_PI * 0.5));
+               BM_loop_calc_face_normal(l, n_tmp);
+               angle_diff += angle_normalized_v3v3(n, n_tmp) * (BM_loop_calc_face_angle(l) * (float)(M_PI * 0.5));
        }
 
        return angle_diff;
index fbbe376a18f3f7dea81091bdbfecdf3bb6e5147f..42857bd72706338b9cfafbe3481e77c4d2480a2c 100644 (file)
@@ -454,10 +454,10 @@ static int edbm_rip_invoke__vert(bContext *C, wmOperator *op, wmEvent *event)
                                BM_ITER_ELEM (l, &iter, vout[i], BM_LOOPS_OF_VERT) {
                                        if (!BM_elem_flag_test(l->f, BM_ELEM_HIDDEN)) {
                                                float l_mid_co[3];
-                                               BM_loop_face_tangent(l, l_mid_co);
+                                               BM_loop_calc_face_tangent(l, l_mid_co);
 
                                                /* scale to average of surrounding edge size, only needs to be approx */
-                                               mul_v3_fl(l_mid_co, (BM_edge_length_calc(l->e) + BM_edge_length_calc(l->prev->e)) / 2.0f);
+                                               mul_v3_fl(l_mid_co, (BM_edge_calc_length(l->e) + BM_edge_calc_length(l->prev->e)) / 2.0f);
                                                add_v3_v3(l_mid_co, v->co);
 
                                                d = edbm_rip_rip_edgedist(ar, projectMat, v->co, l_mid_co, fmval);
index c61724920257141133925e18e0e9ec1bacce8e99..effaa405218d29b8073f138e722f30b8cea1c8a2 100644 (file)
@@ -2845,7 +2845,7 @@ static void draw_em_measure_stats(View3D *v3d, Object *ob, BMEditMesh *em, UnitS
        }
 
        if (me->drawflag & ME_DRAWEXTRA_FACEAREA) {
-               /* would be nice to use BM_face_area_calc, but that is for 2d faces
+               /* would be nice to use BM_face_calc_area, but that is for 2d faces
                 * so instead add up tessellation triangle areas */
                BMFace *f;
                int n;
@@ -2910,7 +2910,7 @@ static void draw_em_measure_stats(View3D *v3d, Object *ob, BMEditMesh *em, UnitS
                        BMIter liter;
                        BMLoop *loop;
 
-                       BM_face_center_bounds_calc(efa, vmid);
+                       BM_face_calc_center_bounds(efa, vmid);
 
                        for (loop = BM_iter_new(&liter, em->bm, BM_LOOPS_OF_FACE, efa);
                             loop; loop = BM_iter_step(&liter))
@@ -2984,7 +2984,7 @@ static void draw_em_indices(BMEditMesh *em)
                UI_GetThemeColor3ubv(TH_DRAWEXTRA_FACEAREA, col);
                BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
                        if (BM_elem_flag_test(f, BM_ELEM_SELECT)) {
-                               BM_face_center_mean_calc(f, pos);
+                               BM_face_calc_center_mean(f, pos);
                                sprintf(numstr, "%d", i);
                                view3d_cached_text_draw_add(pos, numstr, 0, txt_flag, col);
                        }
index fecd32c06a00cb9643a8d4808f9421975e05eb25..57540b58f61d8cc515afabd106a1735a194924b5 100644 (file)
@@ -1961,7 +1961,7 @@ static void editmesh_set_connectivity_distance(BMEditMesh *em, float mtx[][3], f
 
        BM_ITER_ELEM (efa, &iter, eve, BM_FACES_OF_VERT) {
                if (BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
-                       BM_face_center_mean_calc(efa, cent_r);
+                       BM_face_calc_center_mean(efa, cent_r);
                        break;
                }
        }
index f40e344deb75bad68d9ea647800268889c67c416..9084e5770ed21e23d8b62abb2c8ab05f170fd653 100644 (file)
@@ -200,7 +200,7 @@ static void draw_uvs_stretch(SpaceImage *sima, Scene *scene, BMEditMesh *em, MTe
 
                                poly_copy_aspect(tf_uvorig, tf_uv, aspx, aspy, efa->len);
 
-                               totarea += BM_face_area_calc(efa);
+                               totarea += BM_face_calc_area(efa);
                                //totuvarea += tf_area(tf, efa->v4!=0);
                                totuvarea += poly_uv_area(tf_uv, efa->len);
                                
@@ -232,7 +232,7 @@ static void draw_uvs_stretch(SpaceImage *sima, Scene *scene, BMEditMesh *em, MTe
                        else {
                                BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
                                        if (BM_elem_flag_test(efa, BM_ELEM_TAG)) {
-                                               area = BM_face_area_calc(efa) / totarea;
+                                               area = BM_face_calc_area(efa) / totarea;
 
                                                BLI_array_empty(tf_uv);
                                                BLI_array_empty(tf_uvorig);
index ee91b19a5a469495999aef970991be865b15006c..b75243c5feb6e0402ca8bd73a38726889c934c55 100644 (file)
@@ -99,6 +99,7 @@ PyDoc_STRVAR(bpy_bm_elem_select_doc,  "Selected state of this element.\n\n:type:
 PyDoc_STRVAR(bpy_bm_elem_hide_doc,    "Hidden state of this element.\n\n:type: boolean");
 PyDoc_STRVAR(bpy_bm_elem_tag_doc,     "Generic attribute scripts can use for own logic\n\n:type: boolean");
 PyDoc_STRVAR(bpy_bm_elem_smooth_doc,  "Smooth state of this element.\n\n:type: boolean");
+PyDoc_STRVAR(bpy_bm_elem_seam_doc,    "Seam for UV unwrapping.\n\n:type: boolean");
 
 
 static PyObject *bpy_bm_elem_hflag_get(BPy_BMElem *self, void *flag)
@@ -601,7 +602,7 @@ static PyGetSetDef bpy_bmedge_getseters[] = {
     {(char *)"index",  (getter)bpy_bm_elem_index_get, (setter)bpy_bm_elem_index_set, (char *)bpy_bm_elem_index_doc,  NULL},
 
     {(char *)"smooth", (getter)bpy_bm_elem_hflag_get, (setter)bpy_bm_elem_hflag_set, (char *)bpy_bm_elem_smooth_doc, (void *)BM_ELEM_SMOOTH},
-    {(char *)"seam",   (getter)bpy_bm_elem_hflag_get, (setter)bpy_bm_elem_hflag_set, (char *)bpy_bm_elem_smooth_doc, (void *)BM_ELEM_SEAM},
+    {(char *)"seam",   (getter)bpy_bm_elem_hflag_get, (setter)bpy_bm_elem_hflag_set, (char *)bpy_bm_elem_seam_doc, (void *)BM_ELEM_SEAM},
 
     /* connectivity data */
     {(char *)"verts", (getter)bpy_bmelemseq_elem_get, (setter)NULL, (char *)bpy_bmedge_verts_doc, (void *)BM_VERTS_OF_EDGE},
@@ -1197,7 +1198,7 @@ PyDoc_STRVAR(bpy_bmvert_calc_edge_angle_doc,
 static PyObject *bpy_bmvert_calc_edge_angle(BPy_BMVert *self)
 {
        BPY_BM_CHECK_OBJ(self);
-       return PyFloat_FromDouble(BM_vert_edge_angle(self->v));
+       return PyFloat_FromDouble(BM_vert_calc_edge_angle(self->v));
 }
 
 PyDoc_STRVAR(bpy_bmvert_calc_shell_factor_doc,
@@ -1213,7 +1214,7 @@ PyDoc_STRVAR(bpy_bmvert_calc_shell_factor_doc,
 static PyObject *bpy_bmvert_calc_shell_factor(BPy_BMVert *self)
 {
        BPY_BM_CHECK_OBJ(self);
-       return PyFloat_FromDouble(BM_vert_shell_factor(self->v));
+       return PyFloat_FromDouble(BM_vert_calc_shell_factor(self->v));
 }
 
 PyDoc_STRVAR(bpy_bmvert_normal_update_doc,
@@ -1255,7 +1256,7 @@ PyDoc_STRVAR(bpy_bmedge_calc_face_angle_doc,
 static PyObject *bpy_bmedge_calc_face_angle(BPy_BMEdge *self)
 {
        BPY_BM_CHECK_OBJ(self);
-       return PyFloat_FromDouble(BM_edge_face_angle(self->e));
+       return PyFloat_FromDouble(BM_edge_calc_face_angle(self->e));
 }
 
 PyDoc_STRVAR(bpy_bmedge_calc_tangent_doc,
@@ -1283,7 +1284,7 @@ static PyObject *bpy_bmedge_calc_tangent(BPy_BMEdge *self, PyObject *args)
                float vec[3];
                BPY_BM_CHECK_OBJ(py_loop);
                /* no need to check if they are from the same mesh or even connected */
-               BM_edge_face_tangent(self->e, py_loop->l, vec);
+               BM_edge_calc_face_tangent(self->e, py_loop->l, vec);
                return Vector_CreatePyObject(vec, 3, Py_NEW, NULL);
        }
 }
@@ -1441,7 +1442,7 @@ PyDoc_STRVAR(bpy_bmface_calc_area_doc,
 static PyObject *bpy_bmface_calc_area(BPy_BMFace *self)
 {
        BPY_BM_CHECK_OBJ(self);
-       return PyFloat_FromDouble(BM_face_area_calc(self->f));
+       return PyFloat_FromDouble(BM_face_calc_area(self->f));
 }
 
 
@@ -1456,7 +1457,7 @@ PyDoc_STRVAR(bpy_bmface_calc_perimeter_doc,
 static PyObject *bpy_bmface_calc_perimeter(BPy_BMFace *self)
 {
        BPY_BM_CHECK_OBJ(self);
-       return PyFloat_FromDouble(BM_face_perimeter_calc(self->f));
+       return PyFloat_FromDouble(BM_face_calc_perimeter(self->f));
 }
 
 
@@ -1473,7 +1474,7 @@ static PyObject *bpy_bmface_calc_center_mean(BPy_BMFace *self)
        float cent[3];
 
        BPY_BM_CHECK_OBJ(self);
-       BM_face_center_mean_calc(self->f, cent);
+       BM_face_calc_center_mean(self->f, cent);
        return Vector_CreatePyObject(cent, 3, Py_NEW, NULL);
 }
 
@@ -1491,7 +1492,7 @@ static PyObject *bpy_bmface_calc_center_bounds(BPy_BMFace *self)
        float cent[3];
 
        BPY_BM_CHECK_OBJ(self);
-       BM_face_center_bounds_calc(self->f, cent);
+       BM_face_calc_center_bounds(self->f, cent);
        return Vector_CreatePyObject(cent, 3, Py_NEW, NULL);
 }
 
@@ -1570,7 +1571,7 @@ PyDoc_STRVAR(bpy_bmloop_calc_angle_doc,
 static PyObject *bpy_bmloop_calc_angle(BPy_BMLoop *self)
 {
        BPY_BM_CHECK_OBJ(self);
-       return PyFloat_FromDouble(BM_loop_face_angle(self->l));
+       return PyFloat_FromDouble(BM_loop_calc_face_angle(self->l));
 }
 
 PyDoc_STRVAR(bpy_bmloop_calc_normal_doc,
@@ -1586,7 +1587,7 @@ static PyObject *bpy_bmloop_calc_normal(BPy_BMLoop *self)
 {
        float vec[3];
        BPY_BM_CHECK_OBJ(self);
-       BM_loop_face_normal(self->l, vec);
+       BM_loop_calc_face_normal(self->l, vec);
        return Vector_CreatePyObject(vec, 3, Py_NEW, NULL);
 }
 
@@ -1603,7 +1604,7 @@ static PyObject *bpy_bmloop_calc_tangent(BPy_BMLoop *self)
 {
        float vec[3];
        BPY_BM_CHECK_OBJ(self);
-       BM_loop_face_tangent(self->l, vec);
+       BM_loop_calc_face_tangent(self->l, vec);
        return Vector_CreatePyObject(vec, 3, Py_NEW, NULL);
 }