EditMesh: wireframe tool, add offset and vgroup support (not used yet)
authorCampbell Barton <ideasman42@gmail.com>
Sat, 21 Dec 2013 19:54:37 +0000 (06:54 +1100)
committerCampbell Barton <ideasman42@gmail.com>
Sat, 21 Dec 2013 19:54:37 +0000 (06:54 +1100)
source/blender/bmesh/CMakeLists.txt
source/blender/bmesh/intern/bmesh_opdefines.c
source/blender/bmesh/operators/bmo_wireframe.c
source/blender/bmesh/tools/bmesh_wireframe.c [new file with mode: 0644]
source/blender/bmesh/tools/bmesh_wireframe.h [new file with mode: 0644]
source/blender/editors/mesh/editmesh_tools.c

index afb8b07b1a601cdad0f25d433d05d9b08d0c4a7c..cd8d71be1767d9ea6713f654845a129d716ae724 100644 (file)
@@ -136,6 +136,8 @@ set(SRC
        tools/bmesh_path.h
        tools/bmesh_triangulate.c
        tools/bmesh_triangulate.h
+       tools/bmesh_wireframe.c
+       tools/bmesh_wireframe.h
 
        bmesh_class.h
 
index ef43d73d485128c2df2707178951ff906bf2e154..97624ec64bbd21fda84d424badfa283b5421b38a 100644 (file)
@@ -1694,12 +1694,16 @@ static BMOpDefine bmo_wireframe_def = {
        "wireframe",
        /* slots_in */
        {{"faces", BMO_OP_SLOT_ELEMENT_BUF, {BM_FACE}},   /* input faces */
+        {"thickness", BMO_OP_SLOT_FLT},
+        {"offset", BMO_OP_SLOT_FLT},
+        {"use_replace", BMO_OP_SLOT_BOOL},
         {"use_boundary", BMO_OP_SLOT_BOOL},
         {"use_even_offset", BMO_OP_SLOT_BOOL},
         {"use_crease", BMO_OP_SLOT_BOOL},
+        {"crease_weight", BMO_OP_SLOT_FLT},
         {"thickness", BMO_OP_SLOT_FLT},
         {"use_relative_offset", BMO_OP_SLOT_BOOL},
-        {"depth", BMO_OP_SLOT_FLT},
+        {"material_offset", BMO_OP_SLOT_INT},
         {{'\0'}},
        },
        /* slots_out */
index 94b35426e2bb666dc0f134ab411922303fb956bd..83d6e3ad36a0b93e59d8b04544d13b63fc716fc7 100644 (file)
 
 #include "MEM_guardedalloc.h"
 
-#include "BLI_math.h"
+#include "DNA_material_types.h"
 
-#include "BKE_customdata.h"
+#include "BLI_sys_types.h"
+#include "BLI_utildefines.h"
 
 #include "bmesh.h"
 
-#include "intern/bmesh_operators_private.h" /* own include */
-
-static BMLoop *bm_edge_tag_faceloop(BMEdge *e)
-{
-       BMLoop *l, *l_first;
-
-       l = l_first = e->l;
-       do {
-               if (BM_elem_flag_test(l->f, BM_ELEM_TAG)) {
-                       return l;
-               }
-       } while ((l = l->radial_next) != l_first);
-
-       /* in the case this is used, we know this will never happen */
-       return NULL;
-}
-
-static void bm_vert_boundary_tangent(BMVert *v, float r_no[3], float r_no_face[3],
-                                     BMVert **r_va_other, BMVert **r_vb_other)
-{
-       BMIter iter;
-       BMEdge *e_iter;
-
-       BMEdge *e_a = NULL, *e_b = NULL;
-       BMVert *v_a, *v_b;
-
-       BMLoop *l_a, *l_b;
-
-       float no_face[3], no_edge[3];
-       float tvec_a[3], tvec_b[3];
-
-       /* get 2 boundary edges, there should only _be_ 2,
-        * in case there are more - results wont be valid of course */
-       BM_ITER_ELEM (e_iter, &iter, v, BM_EDGES_OF_VERT) {
-               if (BM_elem_flag_test(e_iter, BM_ELEM_TAG)) {
-                       if (e_a == NULL) {
-                               e_a = e_iter;
-                       }
-                       else {
-                               e_b = e_iter;
-                               break;
-                       }
-               }
-       }
-
-       if (e_a && e_b) {
-               /* note, with an incorrectly flushed selection this can crash */
-               l_a = bm_edge_tag_faceloop(e_a);
-               l_b = bm_edge_tag_faceloop(e_b);
-
-               /* average edge face normal */
-               add_v3_v3v3(no_face, l_a->f->no, l_b->f->no);
-
-               /* average edge direction */
-               v_a = BM_edge_other_vert(e_a, v);
-               v_b = BM_edge_other_vert(e_b, v);
-
-               sub_v3_v3v3(tvec_a, v->co, v_a->co);
-               sub_v3_v3v3(tvec_b, v_b->co, v->co);
-               normalize_v3(tvec_a);
-               normalize_v3(tvec_b);
-               add_v3_v3v3(no_edge, tvec_a, tvec_b); /* not unit length but this is ok */
-
-               /* check are we flipped the right way */
-               BM_edge_calc_face_tangent(e_a, l_a, tvec_a);
-               BM_edge_calc_face_tangent(e_b, l_b, tvec_b);
-               add_v3_v3(tvec_a, tvec_b);
-
-               *r_va_other = v_a;
-               *r_vb_other = v_b;
-       }
-       else {
-               /* degenerate case - vertex connects a boundary edged face to other faces,
-                * so we have only one boundary face - only use it for calculations */
-               l_a = bm_edge_tag_faceloop(e_a);
-
-               copy_v3_v3(no_face, l_a->f->no);
-
-               /* edge direction */
-               v_a = BM_edge_other_vert(e_a, v);
-               v_b = NULL;
-
-               sub_v3_v3v3(no_edge, v->co, v_a->co);
-
-               /* check are we flipped the right way */
-               BM_edge_calc_face_tangent(e_a, l_a, tvec_a);
-
-               *r_va_other = NULL;
-               *r_vb_other = NULL;
-       }
+#include "tools/bmesh_wireframe.h"
 
-       /* find the normal */
-       cross_v3_v3v3(r_no, no_edge, no_face);
-       normalize_v3(r_no);
-
-       if (dot_v3v3(r_no, tvec_a) > 0.0f) {
-               negate_v3(r_no);
-       }
-
-       copy_v3_v3(r_no_face, no_face);
-}
+#include "intern/bmesh_operators_private.h" /* own include */
 
-/* check if we are the only tagged loop-face around this edge */
-static bool bm_loop_is_radial_boundary(BMLoop *l_first)
-{
-       BMLoop *l = l_first->radial_next;
-
-       if (l == l_first) {
-               return true; /* a real boundary */
-       }
-       else {
-               do {
-                       if (BM_elem_flag_test(l->f, BM_ELEM_TAG)) {
-                               return false;
-                       }
-               } while ((l = l->radial_next) != l_first);
-       }
-       return true;
-}
 
 void bmo_wireframe_exec(BMesh *bm, BMOperator *op)
 {
+       const float offset             = BMO_slot_float_get(op->slots_in, "thickness");
+       const float offset_fac         = BMO_slot_float_get(op->slots_in, "offset");
+       const bool use_replace         = BMO_slot_bool_get(op->slots_in,  "use_replace");
        const bool use_boundary        = BMO_slot_bool_get(op->slots_in,  "use_boundary");
        const bool use_even_offset     = BMO_slot_bool_get(op->slots_in,  "use_even_offset");
        const bool use_relative_offset = BMO_slot_bool_get(op->slots_in,  "use_relative_offset");
        const bool use_crease          = BMO_slot_bool_get(op->slots_in,  "use_crease");
-       const float depth              = BMO_slot_float_get(op->slots_in, "thickness");
-       const float inset              = depth;
-       int cd_edge_crease_offset      = use_crease ? CustomData_get_offset(&bm->edata, CD_CREASE) : -1;
-       const float crease_weight      = 1.0f;
-
-       const int totvert_orig = bm->totvert;
-
-       BMOIter oiter;
-       BMIter iter;
-       BMIter itersub;
-
-       /* filled only with boundary verts */
-       BMVert **verts_src      = MEM_mallocN(sizeof(BMVert *) * totvert_orig, __func__);
-       BMVert **verts_neg      = MEM_mallocN(sizeof(BMVert *) * totvert_orig, __func__);
-       BMVert **verts_pos      = MEM_mallocN(sizeof(BMVert *) * totvert_orig, __func__);
-
-       /* will over-alloc, but makes for easy lookups by index to keep aligned  */
-       BMVert **verts_boundary = use_boundary ?
-                                 MEM_mallocN(sizeof(BMVert *) * totvert_orig, __func__) : NULL;
-
-       float  *verts_relfac    = use_relative_offset ?
-                                 MEM_mallocN(sizeof(float) * totvert_orig, __func__) : NULL;
-
-       /* may over-alloc if not all faces have wire */
-       BMVert **verts_loop;
-       int verts_loop_tot = 0;
-
-       BMVert *v_src;
-
-       BMFace *f_src;
-       BMLoop *l;
-
-       float tvec[3];
-       float fac;
-
-       int i;
-
-       if (use_crease && cd_edge_crease_offset == -1) {
-               BM_data_layer_add(bm, &bm->edata, CD_CREASE);
-               cd_edge_crease_offset = CustomData_get_offset(&bm->edata, CD_CREASE);
-       }
-
-       BM_mesh_elem_index_ensure(bm, BM_VERT);
-
-       BM_ITER_MESH_INDEX (v_src, &iter, bm, BM_VERTS_OF_MESH, i) {
-               BM_elem_flag_disable(v_src, BM_ELEM_TAG);
-               verts_src[i] = v_src;
-       }
-
-       /* setup tags, all faces and verts will be tagged which will be duplicated */
-       BM_mesh_elem_hflag_disable_all(bm, BM_FACE | BM_EDGE, BM_ELEM_TAG, false);
-
-       BMO_ITER (f_src, &oiter, op->slots_in, "faces", BM_FACE) {
-               verts_loop_tot += f_src->len;
-               BM_elem_flag_enable(f_src, BM_ELEM_TAG);
-               BM_ITER_ELEM (l, &itersub, f_src, BM_LOOPS_OF_FACE) {
-                       BM_elem_flag_enable(l->v, BM_ELEM_TAG);
-
-                       /* also tag boundary edges */
-                       BM_elem_flag_set(l->e, BM_ELEM_TAG, bm_loop_is_radial_boundary(l));
-               }
-       }
-
-       /* duplicate tagged verts */
-       for (i = 0; i < totvert_orig; i++) {
-               v_src = verts_src[i];
-               if (BM_elem_flag_test(v_src, BM_ELEM_TAG)) {
-                       fac = depth;
-
-                       if (use_relative_offset) {
-                               verts_relfac[i] = BM_vert_calc_mean_tagged_edge_length(v_src);
-                               fac *= verts_relfac[i];
-                       }
-
-                       madd_v3_v3v3fl(tvec, v_src->co, v_src->no, -fac);
-                       verts_neg[i] = BM_vert_create(bm, tvec, v_src, BM_CREATE_NOP);
-                       madd_v3_v3v3fl(tvec, v_src->co, v_src->no,  fac);
-                       verts_pos[i] = BM_vert_create(bm, tvec, v_src, BM_CREATE_NOP);
-               }
-               else {
-                       /* could skip this */
-                       verts_src[i] = NULL;
-                       verts_neg[i] = NULL;
-                       verts_pos[i] = NULL;
-               }
-
-               /* conflicts with BM_vert_calc_mean_tagged_edge_length */
-               if (use_relative_offset == false) {
-                       BM_elem_flag_disable(v_src, BM_ELEM_TAG);
-               }
-       }
-
-       if (use_relative_offset) {
-               BM_mesh_elem_hflag_disable_all(bm, BM_VERT, BM_ELEM_TAG, false);
-       }
-
-       verts_loop = MEM_mallocN(sizeof(BMVert *) * verts_loop_tot, __func__);
-       verts_loop_tot = 0; /* count up again */
-
-       BMO_ITER (f_src, &oiter, op->slots_in, "faces", BM_FACE) {
-               BM_ITER_ELEM (l, &itersub, f_src, BM_LOOPS_OF_FACE) {
-                       BM_elem_index_set(l, verts_loop_tot); /* set_loop */
-
-                       BM_loop_calc_face_tangent(l, tvec);
-
-                       /* create offset vert */
-                       fac = inset;
-                       if (use_even_offset) {
-                               fac *= shell_angle_to_dist(((float)M_PI - BM_loop_calc_face_angle(l)) * 0.5f);
-                       }
-                       if (use_relative_offset) {
-                               fac *= verts_relfac[BM_elem_index_get(l->v)];
-                       }
-
-                       madd_v3_v3v3fl(tvec, l->v->co, tvec, fac);
-                       verts_loop[verts_loop_tot] = BM_vert_create(bm, tvec, l->v, BM_CREATE_NOP);
-
-
-                       if (use_boundary) {
-                               if (BM_elem_flag_test(l->e, BM_ELEM_TAG)) {  /* is this a boundary? */
-
-                                       BMLoop *l_pair[2] = {l, l->next};
-
-                                       BM_elem_flag_enable(l->e, BM_ELEM_TAG);
-                                       for (i = 0; i < 2; i++) {
-                                               if (!BM_elem_flag_test(l_pair[i]->v, BM_ELEM_TAG)) {
-                                                       float no_face[3];
-                                                       BMVert *va_other;
-                                                       BMVert *vb_other;
-
-                                                       BM_elem_flag_enable(l_pair[i]->v, BM_ELEM_TAG);
-
-                                                       bm_vert_boundary_tangent(l_pair[i]->v, tvec, no_face, &va_other, &vb_other);
-
-                                                       /* create offset vert */
-                                                       /* similar to code above but different angle calc */
-                                                       fac = inset;
-                                                       if (use_even_offset) {
-                                                               if (va_other) {  /* for verts with only one boundary edge - this will be NULL */
-                                                                       fac *= shell_angle_to_dist(((float)M_PI - angle_on_axis_v3v3v3_v3(va_other->co,
-                                                                                                                                         l_pair[i]->v->co,
-                                                                                                                                         vb_other->co,
-                                                                                                                                         no_face)) * 0.5f);
-                                                               }
-                                                       }
-                                                       if (use_relative_offset) {
-                                                               fac *= verts_relfac[BM_elem_index_get(l_pair[i]->v)];
-                                                       }
-                                                       madd_v3_v3v3fl(tvec, l_pair[i]->v->co, tvec, fac);
-                                                       verts_boundary[BM_elem_index_get(l_pair[i]->v)] = BM_vert_create(bm, tvec, l_pair[i]->v, BM_CREATE_NOP);
-                                               }
-                                       }
-                               }
-                       }
-
-                       verts_loop_tot++;
-               }
-       }
-
-       BMO_ITER (f_src, &oiter, op->slots_in, "faces", BM_FACE) {
-               BM_elem_flag_disable(f_src, BM_ELEM_TAG);
-               BM_ITER_ELEM (l, &itersub, f_src, BM_LOOPS_OF_FACE) {
-                       BMFace *f_new;
-                       BMLoop *l_new;
-                       BMLoop *l_next = l->next;
-                       BMVert *v_l1 = verts_loop[BM_elem_index_get(l)];
-                       BMVert *v_l2 = verts_loop[BM_elem_index_get(l_next)];
-
-                       BMVert *v_src_l1 = l->v;
-                       BMVert *v_src_l2 = l_next->v;
-
-                       const int i_1 = BM_elem_index_get(v_src_l1);
-                       const int i_2 = BM_elem_index_get(v_src_l2);
-
-                       BMVert *v_neg1 = verts_neg[i_1];
-                       BMVert *v_neg2 = verts_neg[i_2];
-
-                       BMVert *v_pos1 = verts_pos[i_1];
-                       BMVert *v_pos2 = verts_pos[i_2];
-
-                       f_new = BM_face_create_quad_tri(bm, v_l1, v_l2, v_neg2, v_neg1, f_src, false);
-                       BM_elem_flag_enable(f_new, BM_ELEM_TAG);
-                       l_new = BM_FACE_FIRST_LOOP(f_new);
-
-                       BM_elem_attrs_copy(bm, bm, l,      l_new);
-                       BM_elem_attrs_copy(bm, bm, l,      l_new->prev);
-                       BM_elem_attrs_copy(bm, bm, l_next, l_new->next);
-                       BM_elem_attrs_copy(bm, bm, l_next, l_new->next->next);
-
-                       f_new = BM_face_create_quad_tri(bm, v_l2, v_l1, v_pos1, v_pos2, f_src, false);
-                       BM_elem_flag_enable(f_new, BM_ELEM_TAG);
-                       l_new = BM_FACE_FIRST_LOOP(f_new);
-
-                       BM_elem_attrs_copy(bm, bm, l_next, l_new);
-                       BM_elem_attrs_copy(bm, bm, l_next, l_new->prev);
-                       BM_elem_attrs_copy(bm, bm, l,      l_new->next);
-                       BM_elem_attrs_copy(bm, bm, l,      l_new->next->next);
-
-                       if (use_boundary) {
-                               if (BM_elem_flag_test(l->e, BM_ELEM_TAG)) {
-                                       /* we know its a boundary and this is the only face user (which is being wire'd) */
-                                       /* we know we only touch this edge/face once */
-                                       BMVert *v_b1 = verts_boundary[i_1];
-                                       BMVert *v_b2 = verts_boundary[i_2];
-
-                                       f_new = BM_face_create_quad_tri(bm, v_b2, v_b1, v_neg1, v_neg2, f_src, false);
-                                       BM_elem_flag_enable(f_new, BM_ELEM_TAG);
-                                       l_new = BM_FACE_FIRST_LOOP(f_new);
-
-                                       BM_elem_attrs_copy(bm, bm, l_next, l_new);
-                                       BM_elem_attrs_copy(bm, bm, l_next, l_new->prev);
-                                       BM_elem_attrs_copy(bm, bm, l,      l_new->next);
-                                       BM_elem_attrs_copy(bm, bm, l,      l_new->next->next);
-
-                                       f_new = BM_face_create_quad_tri(bm, v_b1, v_b2, v_pos2, v_pos1, f_src, false);
-                                       BM_elem_flag_enable(f_new, BM_ELEM_TAG);
-                                       l_new = BM_FACE_FIRST_LOOP(f_new);
-
-                                       BM_elem_attrs_copy(bm, bm, l,      l_new);
-                                       BM_elem_attrs_copy(bm, bm, l,      l_new->prev);
-                                       BM_elem_attrs_copy(bm, bm, l_next, l_new->next);
-                                       BM_elem_attrs_copy(bm, bm, l_next, l_new->next->next);
-
-                                       if (use_crease) {
-                                               BMEdge *e_new;
-                                               e_new = BM_edge_exists(v_pos1, v_b1);
-                                               BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
-
-                                               e_new = BM_edge_exists(v_pos2, v_b2);
-                                               BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
-
-                                               e_new = BM_edge_exists(v_neg1, v_b1);
-                                               BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
-
-                                               e_new = BM_edge_exists(v_neg2, v_b2);
-                                               BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
-                                       }
-                               }
-                       }
-
-                       if (use_crease) {
-                               BMEdge *e_new;
-                               e_new = BM_edge_exists(v_pos1, v_l1);
-                               BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
-
-                               e_new = BM_edge_exists(v_pos2, v_l2);
-                               BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
-
-                               e_new = BM_edge_exists(v_neg1, v_l1);
-                               BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
-
-                               e_new = BM_edge_exists(v_neg2, v_l2);
-                               BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
-                       }
-
-               }
-       }
-
-       if (use_boundary) {
-               MEM_freeN(verts_boundary);
-       }
-
-       if (use_relative_offset) {
-               MEM_freeN(verts_relfac);
-       }
-
-       MEM_freeN(verts_src);
-       MEM_freeN(verts_neg);
-       MEM_freeN(verts_pos);
-       MEM_freeN(verts_loop);
+       const float crease_weight      = BMO_slot_float_get(op->slots_in, "crease_weight");
+
+       BM_mesh_elem_hflag_disable_all(bm, BM_EDGE | BM_FACE, BM_ELEM_TAG, false);
+       BMO_slot_buffer_hflag_enable(bm, op->slots_in, "faces", BM_FACE, BM_ELEM_TAG, false);
+
+       BM_mesh_wireframe(
+               bm,
+               offset, offset_fac, 0.0f,
+               use_replace,
+               use_boundary,
+               use_even_offset, use_relative_offset,
+               use_crease, crease_weight,
+               /* dummy vgroup */
+               -1, false,
+               0, MAXMAT,
+               true);
 
        BMO_slot_buffer_from_enabled_hflag(bm, op, op->slots_out, "faces.out", BM_FACE, BM_ELEM_TAG);
 }
diff --git a/source/blender/bmesh/tools/bmesh_wireframe.c b/source/blender/bmesh/tools/bmesh_wireframe.c
new file mode 100644 (file)
index 0000000..c9ec5a9
--- /dev/null
@@ -0,0 +1,541 @@
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Contributor(s): Campbell Barton
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/bmesh/operators/bmesh_wireframe.c
+ *  \ingroup bmesh
+ *
+ * Creates a solid wireframe from conected faces.
+ */
+
+#include "MEM_guardedalloc.h"
+
+#include "DNA_object_types.h"
+#include "DNA_meshdata_types.h"
+
+#include "BLI_math.h"
+
+#include "bmesh.h"
+
+#include "BKE_deform.h"
+#include "BKE_customdata.h"
+
+#include "bmesh_wireframe.h"
+
+static BMLoop *bm_edge_tag_faceloop(BMEdge *e)
+{
+       BMLoop *l, *l_first;
+
+       l = l_first = e->l;
+       do {
+               if (BM_elem_flag_test(l->f, BM_ELEM_TAG)) {
+                       return l;
+               }
+       } while ((l = l->radial_next) != l_first);
+
+       /* in the case this is used, we know this will never happen */
+       return NULL;
+}
+
+static void bm_vert_boundary_tangent(BMVert *v, float r_no[3], float r_no_face[3],
+                                     BMVert **r_va_other, BMVert **r_vb_other)
+{
+       BMIter iter;
+       BMEdge *e_iter;
+
+       BMEdge *e_a = NULL, *e_b = NULL;
+       BMVert *v_a, *v_b;
+
+       BMLoop *l_a, *l_b;
+
+       float no_face[3], no_edge[3];
+       float tvec_a[3], tvec_b[3];
+
+       /* get 2 boundary edges, there should only _be_ 2,
+        * in case there are more - results wont be valid of course */
+       BM_ITER_ELEM (e_iter, &iter, v, BM_EDGES_OF_VERT) {
+               if (BM_elem_flag_test(e_iter, BM_ELEM_TAG)) {
+                       if (e_a == NULL) {
+                               e_a = e_iter;
+                       }
+                       else {
+                               e_b = e_iter;
+                               break;
+                       }
+               }
+       }
+
+       if (e_a && e_b) {
+               /* note, with an incorrectly flushed selection this can crash */
+               l_a = bm_edge_tag_faceloop(e_a);
+               l_b = bm_edge_tag_faceloop(e_b);
+
+               /* average edge face normal */
+               add_v3_v3v3(no_face, l_a->f->no, l_b->f->no);
+
+               /* average edge direction */
+               v_a = BM_edge_other_vert(e_a, v);
+               v_b = BM_edge_other_vert(e_b, v);
+
+               sub_v3_v3v3(tvec_a, v->co, v_a->co);
+               sub_v3_v3v3(tvec_b, v_b->co, v->co);
+               normalize_v3(tvec_a);
+               normalize_v3(tvec_b);
+               add_v3_v3v3(no_edge, tvec_a, tvec_b); /* not unit length but this is ok */
+
+               /* check are we flipped the right way */
+               BM_edge_calc_face_tangent(e_a, l_a, tvec_a);
+               BM_edge_calc_face_tangent(e_b, l_b, tvec_b);
+               add_v3_v3(tvec_a, tvec_b);
+
+               *r_va_other = v_a;
+               *r_vb_other = v_b;
+       }
+       else {
+               /* degenerate case - vertex connects a boundary edged face to other faces,
+                * so we have only one boundary face - only use it for calculations */
+               l_a = bm_edge_tag_faceloop(e_a);
+
+               copy_v3_v3(no_face, l_a->f->no);
+
+               /* edge direction */
+               v_a = BM_edge_other_vert(e_a, v);
+               v_b = NULL;
+
+               sub_v3_v3v3(no_edge, v->co, v_a->co);
+
+               /* check are we flipped the right way */
+               BM_edge_calc_face_tangent(e_a, l_a, tvec_a);
+
+               *r_va_other = NULL;
+               *r_vb_other = NULL;
+       }
+
+       /* find the normal */
+       cross_v3_v3v3(r_no, no_edge, no_face);
+       normalize_v3(r_no);
+
+       if (dot_v3v3(r_no, tvec_a) > 0.0f) {
+               negate_v3(r_no);
+       }
+
+       copy_v3_v3(r_no_face, no_face);
+}
+
+/* check if we are the only tagged loop-face around this edge */
+static bool bm_loop_is_radial_boundary(BMLoop *l_first)
+{
+       BMLoop *l = l_first->radial_next;
+
+       if (l == l_first) {
+               return true; /* a real boundary */
+       }
+       else {
+               do {
+                       if (BM_elem_flag_test(l->f, BM_ELEM_TAG)) {
+                               return false;
+                       }
+               } while ((l = l->radial_next) != l_first);
+       }
+       return true;
+}
+
+/**
+ * \param def_nr  -1 for no vertex groups.
+ *
+ * \note All edge tags must be cleared.
+ * \note Behavior matches MOD_solidify.c
+ */
+void BM_mesh_wireframe(
+        BMesh *bm,
+        const float offset,
+        const float offset_fac,
+        const float offset_fac_vg,
+        const bool use_replace,
+        const bool use_boundary,
+        const bool use_even_offset,
+        const bool use_relative_offset,
+        const bool use_crease,
+        const float crease_weight,
+        const int defgrp_index,
+        const bool defgrp_invert,
+        const short mat_offset,
+        const short mat_max,
+        /* for operators */
+        const bool use_tag
+        )
+{
+       const float ofs_orig = -(((-offset_fac + 1.0f) * 0.5f) * offset);
+       const float ofs_new  = offset + ofs_orig;
+       const float ofs_mid  = (ofs_orig + ofs_new) / 2.0f;
+       const float inset = offset / 2.0f;
+       int cd_edge_crease_offset = use_crease ? CustomData_get_offset(&bm->edata, CD_CREASE) : -1;
+       const int cd_dvert_offset = (defgrp_index != -1) ? CustomData_get_offset(&bm->vdata, CD_MDEFORMVERT) : -1;
+       const float offset_fac_vg_inv = 1.0f - offset_fac_vg;
+
+       const int totvert_orig = bm->totvert;
+
+       BMIter iter;
+       BMIter itersub;
+
+       /* filled only with boundary verts */
+       BMVert **verts_src      = MEM_mallocN(sizeof(BMVert *) * totvert_orig, __func__);
+       BMVert **verts_neg      = MEM_mallocN(sizeof(BMVert *) * totvert_orig, __func__);
+       BMVert **verts_pos      = MEM_mallocN(sizeof(BMVert *) * totvert_orig, __func__);
+
+       /* will over-alloc, but makes for easy lookups by index to keep aligned  */
+       BMVert **verts_boundary = use_boundary ?
+                                 MEM_mallocN(sizeof(BMVert *) * totvert_orig, __func__) : NULL;
+
+       float  *verts_relfac    = (use_relative_offset || (cd_dvert_offset != -1)) ?
+                                 MEM_mallocN(sizeof(float) * totvert_orig, __func__) : NULL;
+
+       /* may over-alloc if not all faces have wire */
+       BMVert **verts_loop;
+       int verts_loop_tot = 0;
+
+       BMVert *v_src;
+
+       BMFace *f_src;
+       BMLoop *l;
+
+       float tvec[3];
+       float fac, fac_shell;
+
+       int i;
+
+       if (use_crease && cd_edge_crease_offset == -1) {
+               BM_data_layer_add(bm, &bm->edata, CD_CREASE);
+               cd_edge_crease_offset = CustomData_get_offset(&bm->edata, CD_CREASE);
+       }
+
+       BM_mesh_elem_index_ensure(bm, BM_VERT);
+
+       BM_ITER_MESH_INDEX (v_src, &iter, bm, BM_VERTS_OF_MESH, i) {
+               BM_elem_flag_disable(v_src, BM_ELEM_TAG);
+               verts_src[i] = v_src;
+       }
+
+       /* setup tags, all faces and verts will be tagged which will be duplicated */
+
+       BM_ITER_MESH (f_src, &iter, bm, BM_FACES_OF_MESH) {
+
+               if (use_tag) {
+                       if (!BM_elem_flag_test(f_src, BM_ELEM_TAG)) {
+                               continue;
+                       }
+               }
+               else {
+                       BM_elem_flag_enable(f_src, BM_ELEM_TAG);
+               }
+
+
+               verts_loop_tot += f_src->len;
+               BM_ITER_ELEM (l, &itersub, f_src, BM_LOOPS_OF_FACE) {
+                       BM_elem_flag_enable(l->v, BM_ELEM_TAG);
+
+                       /* also tag boundary edges */
+                       BM_elem_flag_set(l->e, BM_ELEM_TAG, bm_loop_is_radial_boundary(l));
+               }
+       }
+
+       /* duplicate tagged verts */
+       for (i = 0; i < totvert_orig; i++) {
+               v_src = verts_src[i];
+               if (BM_elem_flag_test(v_src, BM_ELEM_TAG)) {
+                       fac = 1.0f;
+
+                       if (verts_relfac) {
+                               if (use_relative_offset) {
+                                       verts_relfac[i] = BM_vert_calc_mean_tagged_edge_length(v_src);
+                               }
+                               else {
+                                       verts_relfac[i] = 1.0f;
+                               }
+
+
+                               if (cd_dvert_offset != -1) {
+                                       MDeformVert *dvert = BM_ELEM_CD_GET_VOID_P(v_src, cd_dvert_offset);
+                                       float defgrp_fac = defvert_find_weight(dvert, defgrp_index);
+
+                                       if (defgrp_invert) {
+                                               defgrp_fac = 1.0f - defgrp_fac;
+                                       }
+
+                                       if (offset_fac_vg > 0.0f) {
+                                               defgrp_fac = (offset_fac_vg + (defgrp_fac * offset_fac_vg_inv));
+                                       }
+
+                                       verts_relfac[i] *= defgrp_fac;
+                               }
+
+                               fac *= verts_relfac[i];
+                       }
+
+
+                       verts_neg[i] = BM_vert_create(bm, NULL, v_src, BM_CREATE_NOP);
+                       verts_pos[i] = BM_vert_create(bm, NULL, v_src, BM_CREATE_NOP);
+
+                       if (offset == 0.0f) {
+                               madd_v3_v3v3fl(verts_neg[i]->co, v_src->co, v_src->no, ofs_orig * fac);
+                               madd_v3_v3v3fl(verts_pos[i]->co, v_src->co, v_src->no,  ofs_new * fac);
+                       }
+                       else {
+                               madd_v3_v3v3fl(tvec, v_src->co, v_src->no, ofs_mid * fac);
+
+                               madd_v3_v3v3fl(verts_neg[i]->co, tvec, v_src->no, (ofs_mid - ofs_orig) * fac);
+                               madd_v3_v3v3fl(verts_pos[i]->co, tvec, v_src->no,  (ofs_mid - ofs_new) * fac);
+                       }
+               }
+               else {
+                       /* could skip this */
+                       verts_neg[i] = NULL;
+                       verts_pos[i] = NULL;
+               }
+
+               /* conflicts with BM_vert_calc_mean_tagged_edge_length */
+               if (use_relative_offset == false) {
+                       BM_elem_flag_disable(v_src, BM_ELEM_TAG);
+               }
+       }
+
+       if (use_relative_offset) {
+               BM_mesh_elem_hflag_disable_all(bm, BM_VERT, BM_ELEM_TAG, false);
+       }
+
+       verts_loop = MEM_mallocN(sizeof(BMVert *) * verts_loop_tot, __func__);
+       verts_loop_tot = 0; /* count up again */
+
+       BM_ITER_MESH (f_src, &iter, bm, BM_FACES_OF_MESH) {
+
+               if (use_tag && !BM_elem_flag_test(f_src, BM_ELEM_TAG)) {
+                       continue;
+               }
+
+               BM_ITER_ELEM (l, &itersub, f_src, BM_LOOPS_OF_FACE) {
+                       BM_elem_index_set(l, verts_loop_tot); /* set_loop */
+
+                       BM_loop_calc_face_tangent(l, tvec);
+
+                       /* create offset vert */
+                       fac = 1.0f;
+
+                       if (verts_relfac) {
+                               fac *= verts_relfac[BM_elem_index_get(l->v)];
+                       }
+
+                       fac_shell = fac;
+                       if (use_even_offset) {
+                               fac_shell *= shell_angle_to_dist(((float)M_PI - BM_loop_calc_face_angle(l)) * 0.5f);
+                       }
+
+
+                       madd_v3_v3v3fl(tvec, l->v->co, tvec, inset * fac_shell);
+                       if (offset != 0.0f) {
+                               madd_v3_v3fl(tvec, l->v->no, ofs_mid * fac);
+                       }
+                       verts_loop[verts_loop_tot] = BM_vert_create(bm, tvec, l->v, BM_CREATE_NOP);
+
+
+                       if (use_boundary) {
+                               if (BM_elem_flag_test(l->e, BM_ELEM_TAG)) {  /* is this a boundary? */
+                                       BMVert *v_pair[2] = {l->v, l->next->v};
+
+                                       for (i = 0; i < 2; i++) {
+                                               BMVert *v_boundary = v_pair[i];
+                                               if (!BM_elem_flag_test(v_boundary, BM_ELEM_TAG)) {
+                                                       const int v_boundary_index = BM_elem_index_get(v_boundary);
+                                                       float no_face[3];
+                                                       BMVert *va_other;
+                                                       BMVert *vb_other;
+
+                                                       BM_elem_flag_enable(v_boundary, BM_ELEM_TAG);
+
+                                                       bm_vert_boundary_tangent(v_boundary, tvec, no_face, &va_other, &vb_other);
+
+                                                       /* create offset vert */
+                                                       /* similar to code above but different angle calc */
+                                                       fac = 1.0f;
+
+                                                       if (verts_relfac) {
+                                                               fac *= verts_relfac[v_boundary_index];
+                                                       }
+
+                                                       fac_shell = fac;
+                                                       if (use_even_offset) {
+                                                               if (va_other) {  /* for verts with only one boundary edge - this will be NULL */
+                                                                       fac_shell *= shell_angle_to_dist(((float)M_PI -
+                                                                                                         angle_on_axis_v3v3v3_v3(va_other->co,
+                                                                                                                                 v_boundary->co,
+                                                                                                                                 vb_other->co,
+                                                                                                                                 no_face)) * 0.5f);
+                                                               }
+                                                       }
+
+
+                                                       madd_v3_v3v3fl(tvec, v_boundary->co, tvec, inset * fac_shell);
+                                                       if (offset != 0.0f) {
+                                                               madd_v3_v3fl(tvec, v_boundary->no, ofs_mid * fac);
+                                                       }
+                                                       verts_boundary[v_boundary_index] = BM_vert_create(bm, tvec, v_boundary, BM_CREATE_NOP);
+                                               }
+                                       }
+                               }
+                       }
+
+                       verts_loop_tot++;
+               }
+       }
+
+       BM_ITER_MESH (f_src, &iter, bm, BM_FACES_OF_MESH) {
+
+               /* skip recently added faces */
+               if (BM_elem_index_get(f_src) == -1) {
+                       continue;
+               }
+
+               if (use_tag && !BM_elem_flag_test(f_src, BM_ELEM_TAG)) {
+                       continue;
+               }
+
+               BM_elem_flag_disable(f_src, BM_ELEM_TAG);
+
+               BM_ITER_ELEM (l, &itersub, f_src, BM_LOOPS_OF_FACE) {
+                       BMFace *f_new;
+                       BMLoop *l_new;
+                       BMLoop *l_next = l->next;
+                       BMVert *v_l1 = verts_loop[BM_elem_index_get(l)];
+                       BMVert *v_l2 = verts_loop[BM_elem_index_get(l_next)];
+
+                       BMVert *v_src_l1 = l->v;
+                       BMVert *v_src_l2 = l_next->v;
+
+                       const int i_1 = BM_elem_index_get(v_src_l1);
+                       const int i_2 = BM_elem_index_get(v_src_l2);
+
+                       BMVert *v_neg1 = verts_neg[i_1];
+                       BMVert *v_neg2 = verts_neg[i_2];
+
+                       BMVert *v_pos1 = verts_pos[i_1];
+                       BMVert *v_pos2 = verts_pos[i_2];
+
+                       f_new = BM_face_create_quad_tri(bm, v_l1, v_l2, v_neg2, v_neg1, f_src, false);
+                       if (mat_offset) f_new->mat_nr = CLAMPIS(f_new->mat_nr + mat_offset, 0, mat_max);
+                       BM_elem_flag_enable(f_new, BM_ELEM_TAG);
+                       l_new = BM_FACE_FIRST_LOOP(f_new);
+
+                       BM_elem_attrs_copy(bm, bm, l,      l_new);
+                       BM_elem_attrs_copy(bm, bm, l,      l_new->prev);
+                       BM_elem_attrs_copy(bm, bm, l_next, l_new->next);
+                       BM_elem_attrs_copy(bm, bm, l_next, l_new->next->next);
+
+                       f_new = BM_face_create_quad_tri(bm, v_l2, v_l1, v_pos1, v_pos2, f_src, false);
+
+                       if (mat_offset) f_new->mat_nr = CLAMPIS(f_new->mat_nr + mat_offset, 0, mat_max);
+                       BM_elem_flag_enable(f_new, BM_ELEM_TAG);
+                       l_new = BM_FACE_FIRST_LOOP(f_new);
+
+                       BM_elem_attrs_copy(bm, bm, l_next, l_new);
+                       BM_elem_attrs_copy(bm, bm, l_next, l_new->prev);
+                       BM_elem_attrs_copy(bm, bm, l,      l_new->next);
+                       BM_elem_attrs_copy(bm, bm, l,      l_new->next->next);
+
+                       if (use_boundary) {
+                               if (BM_elem_flag_test(l->e, BM_ELEM_TAG)) {
+                                       /* we know its a boundary and this is the only face user (which is being wire'd) */
+                                       /* we know we only touch this edge/face once */
+                                       BMVert *v_b1 = verts_boundary[i_1];
+                                       BMVert *v_b2 = verts_boundary[i_2];
+
+                                       f_new = BM_face_create_quad_tri(bm, v_b2, v_b1, v_neg1, v_neg2, f_src, false);
+                                       if (mat_offset) f_new->mat_nr = CLAMPIS(f_new->mat_nr + mat_offset, 0, mat_max);
+                                       BM_elem_flag_enable(f_new, BM_ELEM_TAG);
+                                       l_new = BM_FACE_FIRST_LOOP(f_new);
+
+                                       BM_elem_attrs_copy(bm, bm, l_next, l_new);
+                                       BM_elem_attrs_copy(bm, bm, l_next, l_new->prev);
+                                       BM_elem_attrs_copy(bm, bm, l,      l_new->next);
+                                       BM_elem_attrs_copy(bm, bm, l,      l_new->next->next);
+
+                                       f_new = BM_face_create_quad_tri(bm, v_b1, v_b2, v_pos2, v_pos1, f_src, false);
+                                       if (mat_offset) f_new->mat_nr = CLAMPIS(f_new->mat_nr + mat_offset, 0, mat_max);
+                                       BM_elem_flag_enable(f_new, BM_ELEM_TAG);
+                                       l_new = BM_FACE_FIRST_LOOP(f_new);
+
+                                       BM_elem_attrs_copy(bm, bm, l,      l_new);
+                                       BM_elem_attrs_copy(bm, bm, l,      l_new->prev);
+                                       BM_elem_attrs_copy(bm, bm, l_next, l_new->next);
+                                       BM_elem_attrs_copy(bm, bm, l_next, l_new->next->next);
+
+                                       if (use_crease) {
+                                               BMEdge *e_new;
+                                               e_new = BM_edge_exists(v_pos1, v_b1);
+                                               BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
+
+                                               e_new = BM_edge_exists(v_pos2, v_b2);
+                                               BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
+
+                                               e_new = BM_edge_exists(v_neg1, v_b1);
+                                               BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
+
+                                               e_new = BM_edge_exists(v_neg2, v_b2);
+                                               BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
+                                       }
+                               }
+                       }
+
+                       if (use_crease) {
+                               BMEdge *e_new;
+                               e_new = BM_edge_exists(v_pos1, v_l1);
+                               BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
+
+                               e_new = BM_edge_exists(v_pos2, v_l2);
+                               BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
+
+                               e_new = BM_edge_exists(v_neg1, v_l1);
+                               BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
+
+                               e_new = BM_edge_exists(v_neg2, v_l2);
+                               BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
+                       }
+
+               }
+       }
+
+       if (use_boundary) {
+               MEM_freeN(verts_boundary);
+       }
+
+       if (verts_relfac) {
+               MEM_freeN(verts_relfac);
+       }
+
+       if (use_replace) {
+               for (i = 0; i < totvert_orig; i++) {
+                       BM_vert_kill(bm, verts_src[i]);
+               }
+       }
+
+       MEM_freeN(verts_src);
+       MEM_freeN(verts_neg);
+       MEM_freeN(verts_pos);
+       MEM_freeN(verts_loop);
+}
diff --git a/source/blender/bmesh/tools/bmesh_wireframe.h b/source/blender/bmesh/tools/bmesh_wireframe.h
new file mode 100644 (file)
index 0000000..9f40c23
--- /dev/null
@@ -0,0 +1,50 @@
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Contributor(s): Campbell Barton
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/bmesh/tools/bmesh_wireframe.h
+ *  \ingroup bmesh
+ *
+ * Wire Frame.
+ *
+ */
+
+#ifndef __BMESH_WIREFRAME_H__
+#define __BMESH_WIREFRAME_H__
+
+void BM_mesh_wireframe(
+        BMesh *bm,
+        const float offset,
+        const float offset_fac,
+        const float offset_fac_vg,
+        const bool use_replace,
+        const bool use_boundary,
+        const bool use_even_offset,
+        const bool use_relative_offset,
+        const bool use_crease,
+        const float crease_weight,
+        const int defgrp_index,
+        const bool defgrp_invert,
+        const short mat_offset,
+        const short mat_max,
+        const bool use_tag);
+
+#endif  /* __BMESH_WIREFRAME_H__ */
index 74812e58e060a845aad643ae69687a6b8a8edd34..23daa9eb7f1a6ba34f78ea8d7cfaf3766ba70a91 100644 (file)
@@ -4513,25 +4513,18 @@ static int edbm_wireframe_exec(bContext *C, wmOperator *op)
        const bool use_replace         = RNA_boolean_get(op->ptr, "use_replace");
        const bool use_relative_offset = RNA_boolean_get(op->ptr, "use_relative_offset");
        const bool use_crease          = RNA_boolean_get(op->ptr, "use_crease");
+       const float crease_weight      = RNA_float_get(op->ptr,   "crease_weight");
        const float thickness          = RNA_float_get(op->ptr,   "thickness");
+       const float offset             = RNA_float_get(op->ptr,   "offset");
 
        EDBM_op_init(em, &bmop, op,
-                    "wireframe faces=%hf use_boundary=%b use_even_offset=%b use_relative_offset=%b use_crease=%b "
-                    "thickness=%f",
-                    BM_ELEM_SELECT, use_boundary, use_even_offset, use_relative_offset, use_crease,
-                    thickness);
+                    "wireframe faces=%hf use_replace=%b use_boundary=%b use_even_offset=%b use_relative_offset=%b "
+                    "use_crease=%b crease_weight=%f thickness=%f offset=%f",
+                    BM_ELEM_SELECT, use_replace, use_boundary, use_even_offset, use_relative_offset,
+                    use_crease, crease_weight, thickness, offset);
 
        BMO_op_exec(em->bm, &bmop);
 
-       if (use_replace) {
-               BM_mesh_elem_hflag_disable_all(em->bm, BM_FACE, BM_ELEM_TAG, false);
-               BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_in, "faces", BM_FACE, BM_ELEM_TAG, false);
-
-               BMO_op_callf(em->bm, BMO_FLAG_DEFAULTS,
-                            "delete geom=%hvef context=%i",
-                            BM_ELEM_TAG, DEL_FACES);
-       }
-
        BM_mesh_elem_hflag_disable_all(em->bm, BM_VERT | BM_EDGE | BM_FACE, BM_ELEM_SELECT, false);
        BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faces.out", BM_FACE, BM_ELEM_SELECT, true);
 
