code cleanup: rename BKE_tessmesh -> BKE_editmesh, rename EditDerivedBMesh.tc ->...
[blender-staging.git] / source / blender / bmesh / tools / BME_bevel.c
index 0f3cb7c90f72f839950d52b03b09e9659362fb66..ba553e2f7637ced66ecbb7a40fcf7591ee239160 100644 (file)
@@ -38,8 +38,7 @@
 #include "BLI_ghash.h"
 #include "BLI_memarena.h"
 
-#include "BKE_utildefines.h"
-#include "BKE_tessmesh.h"
+#include "BKE_editmesh.h"
 #include "BKE_bmesh.h"
 
 #include "bmesh.h"
 
 /* ------- Bevel code starts here -------- */
 
-BME_TransData_Head *BME_init_transdata(int bufsize)
+static BME_TransData_Head *BME_init_transdata(int bufsize)
 {
        BME_TransData_Head *td;
 
        td = MEM_callocN(sizeof(BME_TransData_Head), "BM transdata header");
-       td->gh = BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, "BME_init_transdata gh");
+       td->gh = BLI_ghash_ptr_new("BME_init_transdata gh");
        td->ma = BLI_memarena_new(bufsize, "BME_TransData arena");
        BLI_memarena_use_calloc(td->ma);
 
@@ -86,12 +85,12 @@ void BME_free_transdata(BME_TransData_Head *td)
        MEM_freeN(td);
 }
 
-BME_TransData *BME_assign_transdata(BME_TransData_Head *td, BMesh *bm, BMVert *v,
-                                    float *co, float *org, float *vec, float *loc,
-                                    float factor, float weight, float maxfactor, float *max)
+static BME_TransData *BME_assign_transdata(BME_TransData_Head *td, BMesh *bm, BMVert *v,
+                                           float *co, float *org, float *vec, float *loc,
+                                           float factor, float weight, float maxfactor, float *max)
 {
        BME_TransData *vtd;
-       int is_new = 0;
+       int is_new = false;
 
        if (v == NULL) {
                return NULL;
@@ -101,7 +100,7 @@ BME_TransData *BME_assign_transdata(BME_TransData_Head *td, BMesh *bm, BMVert *v
                vtd = BLI_memarena_alloc(td->ma, sizeof(*vtd));
                BLI_ghash_insert(td->gh, v, vtd);
                td->len++;
-               is_new = 1;
+               is_new = true;
        }
 
        vtd->bm = bm;
@@ -141,7 +140,7 @@ BME_TransData *BME_get_transdata(BME_TransData_Head *td, BMVert *v)
 }
 
 /* a hack (?) to use the transdata memarena to allocate floats for use with the max limits */
-float *BME_new_transdata_float(BME_TransData_Head *td)
+static float *BME_new_transdata_float(BME_TransData_Head *td)
 {
        return BLI_memarena_alloc(td->ma, sizeof(float));
 }
@@ -152,12 +151,12 @@ static void BME_Bevel_Dissolve_Disk(BMesh *bm, BMVert *v)
 {
        BMFace *f;
        BMEdge *e;
-       int done;
+       bool done;
 
        if (v->e) {
-               done = 0;
+               done = false;
                while (!done) {
-                       done = 1;
+                       done = true;
                        e = v->e; /*loop the edge looking for a edge to dissolve*/
                        do {
                                f = NULL;
@@ -165,14 +164,14 @@ static void BME_Bevel_Dissolve_Disk(BMesh *bm, BMVert *v)
                                        f = bmesh_jfke(bm, e->l->f, e->l->radial_next->f, e);
                                }
                                if (f) {
-                                       done = 0;
+                                       done = false;
                                        break;
                                }
                                e = bmesh_disk_edge_next(e, v);
                        } while (e != v->e);
                }
-               BM_vert_collapse_edge(bm, v->e, v, TRUE);
-               // bmesh_jekv(bm, v->e, v, FALSE);
+               BM_vert_collapse_edge(bm, v->e, v, true);
+               // bmesh_jekv(bm, v->e, v, false);
        }
 }
 
@@ -195,7 +194,7 @@ static int BME_bevel_is_split_vert(BMesh *bm, BMLoop *l)
  * the bevel operation as a whole based on the relationship between v1 and v2
  * (won't necessarily be a vec from v1->co to v2->co, though it probably will be);
  * the return value is -1 for failure, 0 if we used vert co's, and 1 if we used transform origins */
-static int BME_bevel_get_vec(float *vec, BMVert *v1, BMVert *v2, BME_TransData_Head *td)
+static int BME_bevel_get_vec(float vec[3], BMVert *v1, BMVert *v2, BME_TransData_Head *td)
 {
        BME_TransData *vtd1, *vtd2;
 
@@ -234,7 +233,8 @@ static int BME_bevel_get_vec(float *vec, BMVert *v1, BMVert *v2, BME_TransData_H
  * vec2 is the direction of projection (pointing away from vec1)
  * up_vec is used for orientation (expected to be normalized)
  * returns the length of the projected vector that lies along vec1 */
-static float BME_bevel_project_vec(float *vec1, float *vec2, float *up_vec, int is_forward, BME_TransData_Head *UNUSED(td))
+static float BME_bevel_project_vec(float *vec1, float *vec2, float *up_vec,
+                                   int is_forward, BME_TransData_Head *UNUSED(td))
 {
        float factor, vec3[3], tmp[3], c1, c2;
 
@@ -264,7 +264,8 @@ static float BME_bevel_project_vec(float *vec1, float *vec2, float *up_vec, int
  * using the vert and the loop passed, get or make the split vert, set its coordinates
  * and transform properties, and set the max limits.
  * Finally, return the split vert. */
-static BMVert *BME_bevel_split_edge(BMesh *bm, BMVert *v, BMVert *v1, BMLoop *l, float *up_vec, float value, BME_TransData_Head *td)
+static BMVert *BME_bevel_split_edge(BMesh *bm, BMVert *v, BMVert *v1, BMLoop *l,
+                                    float *up_vec, float value, BME_TransData_Head *td)
 {
        BME_TransData *vtd, *vtd1, *vtd2;
        BMVert *sv, *v2, *v3, *ov;
@@ -305,7 +306,7 @@ static BMVert *BME_bevel_split_edge(BMesh *bm, BMVert *v, BMVert *v1, BMLoop *l,
                        e1 = e2;
                }
                ov = BM_edge_other_vert(e1, v);
-               sv = BM_edge_split(bm, e1, v, &ne, 0);
+               sv = BM_edge_split(bm, e1, v, &ne, 0.0f);
                //BME_data_interp_from_verts(bm, v, ov, sv, 0.25); /* this is technically wrong.. */
                //BME_data_interp_from_faceverts(bm, v, ov, sv, 0.25);
                //BME_data_interp_from_faceverts(bm, ov, v, sv, 0.25);
@@ -347,7 +348,7 @@ static BMVert *BME_bevel_split_edge(BMesh *bm, BMVert *v, BMVert *v1, BMLoop *l,
                else {
                        is_split_vert = 0;
                        ov = BM_edge_other_vert(l->e, v);
-                       sv = BM_edge_split(bm, l->e, v, &ne, 0);
+                       sv = BM_edge_split(bm, l->e, v, &ne, 0.0f);
                        //BME_data_interp_from_verts(bm, v, ov, sv, 0.25); /* this is technically wrong.. */
                        //BME_data_interp_from_faceverts(bm, v, ov, sv, 0.25);
                        //BME_data_interp_from_faceverts(bm, ov, v, sv, 0.25);
@@ -371,8 +372,8 @@ static BMVert *BME_bevel_split_edge(BMesh *bm, BMVert *v, BMVert *v1, BMLoop *l,
 
        if (vtd1->loc == NULL) {
                /* this is a vert with data only for calculating initial weights */
-               if (vtd1->weight < 0) {
-                       vtd1->weight = 0;
+               if (vtd1->weight < 0.0f) {
+                       vtd1->weight = 0.0f;
                }
                scale = vtd1->weight / vtd1->factor;
                if (!vtd1->max) {
@@ -496,7 +497,8 @@ static BMVert *BME_bevel_wire(BMesh *bm, BMVert *v, float value, int res, int UN
 }
 #endif
 
-static BMLoop *BME_bevel_edge(BMesh *bm, BMLoop *l, float value, int UNUSED(options), float *up_vec, BME_TransData_Head *td)
+static BMLoop *BME_bevel_edge(BMesh *bm, BMLoop *l, float value, int UNUSED(options),
+                              float *up_vec, BME_TransData_Head *td)
 {
        BMVert *v1, *v2, *kv;
        BMLoop *kl = NULL, *nl;
@@ -537,18 +539,18 @@ static BMLoop *BME_bevel_edge(BMesh *bm, BMLoop *l, float value, int UNUSED(opti
                se = l->next->e;
                jf = NULL;
                if (kl->v == kv) {
-                       BM_face_split(bm, kl->f, kl->prev->v, kl->next->v, &nl, kl->prev->e, FALSE);
+                       BM_face_split(bm, kl->f, kl->prev->v, kl->next->v, &nl, kl->prev->e, true);
                        ke = kl->e;
                        /* BMESH-TODO: jfke doesn't handle customdata */
                        jf = bmesh_jfke(bm, kl->prev->radial_next->f, kl->f, kl->prev->e);
-                       BM_vert_collapse_edge(bm, ke, kv, FALSE);
+                       BM_vert_collapse_edge(bm, ke, kv, false);
                }
                else {
-                       BM_face_split(bm, kl->f, kl->next->next->v, kl->v, &nl, kl->next->e, FALSE);
+                       BM_face_split(bm, kl->f, kl->next->next->v, kl->v, &nl, kl->next->e, true);
                        ke = kl->e;
                        /* BMESH-TODO: jfke doesn't handle customdata */
                        jf = bmesh_jfke(bm, kl->next->radial_next->f, kl->f, kl->next->e);
-                       BM_vert_collapse_edge(bm, ke, kv, FALSE);
+                       BM_vert_collapse_edge(bm, ke, kv, false);
                }
                /* find saved loop pointer */
                l = se->l;
@@ -583,18 +585,18 @@ static BMLoop *BME_bevel_edge(BMesh *bm, BMLoop *l, float value, int UNUSED(opti
                se = l->e;
                jf = NULL;
                if (kl->v == kv) {
-                       BM_face_split(bm, kl->f, kl->prev->v, kl->next->v, &nl, kl->prev->e, FALSE);
+                       BM_face_split(bm, kl->f, kl->prev->v, kl->next->v, &nl, kl->prev->e, true);
                        ke = kl->e;
                        /* BMESH-TODO: jfke doesn't handle customdata */
                        jf = bmesh_jfke(bm, kl->prev->radial_next->f, kl->f, kl->prev->e);
-                       BM_vert_collapse_edge(bm, ke, kv, FALSE);
+                       BM_vert_collapse_edge(bm, ke, kv, false);
                }
                else {
-                       BM_face_split(bm, kl->f, kl->next->next->v, kl->v, &nl, kl->next->e, FALSE);
+                       BM_face_split(bm, kl->f, kl->next->next->v, kl->v, &nl, kl->next->e, true);
                        ke = kl->e;
                        /* BMESH-TODO: jfke doesn't handle customdata */
                        jf = bmesh_jfke(bm, kl->next->radial_next->f, kl->f, kl->next->e);
-                       BM_vert_collapse_edge(bm, ke, kv, FALSE);
+                       BM_vert_collapse_edge(bm, ke, kv, false);
                }
                /* find saved loop pointer */
                l = se->l;
@@ -605,7 +607,7 @@ static BMLoop *BME_bevel_edge(BMesh *bm, BMLoop *l, float value, int UNUSED(opti
        }
 
        if (!BMO_elem_flag_test(bm, v1, BME_BEVEL_NONMAN) || !BMO_elem_flag_test(bm, v2, BME_BEVEL_NONMAN)) {
-               BM_face_split(bm, f, v2, v1, &l, e, FALSE);
+               BM_face_split(bm, f, v2, v1, &l, e, true);
                BMO_elem_flag_enable(bm, l->e, BME_BEVEL_BEVEL);
                l = l->radial_next;
        }
@@ -617,7 +619,8 @@ static BMLoop *BME_bevel_edge(BMesh *bm, BMLoop *l, float value, int UNUSED(opti
        return l;
 }
 
-static BMLoop *BME_bevel_vert(BMesh *bm, BMLoop *l, float value, int UNUSED(options), float *up_vec, BME_TransData_Head *td)
+static BMLoop *BME_bevel_vert(BMesh *bm, BMLoop *l, float value, int UNUSED(options),
+                              float up_vec[3], BME_TransData_Head *td)
 {
        BMVert *v1, *v2;
        /* BMFace *f; */ /* UNUSED */
@@ -633,7 +636,7 @@ static BMLoop *BME_bevel_vert(BMesh *bm, BMLoop *l, float value, int UNUSED(opti
        l = l->next->next;
 
        /* "cut off" this corner */
-       /* f = */ BM_face_split(bm, l->f, v2, v1, NULL, l->e, FALSE);
+       /* f = */ BM_face_split(bm, l->f, v2, v1, NULL, l->e, true);
 
        return l;
 }
@@ -686,15 +689,23 @@ static BMFace *BME_bevel_poly(BMesh *bm, BMFace *f, float value, int options, BM
                         BMO_elem_flag_test(bm, l->v, BME_BEVEL_ORIG) &&
                         !BMO_elem_flag_test(bm, l->prev->e, BME_BEVEL_BEVEL))
                {
-                       max = 1.0f;
-                       l = BME_bevel_vert(bm, l, value, options, up_vec, td);
+                       /* avoid making double vertices [#33438] */
+                       BME_TransData *vtd;
+                       vtd = BME_get_transdata(td, l->v);
+                       if (vtd->weight == 0.0f) {
+                               BMO_elem_flag_disable(bm, l->v, BME_BEVEL_BEVEL);
+                       }
+                       else {
+                               max = 1.0f;
+                               l = BME_bevel_vert(bm, l, value, options, up_vec, td);
+                       }
                }
        }
 
        f = l->f;
 
        /* max pass */
-       if (value > 0.5f && max > 0) {
+       if (value > 0.5f && max > 0.0f) {
                max = -1;
                BM_ITER_ELEM (l, &iter, f, BM_LOOPS_OF_FACE) {
                        if (BMO_elem_flag_test(bm, l->e, BME_BEVEL_BEVEL) || BMO_elem_flag_test(bm, l->e, BME_BEVEL_ORIG)) {
@@ -785,28 +796,32 @@ static float BME_bevel_get_angle(BMEdge *e, BMVert *v)
        return dot_v3v3(vec3, vec4);
 }
 
-static float UNUSED_FUNCTION(BME_bevel_get_angle_vert)(BMVert *v)
+static float BME_bevel_get_angle_vert(BMVert *v)
 {
        BMIter iter;
        BMLoop *l;
        float n[3];
        float n_tmp[3];
        float angle_diff = 0.0f;
+       float tot_angle = 0.0f;
 
 
        BM_ITER_ELEM (l, &iter, v, BM_LOOPS_OF_VERT) {
+               const float angle = BM_loop_calc_face_angle(l);
+               tot_angle += angle;
                BM_loop_calc_face_normal(l, n_tmp);
-               madd_v3_v3fl(n, n_tmp, BM_loop_calc_face_angle(l));
+               madd_v3_v3fl(n, n_tmp, angle);
        }
        normalize_v3(n);
 
        BM_ITER_ELEM (l, &iter, v, BM_LOOPS_OF_VERT) {
                /* could cache from before */
                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));
+               angle_diff += angle_normalized_v3v3(n, n_tmp) * BM_loop_calc_face_angle(l);
        }
 
-       return angle_diff;
+       /* return cosf(angle_diff + 0.001f); */ /* compare with dot product */
+       return (angle_diff / tot_angle) * (float)(M_PI / 2.0);
 }
 
 static void BME_bevel_add_vweight(BME_TransData_Head *td, BMesh *bm, BMVert *v, float weight, float factor, int options)
@@ -831,7 +846,7 @@ static void BME_bevel_add_vweight(BME_TransData_Head *td, BMesh *bm, BMVert *v,
                                vtd->weight = weight;
                        }
                }
-               else if (vtd->weight < 0) {
+               else if (vtd->weight < 0.0f) {
                        vtd->factor = factor;
                        vtd->weight = weight;
                }
@@ -851,8 +866,7 @@ static void bevel_init_verts(BMesh *bm, int options, float angle, BME_TransData_
        BMVert *v;
        BMIter iter;
        float weight;
-//     const float threshold = (options & BME_BEVEL_ANGLE) ? cosf(angle + 0.001) : 0.0f;
-       (void)angle;
+       /* const float threshold = (options & BME_BEVEL_ANGLE) ? cosf(angle + 0.001) : 0.0f; */ /* UNUSED */
 
        BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
                weight = 0.0f;
@@ -867,14 +881,12 @@ static void bevel_init_verts(BMesh *bm, int options, float angle, BME_TransData_
                        else if (options & BME_BEVEL_WEIGHT) {
                                weight = BM_elem_float_data_get(&bm->vdata, v, CD_BWEIGHT);
                        }
-#if 0 // not working well
                        else if (options & BME_BEVEL_ANGLE) {
                                /* dont set weight_v1/weight_v2 here, add direct */
-                               if (BME_bevel_get_angle_vert(bm, v) < threshold) {
+                               if (BME_bevel_get_angle_vert(v) > angle) {
                                        weight = 1.0f;
                                }
                        }
-#endif
                        else {
                                weight = 1.0f;
                        }
@@ -893,14 +905,14 @@ static void bevel_init_edges(BMesh *bm, int options, float angle, BME_TransData_
        int count;
        float weight;
        BMIter iter;
-       const float threshold = (options & BME_BEVEL_ANGLE) ? cosf(angle + 0.001) : 0.0f;
+       const float threshold = (options & BME_BEVEL_ANGLE) ? cosf(angle + 0.001f) : 0.0f;
 
        BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
-               weight = 0.0;
+               weight = 0.0f;
                if (!BMO_elem_flag_test(bm, e, BME_BEVEL_NONMAN)) {
                        if (options & BME_BEVEL_SELECT) {
                                if (BM_elem_flag_test(e, BM_ELEM_SELECT)) {
-                                       weight = 1.0;
+                                       weight = 1.0f;
                                }
                        }
                        else if (options & BME_BEVEL_WEIGHT) {
@@ -924,10 +936,10 @@ static void bevel_init_edges(BMesh *bm, int options, float angle, BME_TransData_
                                }
                        }
                        else {
-                               weight = 1.0;
+                               weight = 1.0f;
                        }
 
-                       if (weight > 0.0) {
+                       if (weight > 0.0f) {
                                BMO_elem_flag_enable(bm, e, BME_BEVEL_BEVEL);
                                BME_bevel_add_vweight(td, bm, e->v1, weight, 1.0, options);
                                BME_bevel_add_vweight(td, bm, e->v2, weight, 1.0, options);
@@ -944,7 +956,8 @@ static void bevel_init_edges(BMesh *bm, int options, float angle, BME_TransData_
        }
 }
 
-static BMesh *BME_bevel_initialize(BMesh *bm, int options, int UNUSED(defgrp_index), float angle, BME_TransData_Head *td)
+static BMesh *BME_bevel_initialize(BMesh *bm, int options,
+                                   int UNUSED(defgrp_index), float angle, BME_TransData_Head *td)
 {
        BMVert *v /*, *v2 */;
        BMEdge *e /*, *curedg */;
@@ -952,7 +965,7 @@ static BMesh *BME_bevel_initialize(BMesh *bm, int options, int UNUSED(defgrp_ind
        BMIter iter;
        int /* wire, */ len;
 
-       /* tag non-manifold geometr */
+       /* tag non-manifold geometry */
        BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
                BMO_elem_flag_enable(bm, v, BME_BEVEL_ORIG);
                if (v->e) {
@@ -1023,20 +1036,20 @@ static BMesh *BME_bevel_reinitialize(BMesh *bm)
 #endif
 
 /**
- *                     BME_bevel_mesh
+ * BME_bevel_mesh
  *
- *     Mesh beveling tool:
+ * Mesh beveling tool:
  *
- *     Bevels an entire mesh. It currently uses the flags of
- *     its vertices and edges to track topological changes.
- *  The parameter "value" is the distance to inset (should be negative).
- *  The parameter "options" is not currently used.
+ * Bevels an entire mesh. It currently uses the flags of
+ * its vertices and edges to track topological changes.
+ * The parameter "value" is the distance to inset (should be negative).
+ * The parameter "options" is not currently used.
  *
- *     Returns -
- *  A BMesh pointer to the BM passed as a parameter.
+ * \return A BMesh pointer to the BM passed as a parameter.
  */
 
-static BMesh *BME_bevel_mesh(BMesh *bm, float value, int UNUSED(res), int options, int UNUSED(defgrp_index), BME_TransData_Head *td)
+static BMesh *BME_bevel_mesh(BMesh *bm, float value, int UNUSED(res), int options,
+                             int UNUSED(defgrp_index), BME_TransData_Head *td)
 {
        BMVert *v;
        BMEdge *e, *curedge;
@@ -1056,7 +1069,7 @@ static BMesh *BME_bevel_mesh(BMesh *bm, float value, int UNUSED(res), int option
        /* get rid of beveled edge */
        BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
                if (BMO_elem_flag_test(bm, e, BME_BEVEL_BEVEL) && BMO_elem_flag_test(bm, e, BME_BEVEL_ORIG)) {
-                       BM_faces_join_pair(bm, e->l->f, e->l->radial_next->f, e, TRUE);
+                       BM_faces_join_pair(bm, e->l->f, e->l->radial_next->f, e, true);
                }
        }
 
@@ -1070,9 +1083,9 @@ static BMesh *BME_bevel_mesh(BMesh *bm, float value, int UNUSED(res), int option
                                if (l->v != v) l = l->next;
                                if (l2->v != v) l2 = l2->next;
                                if (l->f->len > 3)
-                                       BM_face_split(bm, l->f, l->next->v, l->prev->v, &l, l->e, FALSE);  /* clip this corner off */
+                                       BM_face_split(bm, l->f, l->next->v, l->prev->v, &l, l->e, true);  /* clip this corner off */
                                if (l2->f->len > 3)
-                                       BM_face_split(bm, l2->f, l2->next->v, l2->prev->v, &l, l2->e, FALSE);  /* clip this corner off */
+                                       BM_face_split(bm, l2->f, l2->next->v, l2->prev->v, &l, l2->e, true);  /* clip this corner off */
                                curedge = bmesh_disk_edge_next(curedge, v);
                        } while (curedge != v->e);
                        BME_Bevel_Dissolve_Disk(bm, v);
@@ -1091,24 +1104,26 @@ static BMesh *BME_bevel_mesh(BMesh *bm, float value, int UNUSED(res), int option
        return bm;
 }
 
-BMesh *BME_bevel(BMEditMesh *em, float value, int res, int options, int defgrp_index, float angle,
-                 BME_TransData_Head **rtd, int do_tessface)
+BMesh *BME_bevel(BMesh *bm, float value, int res, int options, int defgrp_index, float angle,
+                 BME_TransData_Head **rtd)
 {
-       BMesh *bm = em->bm;
        BMVert *v;
        BMIter iter;
 
        BME_TransData_Head *td;
        BME_TransData *vtd;
        int i;
-       double fac = 1, d;
+       double fac = 1.0, d;
 
        td = BME_init_transdata(BLI_MEMARENA_STD_BUFSIZE);
        /* recursion math courtesy of Martin Poirier (theeth) */
        for (i = 0; i < res - 1; i++) {
-               if (i == 0) fac += 1.0f / 3.0f; else fac += 1.0f / (3 * i * 2.0f);
+               if (i == 0) fac += 1.0 / 3.0;
+               else        fac += 1.0 / (3.0 * i * 2.0);
        }
-       d = 1.0f / fac;
+       d = 1.0 / fac;
+
+       BM_mesh_elem_toolflags_ensure(bm);
 
        for (i = 0; i < res || (res == 0 && i == 0); i++) {
                BMO_push(bm, NULL);
@@ -1121,12 +1136,6 @@ BMesh *BME_bevel(BMEditMesh *em, float value, int res, int options, int defgrp_i
                BMO_pop(bm);
        }
 
-       /* possibly needed when running as a tool (which is no longer functional)
-        * but keep as an optioin for now */
-       if (do_tessface) {
-               BMEdit_RecalcTessellation(em);
-       }
-
        /* interactive preview? */
        if (rtd) {
                *rtd = td;
@@ -1142,7 +1151,7 @@ BMesh *BME_bevel(BMEditMesh *em, float value, int res, int options, int defgrp_i
                        else {
                                d = value;
                        }
-                       madd_v3_v3v3fl(v->co, vtd->org, vtd->vec, vtd->factor * d);
+                       madd_v3_v3v3fl(v->co, vtd->org, vtd->vec, vtd->factor * (float)d);
                }
        }