@@ -4564,14 +4557,14 @@ void MESH_OT_wireframe(wmOperatorType *ot)
        RNA_def_boolean(ot->srna, "use_boundary",        true,  "Boundary",        "Inset face boundaries");
        RNA_def_boolean(ot->srna, "use_even_offset",     true,  "Offset Even",     "Scale the offset to give more even thickness");
        RNA_def_boolean(ot->srna, "use_relative_offset", false, "Offset Relative", "Scale the offset by surrounding geometry");
-       RNA_def_boolean(ot->srna, "use_crease",          false, "Crease",          "Crease hub edges for improved subsurf");
-
+       RNA_def_boolean(ot->srna, "use_replace",         true,  "Replace",                 "Remove original faces");
        prop = RNA_def_float(ot->srna, "thickness", 0.01f, 0.0f, FLT_MAX, "Thickness", "", 0.0f, 10.0f);
        /* use 1 rather then 10 for max else dragging the button moves too far */
        RNA_def_property_ui_range(prop, 0.0, 1.0, 0.01, 4);
-
-
-       RNA_def_boolean(ot->srna, "use_replace",         true, "Replace", "Remove original faces");
+       RNA_def_float(ot->srna, "offset", 0.01f, 0.0f, FLT_MAX, "Offset", "", 0.0f, 10.0f);
+       RNA_def_boolean(ot->srna, "use_crease",          false, "Crease",          "Crease hub edges for improved subsurf");
+       prop = RNA_def_float(ot->srna, "crease_weight", 0.01f, 0.0f, FLT_MAX, "Crease weight", "", 0.0f, 1.0f);
+       RNA_def_property_ui_range(prop, 0.0, 1.0, 0.1, 2);
 }
 
 #ifdef WITH_BULLET