code cleanup: split editmesh_tools.c, into inset, bevel (both modal operators) and...
authorCampbell Barton <ideasman42@gmail.com>
Mon, 1 Apr 2013 10:18:01 +0000 (10:18 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Mon, 1 Apr 2013 10:18:01 +0000 (10:18 +0000)
also move some selection operators from editmesh_tools.c into editmesh_select.c

19 files changed:
source/blender/editors/include/ED_mesh.h
source/blender/editors/mesh/CMakeLists.txt
source/blender/editors/mesh/editmesh_add.c
source/blender/editors/mesh/editmesh_bevel.c [new file with mode: 0644]
source/blender/editors/mesh/editmesh_bvh.c
source/blender/editors/mesh/editmesh_extrude.c [new file with mode: 0644]
source/blender/editors/mesh/editmesh_inset.c [new file with mode: 0644]
source/blender/editors/mesh/editmesh_knife.c
source/blender/editors/mesh/editmesh_knife_project.c
source/blender/editors/mesh/editmesh_loopcut.c
source/blender/editors/mesh/editmesh_rip.c
source/blender/editors/mesh/editmesh_select.c
source/blender/editors/mesh/editmesh_tools.c
source/blender/editors/mesh/editmesh_utils.c
source/blender/editors/mesh/mesh_data.c
source/blender/editors/mesh/mesh_intern.h
source/blender/editors/mesh/mesh_navmesh.c
source/blender/editors/mesh/mesh_ops.c
source/blender/editors/mesh/meshtools.c

index f84281a4f0816d7cd66b453be62a0dc7ab8e44bf..ab112fde48d39669e50bbbb9b48a7b4b61adffba 100644 (file)
@@ -278,7 +278,7 @@ void EDBM_redo_state_restore(struct BMBackup, struct BMEditMesh *em, int recalct
 void EDBM_redo_state_free(struct BMBackup *, struct BMEditMesh *em, int recalctess);
 
 
-/* meshtools.c */
+/* *** meshtools.c *** */
 int         join_mesh_exec(struct bContext *C, struct wmOperator *op);
 int         join_mesh_shapes_exec(struct bContext *C, struct wmOperator *op);
 
index 0a45dd6704b866caa9db96bcbb84d9665bf399b9..46d825b8c9d6b8c9393bcbcefc2c5b90ca0c85c6 100644 (file)
@@ -42,7 +42,10 @@ set(INC_SYS
 set(SRC
        editface.c
        editmesh_add.c
+       editmesh_bevel.c
        editmesh_bvh.c
+       editmesh_extrude.c
+       editmesh_inset.c
        editmesh_knife.c
        editmesh_knife_project.c
        editmesh_loopcut.c
index 3117f45156d104405a782c67695e671feb2e4625..34666b363f385234e411c90c13eb9af61eb74b18 100644 (file)
@@ -30,7 +30,6 @@
  */
 
 #include "DNA_object_types.h"
-#include "DNA_scene_types.h"
 
 #include "BLI_math.h"
 
@@ -50,7 +49,7 @@
 #include "ED_screen.h"
 #include "ED_object.h"
 
-#include "mesh_intern.h"
+#include "mesh_intern.h"  /* own include */
 
 /* ********* add primitive operators ************* */
 
diff --git a/source/blender/editors/mesh/editmesh_bevel.c b/source/blender/editors/mesh/editmesh_bevel.c
new file mode 100644 (file)
index 0000000..d79f125
--- /dev/null
@@ -0,0 +1,368 @@
+/*
+ * ***** 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): Joseph Eagar, Howard Trickey, Campbell Barton
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/editors/mesh/editmesh_bevel.c
+ *  \ingroup edmesh
+ */
+
+#include "MEM_guardedalloc.h"
+
+#include "DNA_object_types.h"
+
+#include "BLI_string.h"
+#include "BLI_math.h"
+
+#include "BLF_translation.h"
+
+#include "BKE_context.h"
+#include "BKE_tessmesh.h"
+
+#include "RNA_define.h"
+#include "RNA_access.h"
+
+#include "WM_api.h"
+#include "WM_types.h"
+
+#include "ED_mesh.h"
+#include "ED_numinput.h"
+#include "ED_screen.h"
+#include "ED_transform.h"
+#include "ED_view3d.h"
+
+#include "mesh_intern.h"  /* own include */
+
+
+#define MVAL_PIXEL_MARGIN  5.0f
+
+typedef struct {
+       BMEditMesh *em;
+       BMBackup mesh_backup;
+       int mcenter[2];
+       float initial_length;
+       float pixel_size;  /* use when mouse input is interpreted as spatial distance */
+       int is_modal;
+       NumInput num_input;
+       float shift_factor; /* The current factor when shift is pressed. Negative when shift not active. */
+} BevelData;
+
+#define HEADER_LENGTH 180
+
+static void edbm_bevel_update_header(wmOperator *op, bContext *C)
+{
+       const char *str = IFACE_("Confirm: Enter/LClick, Cancel: (Esc/RMB), Offset: %s, Segments: %d");
+
+       char msg[HEADER_LENGTH];
+       ScrArea *sa = CTX_wm_area(C);
+
+       if (sa) {
+               char offset_str[NUM_STR_REP_LEN];
+               BLI_snprintf(offset_str, NUM_STR_REP_LEN, "%f", RNA_float_get(op->ptr, "offset"));
+               BLI_snprintf(msg, HEADER_LENGTH, str,
+                            offset_str,
+                            RNA_int_get(op->ptr, "segments")
+                           );
+
+               ED_area_headerprint(sa, msg);
+       }
+}
+
+static int edbm_bevel_init(bContext *C, wmOperator *op, int is_modal)
+{
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = BMEdit_FromObject(obedit);
+       BevelData *opdata;
+
+       if (em == NULL) {
+               return 0;
+       }
+
+       op->customdata = opdata = MEM_mallocN(sizeof(BevelData), "beveldata_mesh_operator");
+
+       opdata->em = em;
+       opdata->is_modal = is_modal;
+       opdata->shift_factor = -1.0f;
+
+       initNumInput(&opdata->num_input);
+       opdata->num_input.flag = NUM_NO_NEGATIVE;
+
+       /* avoid the cost of allocating a bm copy */
+       if (is_modal)
+               opdata->mesh_backup = EDBM_redo_state_store(em);
+
+       return 1;
+}
+
+static int edbm_bevel_calc(wmOperator *op)
+{
+       BevelData *opdata = op->customdata;
+       BMEditMesh *em = opdata->em;
+       BMOperator bmop;
+       const float offset = RNA_float_get(op->ptr, "offset");
+       const int segments = RNA_int_get(op->ptr, "segments");
+       const bool vertex_only = RNA_boolean_get(op->ptr, "vertex_only");
+
+       /* revert to original mesh */
+       if (opdata->is_modal) {
+               EDBM_redo_state_restore(opdata->mesh_backup, em, false);
+       }
+
+       if (!EDBM_op_init(em, &bmop, op,
+                             "bevel geom=%hev offset=%f segments=%i vertex_only=%b",
+                             BM_ELEM_SELECT, offset, segments, vertex_only))
+       {
+               return 0;
+       }
+
+       BMO_op_exec(em->bm, &bmop);
+
+       if (offset != 0.0f) {
+               /* not essential, but we may have some loose geometry that
+                * won't get bevel'd and better not leave it selected */
+               EDBM_flag_disable_all(em, BM_ELEM_SELECT);
+               BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faces.out", BM_FACE, BM_ELEM_SELECT, true);
+       }
+
+       /* no need to de-select existing geometry */
+       if (!EDBM_op_finish(em, &bmop, op, true))
+               return 0;
+
+       EDBM_mesh_normals_update(opdata->em);
+
+       EDBM_update_generic(opdata->em, true, true);
+
+       return 1;
+}
+
+static void edbm_bevel_exit(bContext *C, wmOperator *op)
+{
+       BevelData *opdata = op->customdata;
+
+       ScrArea *sa = CTX_wm_area(C);
+
+       if (sa) {
+               ED_area_headerprint(sa, NULL);
+       }
+
+       if (opdata->is_modal) {
+               EDBM_redo_state_free(&opdata->mesh_backup, NULL, false);
+       }
+       MEM_freeN(opdata);
+       op->customdata = NULL;
+}
+
+static int edbm_bevel_cancel(bContext *C, wmOperator *op)
+{
+       BevelData *opdata = op->customdata;
+       if (opdata->is_modal) {
+               EDBM_redo_state_free(&opdata->mesh_backup, opdata->em, true);
+               EDBM_update_generic(opdata->em, false, true);
+       }
+
+       edbm_bevel_exit(C, op);
+
+       /* need to force redisplay or we may still view the modified result */
+       ED_region_tag_redraw(CTX_wm_region(C));
+       return OPERATOR_CANCELLED;
+}
+
+/* bevel! yay!!*/
+static int edbm_bevel_exec(bContext *C, wmOperator *op)
+{
+       if (!edbm_bevel_init(C, op, false)) {
+               edbm_bevel_exit(C, op);
+               return OPERATOR_CANCELLED;
+       }
+
+       if (!edbm_bevel_calc(op)) {
+               edbm_bevel_cancel(C, op);
+               return OPERATOR_CANCELLED;
+       }
+
+       edbm_bevel_exit(C, op);
+
+       return OPERATOR_FINISHED;
+}
+
+static int edbm_bevel_invoke(bContext *C, wmOperator *op, const wmEvent *event)
+{
+       /* TODO make modal keymap (see fly mode) */
+       RegionView3D *rv3d = CTX_wm_region_view3d(C);
+       BevelData *opdata;
+       float mlen[2];
+       float center_3d[3];
+
+       if (!edbm_bevel_init(C, op, true)) {
+               return OPERATOR_CANCELLED;
+       }
+
+       opdata = op->customdata;
+
+       /* initialize mouse values */
+       if (!calculateTransformCenter(C, V3D_CENTROID, center_3d, opdata->mcenter)) {
+               /* in this case the tool will likely do nothing,
+                * ideally this will never happen and should be checked for above */
+               opdata->mcenter[0] = opdata->mcenter[1] = 0;
+       }
+       mlen[0] = opdata->mcenter[0] - event->mval[0];
+       mlen[1] = opdata->mcenter[1] - event->mval[1];
+       opdata->initial_length = len_v2(mlen);
+       opdata->pixel_size = rv3d ? ED_view3d_pixel_size(rv3d, center_3d) : 1.0f;
+
+       edbm_bevel_update_header(op, C);
+
+       if (!edbm_bevel_calc(op)) {
+               edbm_bevel_cancel(C, op);
+               return OPERATOR_CANCELLED;
+       }
+
+       WM_event_add_modal_handler(C, op);
+
+       return OPERATOR_RUNNING_MODAL;
+}
+
+static float edbm_bevel_mval_factor(wmOperator *op, const wmEvent *event)
+{
+       BevelData *opdata = op->customdata;
+       int use_dist = true;
+       float mdiff[2];
+       float factor;
+
+       mdiff[0] = opdata->mcenter[0] - event->mval[0];
+       mdiff[1] = opdata->mcenter[1] - event->mval[1];
+
+       if (use_dist) {
+               factor = ((len_v2(mdiff) - MVAL_PIXEL_MARGIN) - opdata->initial_length) * opdata->pixel_size;
+       }
+       else {
+               factor = (len_v2(mdiff) - MVAL_PIXEL_MARGIN) / opdata->initial_length;
+               factor = factor - 1.0f;  /* a different kind of buffer where nothing happens */
+       }
+
+       /* Fake shift-transform... */
+       if (event->shift) {
+               if (opdata->shift_factor < 0.0f) {
+                       opdata->shift_factor = RNA_float_get(op->ptr, "offset");
+               }
+               factor = (factor - opdata->shift_factor) * 0.1f + opdata->shift_factor;
+       }
+       else if (opdata->shift_factor >= 0.0f)
+               opdata->shift_factor = -1.0f;
+
+       /* clamp differently based on distance/factor */
+       if (use_dist) {
+               if (factor < 0.0f) factor = 0.0f;
+       }
+       else {
+               CLAMP(factor, 0.0f, 1.0f);
+       }
+
+       return factor;
+}
+
+static int edbm_bevel_modal(bContext *C, wmOperator *op, const wmEvent *event)
+{
+       BevelData *opdata = op->customdata;
+       int segments = RNA_int_get(op->ptr, "segments");
+
+       if (event->val == KM_PRESS) {
+               /* Try to handle numeric inputs... */
+
+               if (handleNumInput(&opdata->num_input, event)) {
+                       float value = RNA_float_get(op->ptr, "offset");
+                       applyNumInput(&opdata->num_input, &value);
+                       RNA_float_set(op->ptr, "offset", value);
+                       edbm_bevel_calc(op);
+                       edbm_bevel_update_header(op, C);
+                       return OPERATOR_RUNNING_MODAL;
+               }
+       }
+
+       switch (event->type) {
+               case ESCKEY:
+               case RIGHTMOUSE:
+                       edbm_bevel_cancel(C, op);
+                       return OPERATOR_CANCELLED;
+
+               case MOUSEMOVE:
+                       if (!hasNumInput(&opdata->num_input)) {
+                               const float factor = edbm_bevel_mval_factor(op, event);
+                               RNA_float_set(op->ptr, "offset", factor);
+
+                               edbm_bevel_calc(op);
+                               edbm_bevel_update_header(op, C);
+                       }
+                       break;
+
+               case LEFTMOUSE:
+               case PADENTER:
+               case RETKEY:
+                       edbm_bevel_calc(op);
+                       edbm_bevel_exit(C, op);
+                       return OPERATOR_FINISHED;
+
+               case WHEELUPMOUSE:  /* change number of segments */
+               case PAGEUPKEY:
+                       if (event->val == KM_RELEASE)
+                               break;
+
+                       segments++;
+                       RNA_int_set(op->ptr, "segments", segments);
+                       edbm_bevel_calc(op);
+                       edbm_bevel_update_header(op, C);
+                       break;
+
+               case WHEELDOWNMOUSE:  /* change number of segments */
+               case PAGEDOWNKEY:
+                       if (event->val == KM_RELEASE)
+                               break;
+
+                       segments = max_ii(segments - 1, 1);
+                       RNA_int_set(op->ptr, "segments", segments);
+                       edbm_bevel_calc(op);
+                       edbm_bevel_update_header(op, C);
+                       break;
+       }
+
+       return OPERATOR_RUNNING_MODAL;
+}
+
+void MESH_OT_bevel(wmOperatorType *ot)
+{
+       /* identifiers */
+       ot->name = "Bevel";
+       ot->description = "Edge Bevel";
+       ot->idname = "MESH_OT_bevel";
+
+       /* api callbacks */
+       ot->exec = edbm_bevel_exec;
+       ot->invoke = edbm_bevel_invoke;
+       ot->modal = edbm_bevel_modal;
+       ot->cancel = edbm_bevel_cancel;
+       ot->poll = ED_operator_editmesh;
+
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_GRAB_POINTER | OPTYPE_BLOCKING;
+
+       RNA_def_float(ot->srna, "offset", 0.0f, -FLT_MAX, FLT_MAX, "Offset", "", 0.0f, 1.0f);
+       RNA_def_int(ot->srna, "segments", 1, 1, 50, "Segments", "Segments for curved edge", 1, 8);
+       RNA_def_boolean(ot->srna, "vertex_only", false, "Vertex only", "Bevel only vertices");
+}
index 8e397797dd987751eed9938fbfb80bab0a49daac..4c989a22291a5df61e4c479e0ae49528c78d1aa2 100644 (file)
@@ -29,9 +29,6 @@
  *  \ingroup edmesh
  */
 
-#define IN_EDITMESHBVH
-
-
 #include "MEM_guardedalloc.h"
 
 #include "DNA_scene_types.h"
 #include "DNA_screen_types.h"
 #include "DNA_view3d_types.h"
 
-
 #include "BLI_math.h"
 #include "BLI_smallhash.h"
 
 #include "BKE_DerivedMesh.h"
 #include "BKE_tessmesh.h"
 
-#include "ED_mesh.h"
 #include "ED_view3d.h"
 
+#define IN_EDITMESHBVH     /* needed for typedef workaround */
 #include "editmesh_bvh.h"  /* own include */
 
+
 typedef struct BMBVHTree {
        BMEditMesh *em;
        BMesh *bm;
diff --git a/source/blender/editors/mesh/editmesh_extrude.c b/source/blender/editors/mesh/editmesh_extrude.c
new file mode 100644 (file)
index 0000000..694053a
--- /dev/null
@@ -0,0 +1,921 @@
+/*
+ * ***** 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.
+ *
+ * The Original Code is Copyright (C) 2004 by Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): Joseph Eagar
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/editors/mesh/editmesh_extrude.c
+ *  \ingroup edmesh
+ */
+
+#include "DNA_modifier_types.h"
+#include "DNA_object_types.h"
+
+#include "BLI_math.h"
+
+#include "BKE_context.h"
+#include "BKE_object.h"
+#include "BKE_report.h"
+#include "BKE_tessmesh.h"
+
+#include "RNA_define.h"
+#include "RNA_access.h"
+
+#include "WM_types.h"
+
+#include "ED_mesh.h"
+#include "ED_screen.h"
+#include "ED_view3d.h"
+
+#include "mesh_intern.h"  /* own include */
+
+/* allow accumulated normals to form a new direction but don't
+ * accept direct opposite directions else they will cancel each other out */
+static void add_normal_aligned(float nor[3], const float add[3])
+{
+       if (dot_v3v3(nor, add) < -0.9999f) {
+               sub_v3_v3(nor, add);
+       }
+       else {
+               add_v3_v3(nor, add);
+       }
+}
+
+/* individual face extrude */
+/* will use vertex normals for extrusion directions, so *nor is unaffected */
+static short edbm_extrude_discrete_faces(BMEditMesh *em, wmOperator *op, const char hflag, float *UNUSED(nor))
+{
+       BMOIter siter;
+       BMIter liter;
+       BMFace *f;
+       BMLoop *l;
+       BMOperator bmop;
+
+       EDBM_op_init(em, &bmop, op, "extrude_discrete_faces faces=%hf", hflag);
+
+       /* deselect original verts */
+       EDBM_flag_disable_all(em, BM_ELEM_SELECT);
+
+       BMO_op_exec(em->bm, &bmop);
+       
+       BMO_ITER (f, &siter, bmop.slots_out, "faces.out", BM_FACE) {
+               BM_face_select_set(em->bm, f, true);
+
+               /* set face vertex normals to face normal */
+               BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
+                       copy_v3_v3(l->v->no, f->no);
+               }
+       }
+
+       if (!EDBM_op_finish(em, &bmop, op, true)) {
+               return 0;
+       }
+
+       return 's';  /* s is shrink/fatten */
+}
+
+/* extrudes individual edges */
+static short edbm_extrude_edges_indiv(BMEditMesh *em, wmOperator *op, const char hflag, float *UNUSED(nor))
+{
+       BMOperator bmop;
+
+       EDBM_op_init(em, &bmop, op, "extrude_edge_only edges=%he", hflag);
+
+       /* deselect original verts */
+       EDBM_flag_disable_all(em, BM_ELEM_SELECT);
+
+       BMO_op_exec(em->bm, &bmop);
+       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "geom.out", BM_VERT | BM_EDGE, BM_ELEM_SELECT, true);
+
+       if (!EDBM_op_finish(em, &bmop, op, true)) {
+               return 0;
+       }
+
+       return 'n';  /* n is normal grab */
+}
+
+/* extrudes individual vertices */
+static short edbm_extrude_verts_indiv(BMEditMesh *em, wmOperator *op, const char hflag, float *UNUSED(nor))
+{
+       BMOperator bmop;
+
+       EDBM_op_init(em, &bmop, op, "extrude_vert_indiv verts=%hv", hflag);
+
+       /* deselect original verts */
+       BMO_slot_buffer_hflag_disable(em->bm, bmop.slots_in, "verts", BM_VERT, BM_ELEM_SELECT, true);
+
+       BMO_op_exec(em->bm, &bmop);
+       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "verts.out", BM_VERT, BM_ELEM_SELECT, true);
+
+       if (!EDBM_op_finish(em, &bmop, op, true)) {
+               return 0;
+       }
+
+       return 'g';  /* g is grab */
+}
+
+static short edbm_extrude_edge(Object *obedit, BMEditMesh *em, const char hflag, float nor[3])
+{
+       BMesh *bm = em->bm;
+       BMIter iter;
+       BMOIter siter;
+       BMOperator extop;
+       BMEdge *edge;
+       BMFace *f;
+       ModifierData *md;
+       BMElem *ele;
+       BMOpSlot *slot_edges_exclude;
+       
+       BMO_op_init(bm, &extop, BMO_FLAG_DEFAULTS, "extrude_face_region");
+       BMO_slot_buffer_from_enabled_hflag(bm, &extop, extop.slots_in, "geom", BM_VERT | BM_EDGE | BM_FACE, hflag);
+
+       slot_edges_exclude = BMO_slot_get(extop.slots_in, "edges_exclude");
+
+       /* If a mirror modifier with clipping is on, we need to adjust some 
+        * of the cases above to handle edges on the line of symmetry.
+        */
+       md = obedit->modifiers.first;
+       for (; md; md = md->next) {
+               if ((md->type == eModifierType_Mirror) && (md->mode & eModifierMode_Realtime)) {
+                       MirrorModifierData *mmd = (MirrorModifierData *) md;
+               
+                       if (mmd->flag & MOD_MIR_CLIPPING) {
+                               float mtx[4][4];
+                               if (mmd->mirror_ob) {
+                                       float imtx[4][4];
+                                       invert_m4_m4(imtx, mmd->mirror_ob->obmat);
+                                       mult_m4_m4m4(mtx, imtx, obedit->obmat);
+                               }
+
+                               BM_ITER_MESH (edge, &iter, bm, BM_EDGES_OF_MESH) {
+                                       if (BM_elem_flag_test(edge, hflag) &&
+                                           BM_edge_is_boundary(edge) &&
+                                           BM_elem_flag_test(edge->l->f, hflag))
+                                       {
+                                               float co1[3], co2[3];
+
+                                               copy_v3_v3(co1, edge->v1->co);
+                                               copy_v3_v3(co2, edge->v2->co);
+
+                                               if (mmd->mirror_ob) {
+                                                       mul_v3_m4v3(co1, mtx, co1);
+                                                       mul_v3_m4v3(co2, mtx, co2);
+                                               }
+
+                                               if (mmd->flag & MOD_MIR_AXIS_X) {
+                                                       if ((fabsf(co1[0]) < mmd->tolerance) &&
+                                                           (fabsf(co2[0]) < mmd->tolerance))
+                                                       {
+                                                               BMO_slot_map_empty_insert(&extop, slot_edges_exclude, edge);
+                                                       }
+                                               }
+                                               if (mmd->flag & MOD_MIR_AXIS_Y) {
+                                                       if ((fabsf(co1[1]) < mmd->tolerance) &&
+                                                           (fabsf(co2[1]) < mmd->tolerance))
+                                                       {
+                                                               BMO_slot_map_empty_insert(&extop, slot_edges_exclude, edge);
+                                                       }
+                                               }
+                                               if (mmd->flag & MOD_MIR_AXIS_Z) {
+                                                       if ((fabsf(co1[2]) < mmd->tolerance) &&
+                                                           (fabsf(co2[2]) < mmd->tolerance))
+                                                       {
+                                                               BMO_slot_map_empty_insert(&extop, slot_edges_exclude, edge);
+                                                       }
+                                               }
+                                       }
+                               }
+                       }
+               }
+       }
+
+       EDBM_flag_disable_all(em, BM_ELEM_SELECT);
+
+       BMO_op_exec(bm, &extop);
+
+       zero_v3(nor);
+       
+       BMO_ITER (ele, &siter, extop.slots_out, "geom.out", BM_ALL) {
+               BM_elem_select_set(bm, ele, true);
+
+               if (ele->head.htype == BM_FACE) {
+                       f = (BMFace *)ele;
+                       add_normal_aligned(nor, f->no);
+               }
+       }
+
+       normalize_v3(nor);
+
+       BMO_op_finish(bm, &extop);
+
+       /* grab / normal constraint */
+       return is_zero_v3(nor) ? 'g' : 'n';
+}
+
+static short edbm_extrude_vert(Object *obedit, BMEditMesh *em, const char hflag, float nor[3])
+{
+       BMIter iter;
+       BMEdge *eed;
+               
+       /* ensure vert flags are consistent for edge selections */
+       BM_ITER_MESH (eed, &iter, em->bm, BM_EDGES_OF_MESH) {
+               if (BM_elem_flag_test(eed, hflag)) {
+                       if (hflag & BM_ELEM_SELECT) {
+                               BM_vert_select_set(em->bm, eed->v1, true);
+                               BM_vert_select_set(em->bm, eed->v2, true);
+                       }
+
+                       BM_elem_flag_enable(eed->v1, hflag & ~BM_ELEM_SELECT);
+                       BM_elem_flag_enable(eed->v2, hflag & ~BM_ELEM_SELECT);
+               }
+               else {
+                       if (BM_elem_flag_test(eed->v1, hflag) && BM_elem_flag_test(eed->v2, hflag)) {
+                               if (hflag & BM_ELEM_SELECT) {
+                                       BM_edge_select_set(em->bm, eed, true);
+                               }
+
+                               BM_elem_flag_enable(eed, hflag & ~BM_ELEM_SELECT);
+                       }
+               }
+       }
+
+       return edbm_extrude_edge(obedit, em, hflag, nor);
+}
+
+static int edbm_extrude_repeat_exec(bContext *C, wmOperator *op)
+{
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = BMEdit_FromObject(obedit);
+       RegionView3D *rv3d = CTX_wm_region_view3d(C);
+               
+       const int steps = RNA_int_get(op->ptr, "steps");
+       
+       const float offs = RNA_float_get(op->ptr, "offset");
+       float dvec[3], tmat[3][3], bmat[3][3], nor[3] = {0.0, 0.0, 0.0};
+       short a;
+
+       /* dvec */
+       normalize_v3_v3(dvec, rv3d->persinv[2]);
+       mul_v3_fl(dvec, offs);
+
+       /* base correction */
+       copy_m3_m4(bmat, obedit->obmat);
+       invert_m3_m3(tmat, bmat);
+       mul_m3_v3(tmat, dvec);
+
+       for (a = 0; a < steps; a++) {
+               edbm_extrude_edge(obedit, em, BM_ELEM_SELECT, nor);
+               //BMO_op_callf(em->bm, BMO_FLAG_DEFAULTS, "extrude_face_region geom=%hef", BM_ELEM_SELECT);
+               BMO_op_callf(em->bm, BMO_FLAG_DEFAULTS,
+                            "translate vec=%v verts=%hv",
+                            (float *)dvec, BM_ELEM_SELECT);
+               //extrudeflag(obedit, em, SELECT, nor);
+               //translateflag(em, SELECT, dvec);
+       }
+       
+       EDBM_mesh_normals_update(em);
+
+       EDBM_update_generic(em, true, true);
+
+       return OPERATOR_FINISHED;
+}
+
+void MESH_OT_extrude_repeat(wmOperatorType *ot)
+{
+       /* identifiers */
+       ot->name = "Extrude Repeat Mesh";
+       ot->description = "Extrude selected vertices, edges or faces repeatedly";
+       ot->idname = "MESH_OT_extrude_repeat";
+       
+       /* api callbacks */
+       ot->exec = edbm_extrude_repeat_exec;
+       ot->poll = ED_operator_editmesh_view3d;
+       
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+       
+       /* props */
+       RNA_def_float(ot->srna, "offset", 2.0f, 0.0f, FLT_MAX, "Offset", "", 0.0f, 100.0f);
+       RNA_def_int(ot->srna, "steps", 10, 0, INT_MAX, "Steps", "", 0, 180);
+}
+
+/* generic extern called extruder */
+static int edbm_extrude_mesh(Scene *scene, Object *obedit, BMEditMesh *em, wmOperator *op, float *norin)
+{
+       short nr, transmode = 0;
+       float stacknor[3] = {0.0f, 0.0f, 0.0f};
+       float *nor = norin ? norin : stacknor;
+
+       zero_v3(nor);
+
+       /* XXX If those popup menus were to be enabled again, please get rid of this "menu string" syntax! */
+       if (em->selectmode & SCE_SELECT_VERTEX) {
+               if (em->bm->totvertsel == 0) nr = 0;
+               else if (em->bm->totvertsel == 1) nr = 4;
+               else if (em->bm->totedgesel == 0) nr = 4;
+               else if (em->bm->totfacesel == 0)
+                       nr = 3;  /* pupmenu("Extrude %t|Only Edges %x3|Only Vertices %x4"); */
+               else if (em->bm->totfacesel == 1)
+                       nr = 1;  /* pupmenu("Extrude %t|Region %x1|Only Edges% x3|Only Vertices %x4"); */
+               else
+                       nr = 1;  /* pupmenu("Extrude %t|Region %x1|Individual Faces %x2|Only Edges %x3|Only Vertices %x4"); */
+       }
+       else if (em->selectmode & SCE_SELECT_EDGE) {
+               if (em->bm->totedgesel == 0) nr = 0;
+               
+               nr = 1;
+#if 0
+               else if (em->totedgesel == 1) nr = 3;
+               else if (em->totfacesel == 0) nr = 3;
+               else if (em->totfacesel == 1)
+                       nr = 1;  /* pupmenu("Extrude %t|Region %x1|Only Edges %x3"); */
+               else
+                       nr = 1;  /* pupmenu("Extrude %t|Region %x1|Individual Faces %x2|Only Edges %x3"); */
+#endif
+       }
+       else {
+               if (em->bm->totfacesel == 0) nr = 0;
+               else if (em->bm->totfacesel == 1) nr = 1;
+               else
+                       nr = 1;  /* pupmenu("Extrude %t|Region %x1|Individual Faces %x2"); */
+       }
+
+       if (nr < 1) return 'g';
+
+       if (nr == 1 && (em->selectmode & SCE_SELECT_VERTEX))
+               transmode = edbm_extrude_vert(obedit, em, BM_ELEM_SELECT, nor);
+       else if (nr == 1) transmode = edbm_extrude_edge(obedit, em, BM_ELEM_SELECT, nor);
+       else if (nr == 4) transmode = edbm_extrude_verts_indiv(em, op, BM_ELEM_SELECT, nor);
+       else if (nr == 3) transmode = edbm_extrude_edges_indiv(em, op, BM_ELEM_SELECT, nor);
+       else transmode = edbm_extrude_discrete_faces(em, op, BM_ELEM_SELECT, nor);
+       
+       if (transmode == 0) {
+               BKE_report(op->reports, RPT_ERROR, "Not a valid selection for extrude");
+       }
+       else {
+               
+               /* We need to force immediate calculation here because
+                * transform may use derived objects (which are now stale).
+                *
+                * This shouldn't be necessary, derived queries should be
+                * automatically building this data if invalid. Or something.
+                */
+//             DAG_object_flush_update(scene, obedit, OB_RECALC_DATA);
+               BKE_object_handle_update(scene, obedit);
+
+               /* individual faces? */
+//             BIF_TransformSetUndo("Extrude");
+               if (nr == 2) {
+//                     initTransform(TFM_SHRINKFATTEN, CTX_NO_PET|CTX_NO_MIRROR);
+//                     Transform();
+               }
+               else {
+//                     initTransform(TFM_TRANSLATION, CTX_NO_PET|CTX_NO_MIRROR);
+                       if (transmode == 'n') {
+                               mul_m4_v3(obedit->obmat, nor);
+                               sub_v3_v3v3(nor, nor, obedit->obmat[3]);
+//                             BIF_setSingleAxisConstraint(nor, "along normal");
+                       }
+//                     Transform();
+               }
+       }
+       
+       return transmode;
+}
+
+/* extrude without transform */
+static int edbm_extrude_region_exec(bContext *C, wmOperator *op)
+{
+       Scene *scene = CTX_data_scene(C);
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = BMEdit_FromObject(obedit);
+       
+       edbm_extrude_mesh(scene, obedit, em, op, NULL);
+
+       /* This normally happens when pushing undo but modal operators
+        * like this one don't push undo data until after modal mode is
+        * done.*/
+       EDBM_mesh_normals_update(em);
+
+       EDBM_update_generic(em, true, true);
+       
+       return OPERATOR_FINISHED;
+}
+
+void MESH_OT_extrude_region(wmOperatorType *ot)
+{
+       /* identifiers */
+       ot->name = "Extrude Region";
+       ot->idname = "MESH_OT_extrude_region";
+       ot->description = "Extrude region of faces";
+       
+       /* api callbacks */
+       //ot->invoke = mesh_extrude_region_invoke;
+       ot->exec = edbm_extrude_region_exec;
+       ot->poll = ED_operator_editmesh;
+       
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+
+       RNA_def_boolean(ot->srna, "mirror", 0, "Mirror Editing", "");
+}
+
+static int edbm_extrude_verts_exec(bContext *C, wmOperator *op)
+{
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = BMEdit_FromObject(obedit);
+       float nor[3];
+
+       edbm_extrude_verts_indiv(em, op, BM_ELEM_SELECT, nor);
+       
+       EDBM_update_generic(em, true, true);
+       
+       return OPERATOR_FINISHED;
+}
+
+void MESH_OT_extrude_verts_indiv(wmOperatorType *ot)
+{
+       /* identifiers */
+       ot->name = "Extrude Only Vertices";
+       ot->idname = "MESH_OT_extrude_verts_indiv";
+       ot->description = "Extrude individual vertices only";
+       
+       /* api callbacks */
+       ot->exec = edbm_extrude_verts_exec;
+       ot->poll = ED_operator_editmesh;
+       
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+
+       /* to give to transform */
+       RNA_def_boolean(ot->srna, "mirror", 0, "Mirror Editing", "");
+}
+
+static int edbm_extrude_edges_exec(bContext *C, wmOperator *op)
+{
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = BMEdit_FromObject(obedit);
+       float nor[3];
+
+       edbm_extrude_edges_indiv(em, op, BM_ELEM_SELECT, nor);
+       
+       EDBM_update_generic(em, true, true);
+       
+       return OPERATOR_FINISHED;
+}
+
+void MESH_OT_extrude_edges_indiv(wmOperatorType *ot)
+{
+       /* identifiers */
+       ot->name = "Extrude Only Edges";
+       ot->idname = "MESH_OT_extrude_edges_indiv";
+       ot->description = "Extrude individual edges only";
+       
+       /* api callbacks */
+       ot->exec = edbm_extrude_edges_exec;
+       ot->poll = ED_operator_editmesh;
+       
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+
+       /* to give to transform */
+       RNA_def_boolean(ot->srna, "mirror", 0, "Mirror Editing", "");
+}
+
+static int edbm_extrude_faces_exec(bContext *C, wmOperator *op)
+{
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = BMEdit_FromObject(obedit);
+       float nor[3];
+
+       edbm_extrude_discrete_faces(em, op, BM_ELEM_SELECT, nor);
+       
+       EDBM_update_generic(em, true, true);
+       
+       return OPERATOR_FINISHED;
+}
+
+void MESH_OT_extrude_faces_indiv(wmOperatorType *ot)
+{
+       /* identifiers */
+       ot->name = "Extrude Individual Faces";
+       ot->idname = "MESH_OT_extrude_faces_indiv";
+       ot->description = "Extrude individual faces only";
+       
+       /* api callbacks */
+       ot->exec = edbm_extrude_faces_exec;
+       ot->poll = ED_operator_editmesh;
+       
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+
+       RNA_def_boolean(ot->srna, "mirror", 0, "Mirror Editing", "");
+}
+
+/* *************** add-click-mesh (extrude) operator ************** */
+static int edbm_dupli_extrude_cursor_invoke(bContext *C, wmOperator *op, const wmEvent *event)
+{
+       ViewContext vc;
+       BMVert *v1;
+       BMIter iter;
+       float min[3], max[3];
+       bool done = false;
+       bool use_proj;
+       
+       em_setup_viewcontext(C, &vc);
+
+       ED_view3d_init_mats_rv3d(vc.obedit, vc.rv3d);
+
+
+       use_proj = ((vc.scene->toolsettings->snap_flag & SCE_SNAP) &&
+                   (vc.scene->toolsettings->snap_mode == SCE_SNAP_MODE_FACE));
+
+       INIT_MINMAX(min, max);
+       
+       BM_ITER_MESH (v1, &iter, vc.em->bm, BM_VERTS_OF_MESH) {
+               if (BM_elem_flag_test(v1, BM_ELEM_SELECT)) {
+                       minmax_v3v3_v3(min, max, v1->co);
+                       done = true;
+               }
+       }
+
+       /* call extrude? */
+       if (done) {
+               const bool rot_src = RNA_boolean_get(op->ptr, "rotate_source");
+               BMEdge *eed;
+               float vec[3], cent[3], mat[3][3];
+               float nor[3] = {0.0, 0.0, 0.0};
+
+               /* 2D normal calc */
+               const float mval_f[2] = {(float)event->mval[0],
+                                        (float)event->mval[1]};
+
+               /* check for edges that are half selected, use for rotation */
+               done = false;
+               BM_ITER_MESH (eed, &iter, vc.em->bm, BM_EDGES_OF_MESH) {
+                       if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) {
+                               float co1[2], co2[2];
+
+                               if ((ED_view3d_project_float_object(vc.ar, eed->v1->co, co1, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK) &&
+                                   (ED_view3d_project_float_object(vc.ar, eed->v2->co, co2, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK))
+                               {
+                                       /* 2D rotate by 90d while adding.
+                                        *  (x, y) = (y, -x)
+                                        *
+                                        * accumulate the screenspace normal in 2D,
+                                        * with screenspace edge length weighting the result. */
+                                       if (line_point_side_v2(co1, co2, mval_f) >= 0.0f) {
+                                               nor[0] +=  (co1[1] - co2[1]);
+                                               nor[1] += -(co1[0] - co2[0]);
+                                       }
+                                       else {
+                                               nor[0] +=  (co2[1] - co1[1]);
+                                               nor[1] += -(co2[0] - co1[0]);
+                                       }
+                                       done = true;
+                               }
+                       }
+               }
+
+               if (done) {
+                       float view_vec[3], cross[3];
+
+                       /* convert the 2D nomal into 3D */
+                       mul_mat3_m4_v3(vc.rv3d->viewinv, nor); /* worldspace */
+                       mul_mat3_m4_v3(vc.obedit->imat, nor); /* local space */
+
+                       /* correct the normal to be aligned on the view plane */
+                       copy_v3_v3(view_vec, vc.rv3d->viewinv[2]);
+                       mul_mat3_m4_v3(vc.obedit->imat, view_vec);
+                       cross_v3_v3v3(cross, nor, view_vec);
+                       cross_v3_v3v3(nor, view_vec, cross);
+                       normalize_v3(nor);
+               }
+               
+               /* center */
+               mid_v3_v3v3(cent, min, max);
+               copy_v3_v3(min, cent);
+
+               mul_m4_v3(vc.obedit->obmat, min);  /* view space */
+               ED_view3d_win_to_3d_int(vc.ar, min, event->mval, min);
+               mul_m4_v3(vc.obedit->imat, min); // back in object space
+
+               sub_v3_v3(min, cent);
+               
+               /* calculate rotation */
+               unit_m3(mat);
+               if (done) {
+                       float angle;
+
+                       normalize_v3_v3(vec, min);
+
+                       angle = angle_normalized_v3v3(vec, nor);
+
+                       if (angle != 0.0f) {
+                               float axis[3];
+
+                               cross_v3_v3v3(axis, nor, vec);
+
+                               /* halve the rotation if its applied twice */
+                               if (rot_src) {
+                                       angle *= 0.5f;
+                               }
+
+                               axis_angle_to_mat3(mat, axis, angle);
+                       }
+               }
+               
+               if (rot_src) {
+                       EDBM_op_callf(vc.em, op, "rotate verts=%hv cent=%v matrix=%m3",
+                                     BM_ELEM_SELECT, cent, mat);
+
+                       /* also project the source, for retopo workflow */
+                       if (use_proj)
+                               EMBM_project_snap_verts(C, vc.ar, vc.em);
+               }
+
+               edbm_extrude_edge(vc.obedit, vc.em, BM_ELEM_SELECT, nor);
+               EDBM_op_callf(vc.em, op, "rotate verts=%hv cent=%v matrix=%m3",
+                             BM_ELEM_SELECT, cent, mat);
+               EDBM_op_callf(vc.em, op, "translate verts=%hv vec=%v",
+                             BM_ELEM_SELECT, min);
+       }
+       else {
+               const float *curs = give_cursor(vc.scene, vc.v3d);
+               BMOperator bmop;
+               BMOIter oiter;
+               
+               copy_v3_v3(min, curs);
+               ED_view3d_win_to_3d_int(vc.ar, min, event->mval, min);
+
+               invert_m4_m4(vc.obedit->imat, vc.obedit->obmat);
+               mul_m4_v3(vc.obedit->imat, min); // back in object space
+               
+               EDBM_op_init(vc.em, &bmop, op, "create_vert co=%v", min);
+               BMO_op_exec(vc.em->bm, &bmop);
+
+               BMO_ITER (v1, &oiter, bmop.slots_out, "vert.out", BM_VERT) {
+                       BM_vert_select_set(vc.em->bm, v1, true);
+               }
+
+               if (!EDBM_op_finish(vc.em, &bmop, op, true)) {
+                       return OPERATOR_CANCELLED;
+               }
+       }
+
+       if (use_proj)
+               EMBM_project_snap_verts(C, vc.ar, vc.em);
+
+       /* This normally happens when pushing undo but modal operators
+        * like this one don't push undo data until after modal mode is
+        * done. */
+       EDBM_mesh_normals_update(vc.em);
+
+       EDBM_update_generic(vc.em, true, true);
+
+       return OPERATOR_FINISHED;
+}
+
+void MESH_OT_dupli_extrude_cursor(wmOperatorType *ot)
+{
+       /* identifiers */
+       ot->name = "Duplicate or Extrude at 3D Cursor";
+       ot->idname = "MESH_OT_dupli_extrude_cursor";
+       ot->description = "Duplicate and extrude selected vertices, edges or faces towards the mouse cursor";
+       
+       /* api callbacks */
+       ot->invoke = edbm_dupli_extrude_cursor_invoke;
+       ot->poll = ED_operator_editmesh;
+       
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+
+       RNA_def_boolean(ot->srna, "rotate_source", 1, "Rotate Source", "Rotate initial selection giving better shape");
+}
+
+
+static int edbm_spin_exec(bContext *C, wmOperator *op)
+{
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = BMEdit_FromObject(obedit);
+       BMesh *bm = em->bm;
+       BMOperator spinop;
+       float cent[3], axis[3], imat[3][3];
+       float d[3] = {0.0f, 0.0f, 0.0f};
+       int steps, dupli;
+       float angle;
+
+       RNA_float_get_array(op->ptr, "center", cent);
+       RNA_float_get_array(op->ptr, "axis", axis);
+       steps = RNA_int_get(op->ptr, "steps");
+       angle = RNA_float_get(op->ptr, "angle");
+       //if (ts->editbutflag & B_CLOCKWISE)
+       angle = -angle;
+       dupli = RNA_boolean_get(op->ptr, "dupli");
+
+       /* undo object transformation */
+       copy_m3_m4(imat, obedit->imat);
+       sub_v3_v3(cent, obedit->obmat[3]);
+       mul_m3_v3(imat, cent);
+       mul_m3_v3(imat, axis);
+
+       if (!EDBM_op_init(em, &spinop, op,
+                         "spin geom=%hvef cent=%v axis=%v dvec=%v steps=%i angle=%f use_duplicate=%b",
+                         BM_ELEM_SELECT, cent, axis, d, steps, angle, dupli))
+       {
+               return OPERATOR_CANCELLED;
+       }
+       BMO_op_exec(bm, &spinop);
+       EDBM_flag_disable_all(em, BM_ELEM_SELECT);
+       BMO_slot_buffer_hflag_enable(bm, spinop.slots_out, "geom_last.out", BM_ALL_NOLOOP, BM_ELEM_SELECT, true);
+       if (!EDBM_op_finish(em, &spinop, op, true)) {
+               return OPERATOR_CANCELLED;
+       }
+
+       EDBM_update_generic(em, true, true);
+
+       return OPERATOR_FINISHED;
+}
+
+/* get center and axis, in global coords */
+static int edbm_spin_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
+{
+       Scene *scene = CTX_data_scene(C);
+       View3D *v3d = CTX_wm_view3d(C);
+       RegionView3D *rv3d = ED_view3d_context_rv3d(C);
+
+       RNA_float_set_array(op->ptr, "center", give_cursor(scene, v3d));
+       RNA_float_set_array(op->ptr, "axis", rv3d->viewinv[2]);
+
+       return edbm_spin_exec(C, op);
+}
+
+void MESH_OT_spin(wmOperatorType *ot)
+{
+       PropertyRNA *prop;
+
+       /* identifiers */
+       ot->name = "Spin";
+       ot->description = "Extrude selected vertices in a circle around the cursor in indicated viewport";
+       ot->idname = "MESH_OT_spin";
+
+       /* api callbacks */
+       ot->invoke = edbm_spin_invoke;
+       ot->exec = edbm_spin_exec;
+       ot->poll = EDBM_view3d_poll;
+
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+
+       /* props */
+       RNA_def_int(ot->srna, "steps", 9, 0, INT_MAX, "Steps", "Steps", 0, INT_MAX);
+       RNA_def_boolean(ot->srna, "dupli", 0, "Dupli", "Make Duplicates");
+       prop = RNA_def_float(ot->srna, "angle", DEG2RADF(90.0f), -FLT_MAX, FLT_MAX, "Angle", "Angle", DEG2RADF(-360.0f), DEG2RADF(360.0f));
+       RNA_def_property_subtype(prop, PROP_ANGLE);
+
+       RNA_def_float_vector(ot->srna, "center", 3, NULL, -FLT_MAX, FLT_MAX, "Center", "Center in global view space", -FLT_MAX, FLT_MAX);
+       RNA_def_float_vector(ot->srna, "axis", 3, NULL, -FLT_MAX, FLT_MAX, "Axis", "Axis in global view space", -1.0f, 1.0f);
+
+}
+
+static int edbm_screw_exec(bContext *C, wmOperator *op)
+{
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = BMEdit_FromObject(obedit);
+       BMesh *bm = em->bm;
+       BMEdge *eed;
+       BMVert *eve, *v1, *v2;
+       BMIter iter, eiter;
+       BMOperator spinop;
+       float dvec[3], nor[3], cent[3], axis[3];
+       float imat[3][3];
+       int steps, turns;
+       int valence;
+
+
+       turns = RNA_int_get(op->ptr, "turns");
+       steps = RNA_int_get(op->ptr, "steps");
+       RNA_float_get_array(op->ptr, "center", cent);
+       RNA_float_get_array(op->ptr, "axis", axis);
+
+       /* undo object transformation */
+       copy_m3_m4(imat, obedit->imat);
+       sub_v3_v3(cent, obedit->obmat[3]);
+       mul_m3_v3(imat, cent);
+       mul_m3_v3(imat, axis);
+
+
+       /* find two vertices with valence count == 1, more or less is wrong */
+       v1 = NULL;
+       v2 = NULL;
+
+       BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
+               valence = 0;
+               BM_ITER_ELEM (eed, &eiter, eve, BM_EDGES_OF_VERT) {
+                       if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) {
+                               valence++;
+                       }
+               }
+
+               if (valence == 1) {
+                       if (v1 == NULL) {
+                               v1 = eve;
+                       }
+                       else if (v2 == NULL) {
+                               v2 = eve;
+                       }
+                       else {
+                               v1 = NULL;
+                               break;
+                       }
+               }
+       }
+
+       if (v1 == NULL || v2 == NULL) {
+               BKE_report(op->reports, RPT_ERROR, "You have to select a string of connected vertices too");
+               return OPERATOR_CANCELLED;
+       }
+
+       /* calculate dvec */
+       sub_v3_v3v3(dvec, v1->co, v2->co);
+       mul_v3_fl(dvec, 1.0f / steps);
+
+       if (dot_v3v3(nor, dvec) > 0.000f)
+               negate_v3(dvec);
+
+       if (!EDBM_op_init(em, &spinop, op,
+                         "spin geom=%hvef cent=%v axis=%v dvec=%v steps=%i angle=%f use_duplicate=%b",
+                         BM_ELEM_SELECT, cent, axis, dvec, turns * steps, DEG2RADF(360.0f * turns), false))
+       {
+               return OPERATOR_CANCELLED;
+       }
+       BMO_op_exec(bm, &spinop);
+       EDBM_flag_disable_all(em, BM_ELEM_SELECT);
+       BMO_slot_buffer_hflag_enable(bm, spinop.slots_out, "geom_last.out", BM_ALL_NOLOOP, BM_ELEM_SELECT, true);
+       if (!EDBM_op_finish(em, &spinop, op, true)) {
+               return OPERATOR_CANCELLED;
+       }
+
+       EDBM_update_generic(em, true, true);
+
+       return OPERATOR_FINISHED;
+}
+
+/* get center and axis, in global coords */
+static int edbm_screw_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
+{
+       Scene *scene = CTX_data_scene(C);
+       View3D *v3d = CTX_wm_view3d(C);
+       RegionView3D *rv3d = ED_view3d_context_rv3d(C);
+
+       RNA_float_set_array(op->ptr, "center", give_cursor(scene, v3d));
+       RNA_float_set_array(op->ptr, "axis", rv3d->viewinv[1]);
+
+       return edbm_screw_exec(C, op);
+}
+
+void MESH_OT_screw(wmOperatorType *ot)
+{
+       /* identifiers */
+       ot->name = "Screw";
+       ot->description = "Extrude selected vertices in screw-shaped rotation around the cursor in indicated viewport";
+       ot->idname = "MESH_OT_screw";
+
+       /* api callbacks */
+       ot->invoke = edbm_screw_invoke;
+       ot->exec = edbm_screw_exec;
+       ot->poll = EDBM_view3d_poll;
+
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+
+       /* props */
+       RNA_def_int(ot->srna, "steps", 9, 1, INT_MAX, "Steps", "Steps", 3, 256);
+       RNA_def_int(ot->srna, "turns", 1, 1, INT_MAX, "Turns", "Turns", 1, 256);
+
+       RNA_def_float_vector(ot->srna, "center", 3, NULL, -FLT_MAX, FLT_MAX,
+                            "Center", "Center in global view space", -FLT_MAX, FLT_MAX);
+       RNA_def_float_vector(ot->srna, "axis", 3, NULL, -FLT_MAX, FLT_MAX,
+                            "Axis", "Axis in global view space", -1.0f, 1.0f);
+}
diff --git a/source/blender/editors/mesh/editmesh_inset.c b/source/blender/editors/mesh/editmesh_inset.c
new file mode 100644 (file)
index 0000000..10f384f
--- /dev/null
@@ -0,0 +1,431 @@
+/*
+ * ***** 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/editors/mesh/editmesh_inset.c
+ *  \ingroup edmesh
+ */
+
+#include "MEM_guardedalloc.h"
+
+#include "DNA_object_types.h"
+
+#include "BLI_string.h"
+#include "BLI_math.h"
+
+#include "BLF_translation.h"
+
+#include "BKE_context.h"
+#include "BKE_tessmesh.h"
+
+#include "RNA_define.h"
+#include "RNA_access.h"
+
+#include "WM_api.h"
+#include "WM_types.h"
+
+#include "ED_mesh.h"
+#include "ED_numinput.h"
+#include "ED_screen.h"
+#include "ED_transform.h"
+#include "ED_view3d.h"
+
+#include "mesh_intern.h"  /* own include */
+
+
+#define HEADER_LENGTH 180
+
+typedef struct {
+       float old_thickness;
+       float old_depth;
+       int mcenter[2];
+       int modify_depth;
+       float initial_length;
+       float pixel_size;  /* use when mouse input is interpreted as spatial distance */
+       int is_modal;
+       int shift;
+       float shift_amount;
+       BMBackup backup;
+       BMEditMesh *em;
+       NumInput num_input;
+} InsetData;
+
+
+static void edbm_inset_update_header(wmOperator *op, bContext *C)
+{
+       InsetData *opdata = op->customdata;
+
+       const char *str = IFACE_("Confirm: Enter/LClick, Cancel: (Esc/RClick), Thickness: %s, "
+                                "Depth (Ctrl to tweak): %s (%s), Outset (O): (%s), Boundary (B): (%s)");
+
+       char msg[HEADER_LENGTH];
+       ScrArea *sa = CTX_wm_area(C);
+
+       if (sa) {
+               char flts_str[NUM_STR_REP_LEN * 2];
+               if (hasNumInput(&opdata->num_input))
+                       outputNumInput(&opdata->num_input, flts_str);
+               else {
+                       BLI_snprintf(flts_str, NUM_STR_REP_LEN, "%f", RNA_float_get(op->ptr, "thickness"));
+                       BLI_snprintf(flts_str + NUM_STR_REP_LEN, NUM_STR_REP_LEN, "%f", RNA_float_get(op->ptr, "depth"));
+               }
+               BLI_snprintf(msg, HEADER_LENGTH, str,
+                            flts_str,
+                            flts_str + NUM_STR_REP_LEN,
+                            opdata->modify_depth ? IFACE_("On") : IFACE_("Off"),
+                            RNA_boolean_get(op->ptr, "use_outset") ? IFACE_("On") : IFACE_("Off"),
+                            RNA_boolean_get(op->ptr, "use_boundary") ? IFACE_("On") : IFACE_("Off")
+                           );
+
+               ED_area_headerprint(sa, msg);
+       }
+}
+
+
+static int edbm_inset_init(bContext *C, wmOperator *op, int is_modal)
+{
+       InsetData *opdata;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = BMEdit_FromObject(obedit);
+
+       op->customdata = opdata = MEM_mallocN(sizeof(InsetData), "inset_operator_data");
+
+       opdata->old_thickness = 0.01;
+       opdata->old_depth = 0.0;
+       opdata->modify_depth = false;
+       opdata->shift = false;
+       opdata->shift_amount = 0.0f;
+       opdata->is_modal = is_modal;
+       opdata->em = em;
+
+       initNumInput(&opdata->num_input);
+       opdata->num_input.idx_max = 1; /* Two elements. */
+
+       if (is_modal)
+               opdata->backup = EDBM_redo_state_store(em);
+
+       return 1;
+}
+
+static void edbm_inset_exit(bContext *C, wmOperator *op)
+{
+       InsetData *opdata;
+       ScrArea *sa = CTX_wm_area(C);
+
+       opdata = op->customdata;
+
+       if (opdata->is_modal)
+               EDBM_redo_state_free(&opdata->backup, NULL, false);
+
+       if (sa) {
+               ED_area_headerprint(sa, NULL);
+       }
+       MEM_freeN(op->customdata);
+}
+
+static int edbm_inset_cancel(bContext *C, wmOperator *op)
+{
+       InsetData *opdata;
+
+       opdata = op->customdata;
+       if (opdata->is_modal) {
+               EDBM_redo_state_free(&opdata->backup, opdata->em, true);
+               EDBM_update_generic(opdata->em, false, true);
+       }
+
+       edbm_inset_exit(C, op);
+
+       /* need to force redisplay or we may still view the modified result */
+       ED_region_tag_redraw(CTX_wm_region(C));
+       return OPERATOR_CANCELLED;
+}
+
+static int edbm_inset_calc(wmOperator *op)
+{
+       InsetData *opdata;
+       BMEditMesh *em;
+       BMOperator bmop;
+
+       const bool use_boundary        = RNA_boolean_get(op->ptr, "use_boundary");
+       const bool use_even_offset     = RNA_boolean_get(op->ptr, "use_even_offset");
+       const bool use_relative_offset = RNA_boolean_get(op->ptr, "use_relative_offset");
+       const float thickness          = RNA_float_get(op->ptr,   "thickness");
+       const float depth              = RNA_float_get(op->ptr,   "depth");
+       const bool use_outset          = RNA_boolean_get(op->ptr, "use_outset");
+       const bool use_select_inset    = RNA_boolean_get(op->ptr, "use_select_inset"); /* not passed onto the BMO */
+
+       opdata = op->customdata;
+       em = opdata->em;
+
+       if (opdata->is_modal) {
+               EDBM_redo_state_restore(opdata->backup, em, false);
+       }
+
+       EDBM_op_init(em, &bmop, op,
+                    "inset faces=%hf use_boundary=%b use_even_offset=%b use_relative_offset=%b "
+                    "thickness=%f depth=%f use_outset=%b",
+                    BM_ELEM_SELECT, use_boundary, use_even_offset, use_relative_offset,
+                    thickness, depth, use_outset);
+
+       BMO_op_exec(em->bm, &bmop);
+
+       if (use_select_inset) {
+               /* deselect original faces/verts */
+               EDBM_flag_disable_all(em, BM_ELEM_SELECT);
+               BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faces.out", BM_FACE, BM_ELEM_SELECT, true);
+       }
+       else {
+               BM_mesh_elem_hflag_disable_all(em->bm, BM_VERT | BM_EDGE, BM_ELEM_SELECT, false);
+               BMO_slot_buffer_hflag_disable(em->bm, bmop.slots_out, "faces.out", BM_FACE, BM_ELEM_SELECT, false);
+               /* re-select faces so the verts and edges get selected too */
+               BM_mesh_elem_hflag_enable_test(em->bm, BM_FACE, BM_ELEM_SELECT, true, BM_ELEM_SELECT);
+       }
+
+       if (!EDBM_op_finish(em, &bmop, op, true)) {
+               return 0;
+       }
+       else {
+               EDBM_update_generic(em, true, true);
+               return 1;
+       }
+}
+
+static int edbm_inset_exec(bContext *C, wmOperator *op)
+{
+       edbm_inset_init(C, op, false);
+
+       if (!edbm_inset_calc(op)) {
+               edbm_inset_exit(C, op);
+               return OPERATOR_CANCELLED;
+       }
+
+       edbm_inset_exit(C, op);
+       return OPERATOR_FINISHED;
+}
+
+static int edbm_inset_invoke(bContext *C, wmOperator *op, const wmEvent *event)
+{
+       RegionView3D *rv3d = CTX_wm_region_view3d(C);
+       InsetData *opdata;
+       float mlen[2];
+       float center_3d[3];
+
+       edbm_inset_init(C, op, true);
+
+       opdata = op->customdata;
+
+       /* initialize mouse values */
+       if (!calculateTransformCenter(C, V3D_CENTROID, center_3d, opdata->mcenter)) {
+               /* in this case the tool will likely do nothing,
+                * ideally this will never happen and should be checked for above */
+               opdata->mcenter[0] = opdata->mcenter[1] = 0;
+       }
+       mlen[0] = opdata->mcenter[0] - event->mval[0];
+       mlen[1] = opdata->mcenter[1] - event->mval[1];
+       opdata->initial_length = len_v2(mlen);
+       opdata->pixel_size = rv3d ? ED_view3d_pixel_size(rv3d, center_3d) : 1.0f;
+
+       edbm_inset_calc(op);
+
+       edbm_inset_update_header(op, C);
+
+       WM_event_add_modal_handler(C, op);
+       return OPERATOR_RUNNING_MODAL;
+}
+
+static int edbm_inset_modal(bContext *C, wmOperator *op, const wmEvent *event)
+{
+       InsetData *opdata = op->customdata;
+
+       if (event->val == KM_PRESS) {
+               /* Try to handle numeric inputs... */
+
+               if (handleNumInput(&opdata->num_input, event)) {
+                       float amounts[2] = {RNA_float_get(op->ptr, "thickness"),
+                                           RNA_float_get(op->ptr, "depth")};
+                       applyNumInput(&opdata->num_input, amounts);
+                       amounts[0] = max_ff(amounts[0], 0.0f);
+                       RNA_float_set(op->ptr, "thickness", amounts[0]);
+                       RNA_float_set(op->ptr, "depth", amounts[1]);
+
+                       if (edbm_inset_calc(op)) {
+                               edbm_inset_update_header(op, C);
+                               return OPERATOR_RUNNING_MODAL;
+                       }
+                       else {
+                               edbm_inset_cancel(C, op);
+                               return OPERATOR_CANCELLED;
+                       }
+               }
+       }
+
+       switch (event->type) {
+               case ESCKEY:
+               case RIGHTMOUSE:
+                       edbm_inset_cancel(C, op);
+                       return OPERATOR_CANCELLED;
+
+               case MOUSEMOVE:
+                       if (!hasNumInput(&opdata->num_input)) {
+                               float mdiff[2];
+                               float amount;
+
+                               mdiff[0] = opdata->mcenter[0] - event->mval[0];
+                               mdiff[1] = opdata->mcenter[1] - event->mval[1];
+
+                               if (opdata->modify_depth)
+                                       amount = opdata->old_depth     + ((len_v2(mdiff) - opdata->initial_length) * opdata->pixel_size);
+                               else
+                                       amount = opdata->old_thickness - ((len_v2(mdiff) - opdata->initial_length) * opdata->pixel_size);
+
+                               /* Fake shift-transform... */
+                               if (opdata->shift)
+                                       amount = (amount - opdata->shift_amount) * 0.1f + opdata->shift_amount;
+
+                               if (opdata->modify_depth)
+                                       RNA_float_set(op->ptr, "depth", amount);
+                               else {
+                                       amount = max_ff(amount, 0.0f);
+                                       RNA_float_set(op->ptr, "thickness", amount);
+                               }
+
+                               if (edbm_inset_calc(op))
+                                       edbm_inset_update_header(op, C);
+                               else {
+                                       edbm_inset_cancel(C, op);
+                                       return OPERATOR_CANCELLED;
+                               }
+                       }
+                       break;
+
+               case LEFTMOUSE:
+               case PADENTER:
+               case RETKEY:
+                       edbm_inset_calc(op);
+                       edbm_inset_exit(C, op);
+                       return OPERATOR_FINISHED;
+
+               case LEFTSHIFTKEY:
+               case RIGHTSHIFTKEY:
+                       if (event->val == KM_PRESS) {
+                               if (opdata->modify_depth)
+                                       opdata->shift_amount = RNA_float_get(op->ptr, "depth");
+                               else
+                                       opdata->shift_amount = RNA_float_get(op->ptr, "thickness");
+                               opdata->shift = true;
+                       }
+                       else {
+                               opdata->shift_amount = 0.0f;
+                               opdata->shift = false;
+                       }
+                       break;
+
+               case LEFTCTRLKEY:
+               case RIGHTCTRLKEY:
+               {
+                       float mlen[2];
+
+                       mlen[0] = opdata->mcenter[0] - event->mval[0];
+                       mlen[1] = opdata->mcenter[1] - event->mval[1];
+
+                       if (event->val == KM_PRESS) {
+                               opdata->old_thickness = RNA_float_get(op->ptr, "thickness");
+                               if (opdata->shift)
+                                       opdata->shift_amount = opdata->old_thickness;
+                               opdata->modify_depth = true;
+                       }
+                       else {
+                               opdata->old_depth = RNA_float_get(op->ptr, "depth");
+                               if (opdata->shift)
+                                       opdata->shift_amount = opdata->old_depth;
+                               opdata->modify_depth = false;
+                       }
+                       opdata->initial_length = len_v2(mlen);
+
+                       edbm_inset_update_header(op, C);
+                       break;
+               }
+
+               case OKEY:
+                       if (event->val == KM_PRESS) {
+                               const bool use_outset = RNA_boolean_get(op->ptr, "use_outset");
+                               RNA_boolean_set(op->ptr, "use_outset", !use_outset);
+                               if (edbm_inset_calc(op)) {
+                                       edbm_inset_update_header(op, C);
+                               }
+                               else {
+                                       edbm_inset_cancel(C, op);
+                                       return OPERATOR_CANCELLED;
+                               }
+                       }
+                       break;
+               case BKEY:
+                       if (event->val == KM_PRESS) {
+                               const bool use_boundary = RNA_boolean_get(op->ptr, "use_boundary");
+                               RNA_boolean_set(op->ptr, "use_boundary", !use_boundary);
+                               if (edbm_inset_calc(op)) {
+                                       edbm_inset_update_header(op, C);
+                               }
+                               else {
+                                       edbm_inset_cancel(C, op);
+                                       return OPERATOR_CANCELLED;
+                               }
+                       }
+                       break;
+       }
+
+       return OPERATOR_RUNNING_MODAL;
+}
+
+
+void MESH_OT_inset(wmOperatorType *ot)
+{
+       PropertyRNA *prop;
+
+       /* identifiers */
+       ot->name = "Inset Faces";
+       ot->idname = "MESH_OT_inset";
+       ot->description = "Inset new faces into selected faces";
+
+       /* api callbacks */
+       ot->invoke = edbm_inset_invoke;
+       ot->modal = edbm_inset_modal;
+       ot->exec = edbm_inset_exec;
+       ot->cancel = edbm_inset_cancel;
+       ot->poll = ED_operator_editmesh;
+
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_GRAB_POINTER | OPTYPE_BLOCKING;
+
+       /* properties */
+       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");
+
+       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);
+       prop = RNA_def_float(ot->srna, "depth", 0.0f, -FLT_MAX, FLT_MAX, "Depth", "", -10.0f, 10.0f);
+       RNA_def_property_ui_range(prop, -10.0f, 10.0f, 0.01, 4);
+
+       RNA_def_boolean(ot->srna, "use_outset", false, "Outset", "Outset rather than inset");
+       RNA_def_boolean(ot->srna, "use_select_inset", true, "Select Outer", "Select the new inset faces");
+}
index 57d3f7406cae7077aa86a9582d9a8da215646fb4..3f1c8ced5d2856293c94515abab3fa643bc24328 100644 (file)
@@ -35,7 +35,8 @@
 
 #include "MEM_guardedalloc.h"
 
-#include "BLI_blenlib.h"
+#include "BLI_listbase.h"
+#include "BLI_string.h"
 #include "BLI_array.h"
 #include "BLI_linklist.h"
 #include "BLI_math.h"
@@ -58,7 +59,6 @@
 #include "WM_api.h"
 #include "WM_types.h"
 
-#include "DNA_scene_types.h"
 #include "DNA_object_types.h"
 #include "BKE_tessmesh.h"
 #include "UI_resources.h"
@@ -66,7 +66,7 @@
 #include "RNA_access.h"
 #include "RNA_define.h"
 
-#include "mesh_intern.h"
+#include "mesh_intern.h"  /* own include */
 
 /* this code here is kindof messy. . .I might need to eventually rework it - joeedh */
 
index c8256914884f12c8a4829702cf71187a2e306b7f..1dae4aa51c88718cad776967d4010714a3ba2080 100644 (file)
@@ -15,7 +15,7 @@
  * along with this program; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  *
- * The Original Code is Copyright (C) 2007 Blender Foundation.
+ * The Original Code is Copyright (C) 2013 Blender Foundation.
  * All rights reserved.
  *
  *
  */
 
 #include "DNA_curve_types.h"
-#include "DNA_scene_types.h"
 #include "DNA_object_types.h"
-#include "DNA_screen_types.h"
-#include "DNA_windowmanager_types.h"
 
-#include "BLI_utildefines.h"
 #include "BLI_math.h"
 #include "BLI_linklist.h"
 #include "BLI_listbase.h"
 
-#include "BKE_library.h"
 #include "BKE_mesh.h"
 #include "BKE_context.h"
 #include "BKE_curve.h"
@@ -55,7 +50,7 @@
 #include "ED_screen.h"
 #include "ED_view3d.h"
 
-#include "mesh_intern.h"
+#include "mesh_intern.h"  /* own include */
 
 
 static LinkNode *knifeproject_poly_from_object(ARegion *ar, Scene *scene, Object *ob, LinkNode *polys)
index ee1c274b154303f799e5b685d731fdfd2b37f429..62cb1840808ad74553be365357010db00a3122bf 100644 (file)
  */
 
 #include "DNA_object_types.h"
-#include "DNA_scene_types.h"
 
 #include "MEM_guardedalloc.h"
 
 #include "BLI_array.h"
-#include "BLI_blenlib.h"
+#include "BLI_string.h"
 #include "BLI_math.h"
 
 #include "BLF_translation.h"
@@ -58,7 +57,8 @@
 #include "WM_api.h"
 #include "WM_types.h"
 
-#include "mesh_intern.h"
+#include "mesh_intern.h"  /* own include */
+
 
 /* ringsel operator */
 
index 0ea02f371f07dc47ba83e9b65ab49fb98404a121..23920e7424e8e23e1043a69f6c400d338f17a107 100644 (file)
@@ -50,7 +50,7 @@
 #include "ED_transform.h"
 #include "ED_view3d.h"
 
-#include "mesh_intern.h"
+#include "mesh_intern.h"  /* own include */
 
 /**
  * helper to find edge for edge_rip,
@@ -1049,7 +1049,7 @@ void MESH_OT_rip(wmOperatorType *ot)
 
        /* api callbacks */
        ot->invoke = edbm_rip_invoke;
-       ot->poll = EM_view3d_poll;
+       ot->poll = EDBM_view3d_poll;
 
        /* flags */
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
index c89a5558c9a242a147114c9d096991134a36f3a6..0bdd7093976db71d871923e0ecf3353279f34007 100644 (file)
@@ -31,7 +31,7 @@
 
 #include "MEM_guardedalloc.h"
 
-#include "BLI_blenlib.h"
+#include "BLI_listbase.h"
 #include "BLI_math.h"
 #include "BLI_rand.h"
 #include "BLI_array.h"
@@ -42,7 +42,6 @@
 #include "BKE_displist.h"
 #include "BKE_report.h"
 #include "BKE_paint.h"
-#include "BKE_mesh.h"
 #include "BKE_tessmesh.h"
 
 #include "IMB_imbuf_types.h"
 
 #include "BIF_gl.h"
 
-#include "DNA_scene_types.h"
 #include "DNA_object_types.h"
 #include "DNA_mesh_types.h"
 #include "DNA_meshdata_types.h"
 
 #include "GPU_extensions.h"
 
-#include "mesh_intern.h"
-
 #include "UI_resources.h"
 
+#include "mesh_intern.h"  /* own include */
+
 /* ****************************** MIRROR **************** */
 
 void EDBM_select_mirrored(Object *UNUSED(obedit), BMEditMesh *em, bool extend)
@@ -738,7 +736,6 @@ static int similar_face_select_exec(bContext *C, wmOperator *op)
 
        EDBM_update_generic(em, false, false);
 
-       /* we succeeded */
        return OPERATOR_FINISHED;
 }      
 
@@ -780,7 +777,6 @@ static int similar_edge_select_exec(bContext *C, wmOperator *op)
 
        EDBM_update_generic(em, false, false);
 
-       /* we succeeded */
        return OPERATOR_FINISHED;
 }
 
@@ -825,7 +821,6 @@ static int similar_vert_select_exec(bContext *C, wmOperator *op)
 
        EDBM_update_generic(em, false, false);
 
-       /* we succeeded */
        return OPERATOR_FINISHED;
 }
 
@@ -1259,6 +1254,82 @@ void MESH_OT_edgering_select(wmOperatorType *ot)
        RNA_def_boolean(ot->srna, "ring", 1, "Select Ring", "Select ring");
 }
 
+/* ******************** (de)select all operator **************** */
+static int edbm_select_all_exec(bContext *C, wmOperator *op)
+{
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = BMEdit_FromObject(obedit);
+       const int action = RNA_enum_get(op->ptr, "action");
+
+       switch (action) {
+               case SEL_TOGGLE:
+                       EDBM_select_toggle_all(em);
+                       break;
+               case SEL_SELECT:
+                       EDBM_flag_enable_all(em, BM_ELEM_SELECT);
+                       break;
+               case SEL_DESELECT:
+                       EDBM_flag_disable_all(em, BM_ELEM_SELECT);
+                       break;
+               case SEL_INVERT:
+                       EDBM_select_swap(em);
+                       EDBM_selectmode_flush(em);
+                       break;
+       }
+
+       WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit);
+
+       return OPERATOR_FINISHED;
+}
+
+void MESH_OT_select_all(wmOperatorType *ot)
+{
+       /* identifiers */
+       ot->name = "(De)select All";
+       ot->idname = "MESH_OT_select_all";
+       ot->description = "(De)select all vertices, edges or faces";
+
+       /* api callbacks */
+       ot->exec = edbm_select_all_exec;
+       ot->poll = ED_operator_editmesh;
+
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+
+       WM_operator_properties_select_all(ot);
+}
+
+static int edbm_faces_select_interior_exec(bContext *C, wmOperator *UNUSED(op))
+{
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = BMEdit_FromObject(obedit);
+
+       if (EDBM_select_interior_faces(em)) {
+               WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit);
+
+               return OPERATOR_FINISHED;
+       }
+       else {
+               return OPERATOR_CANCELLED;
+       }
+
+}
+
+void MESH_OT_select_interior_faces(wmOperatorType *ot)
+{
+       /* identifiers */
+       ot->name = "Select Interior Faces";
+       ot->idname = "MESH_OT_select_interior_faces";
+       ot->description = "Select faces where all edges have more than 2 face users";
+
+       /* api callbacks */
+       ot->exec = edbm_faces_select_interior_exec;
+       ot->poll = ED_operator_editmesh;
+
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+}
+
 /* ******************* generic tag_shortest_path and helpers ****************** */
 
 static float step_cost_3_v3(const float v1[3], const float v2[3], const float v3[3])
@@ -2267,6 +2338,9 @@ int EDBM_select_interior_faces(BMEditMesh *em)
        return change;
 }
 
+
+/************************ Select Linked Operator *************************/
+
 static void linked_limit_default(bContext *C, wmOperator *op)
 {
        if (!RNA_struct_property_is_set(op->ptr, "limit")) {
@@ -2279,6 +2353,106 @@ static void linked_limit_default(bContext *C, wmOperator *op)
        }
 }
 
+static int edbm_select_linked_exec(bContext *C, wmOperator *op)
+{
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = BMEdit_FromObject(obedit);
+       BMesh *bm = em->bm;
+       BMIter iter;
+       BMVert *v;
+       BMEdge *e;
+       BMWalker walker;
+
+       int limit;
+
+       linked_limit_default(C, op);
+
+       limit = RNA_boolean_get(op->ptr, "limit");
+
+       if (em->selectmode == SCE_SELECT_FACE) {
+               BMFace *efa;
+
+               BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
+                       BM_elem_flag_set(efa, BM_ELEM_TAG, (BM_elem_flag_test(efa, BM_ELEM_SELECT) &&
+                                                           !BM_elem_flag_test(efa, BM_ELEM_HIDDEN)));
+               }
+
+               if (limit) {
+                       /* grr, shouldn't need to alloc BMO flags here */
+                       BM_mesh_elem_toolflags_ensure(bm);
+                       BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
+                               /* BMESH_TODO, don't use 'BM_ELEM_SELECT' here, its a HFLAG only! */
+                               BMO_elem_flag_set(bm, e, BM_ELEM_SELECT, !BM_elem_flag_test(e, BM_ELEM_SEAM));
+                       }
+               }
+
+               BMW_init(&walker, bm, BMW_ISLAND,
+                        BMW_MASK_NOP, limit ? BM_ELEM_SELECT : BMW_MASK_NOP, BMW_MASK_NOP,
+                        BMW_FLAG_TEST_HIDDEN,
+                        BMW_NIL_LAY);
+
+               BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
+                       if (BM_elem_flag_test(efa, BM_ELEM_TAG)) {
+                               for (efa = BMW_begin(&walker, efa); efa; efa = BMW_step(&walker)) {
+                                       BM_face_select_set(bm, efa, true);
+                               }
+                       }
+               }
+               BMW_end(&walker);
+
+               if (limit) {
+                       BM_mesh_elem_toolflags_clear(bm);
+               }
+       }
+       else {
+               BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
+                       if (BM_elem_flag_test(v, BM_ELEM_SELECT)) {
+                               BM_elem_flag_enable(v, BM_ELEM_TAG);
+                       }
+                       else {
+                               BM_elem_flag_disable(v, BM_ELEM_TAG);
+                       }
+               }
+
+               BMW_init(&walker, em->bm, BMW_SHELL,
+                        BMW_MASK_NOP, BMW_MASK_NOP, BMW_MASK_NOP,
+                        BMW_FLAG_TEST_HIDDEN,
+                        BMW_NIL_LAY);
+
+               BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
+                       if (BM_elem_flag_test(v, BM_ELEM_TAG)) {
+                               for (e = BMW_begin(&walker, v); e; e = BMW_step(&walker)) {
+                                       BM_edge_select_set(em->bm, e, true);
+                               }
+                       }
+               }
+               BMW_end(&walker);
+
+               EDBM_selectmode_flush(em);
+       }
+
+       WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit);
+
+       return OPERATOR_FINISHED;
+}
+
+void MESH_OT_select_linked(wmOperatorType *ot)
+{
+       /* identifiers */
+       ot->name = "Select Linked All";
+       ot->idname = "MESH_OT_select_linked";
+       ot->description = "Select all vertices linked to the active mesh";
+
+       /* api callbacks */
+       ot->exec = edbm_select_linked_exec;
+       ot->poll = ED_operator_editmesh;
+
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+
+       RNA_def_boolean(ot->srna, "limit", 0, "Limit by Seams", "");
+}
+
 static int edbm_select_linked_pick_invoke(bContext *C, wmOperator *op, const wmEvent *event)
 {
        Object *obedit = CTX_data_edit_object(C);
@@ -2394,104 +2568,160 @@ void MESH_OT_select_linked_pick(wmOperatorType *ot)
 }
 
 
-static int edbm_select_linked_exec(bContext *C, wmOperator *op)
+static int edbm_select_face_by_sides_exec(bContext *C, wmOperator *op)
 {
        Object *obedit = CTX_data_edit_object(C);
        BMEditMesh *em = BMEdit_FromObject(obedit);
-       BMesh *bm = em->bm;
+       BMFace *efa;
        BMIter iter;
-       BMVert *v;
-       BMEdge *e;
-       BMWalker walker;
-
-       int limit;
+       const int numverts = RNA_int_get(op->ptr, "number");
+       const int type = RNA_enum_get(op->ptr, "type");
 
-       linked_limit_default(C, op);
+       if (!RNA_boolean_get(op->ptr, "extend"))
+               EDBM_flag_disable_all(em, BM_ELEM_SELECT);
 
-       limit = RNA_boolean_get(op->ptr, "limit");
+       BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
 
-       if (em->selectmode == SCE_SELECT_FACE) {
-               BMFace *efa;
+               int select;
 
-               BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
-                       BM_elem_flag_set(efa, BM_ELEM_TAG, (BM_elem_flag_test(efa, BM_ELEM_SELECT) &&
-                                                           !BM_elem_flag_test(efa, BM_ELEM_HIDDEN)));
+               switch (type) {
+                       case 0:
+                               select = (efa->len < numverts);
+                               break;
+                       case 1:
+                               select = (efa->len == numverts);
+                               break;
+                       case 2:
+                               select = (efa->len > numverts);
+                               break;
+                       case 3:
+                               select = (efa->len != numverts);
+                               break;
+                       default:
+                               BLI_assert(0);
+                               select = false;
+                               break;
                }
 
-               if (limit) {
-                       /* grr, shouldn't need to alloc BMO flags here */
-                       BM_mesh_elem_toolflags_ensure(bm);
-                       BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
-                               /* BMESH_TODO, don't use 'BM_ELEM_SELECT' here, its a HFLAG only! */
-                               BMO_elem_flag_set(bm, e, BM_ELEM_SELECT, !BM_elem_flag_test(e, BM_ELEM_SEAM));
-                       }
+               if (select) {
+                       BM_face_select_set(em->bm, efa, true);
                }
+       }
 
-               BMW_init(&walker, bm, BMW_ISLAND,
-                        BMW_MASK_NOP, limit ? BM_ELEM_SELECT : BMW_MASK_NOP, BMW_MASK_NOP,
-                        BMW_FLAG_TEST_HIDDEN,
-                        BMW_NIL_LAY);
+       EDBM_selectmode_flush(em);
 
-               BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
-                       if (BM_elem_flag_test(efa, BM_ELEM_TAG)) {
-                               for (efa = BMW_begin(&walker, efa); efa; efa = BMW_step(&walker)) {
-                                       BM_face_select_set(bm, efa, true);
-                               }
-                       }
-               }
-               BMW_end(&walker);
+       WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit->data);
+       return OPERATOR_FINISHED;
+}
 
-               if (limit) {
-                       BM_mesh_elem_toolflags_clear(bm);
+void MESH_OT_select_face_by_sides(wmOperatorType *ot)
+{
+       static const EnumPropertyItem type_items[] = {
+               {0, "LESS", 0, "Less Than", ""},
+               {1, "EQUAL", 0, "Equal To", ""},
+               {2, "GREATER", 0, "Greater Than", ""},
+               {3, "NOTEQUAL", 0, "Not Equal To", ""},
+               {0, NULL, 0, NULL, NULL}
+       };
+
+       /* identifiers */
+       ot->name = "Select Faces by Sides";
+       ot->description = "Select vertices or faces by the number of polygon sides";
+       ot->idname = "MESH_OT_select_face_by_sides";
+
+       /* api callbacks */
+       ot->exec = edbm_select_face_by_sides_exec;
+       ot->poll = ED_operator_editmesh;
+
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+
+       /* properties */
+       RNA_def_int(ot->srna, "number", 4, 3, INT_MAX, "Number of Vertices", "", 3, INT_MAX);
+       RNA_def_enum(ot->srna, "type", type_items, 1, "Type", "Type of comparison to make");
+       RNA_def_boolean(ot->srna, "extend", true, "Extend", "Extend the selection");
+}
+
+
+static int edbm_select_loose_verts_exec(bContext *C, wmOperator *op)
+{
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = BMEdit_FromObject(obedit);
+       BMVert *eve;
+       BMEdge *eed;
+       BMIter iter;
+
+       if (!RNA_boolean_get(op->ptr, "extend"))
+               EDBM_flag_disable_all(em, BM_ELEM_SELECT);
+
+       BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
+               if (!eve->e) {
+                       BM_vert_select_set(em->bm, eve, true);
                }
        }
-       else {
-               BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
-                       if (BM_elem_flag_test(v, BM_ELEM_SELECT)) {
-                               BM_elem_flag_enable(v, BM_ELEM_TAG);
-                       }
-                       else {
-                               BM_elem_flag_disable(v, BM_ELEM_TAG);
-                       }
+
+       BM_ITER_MESH (eed, &iter, em->bm, BM_EDGES_OF_MESH) {
+               if (!eed->l) {
+                       BM_edge_select_set(em->bm, eed, true);
                }
+       }
 
-               BMW_init(&walker, em->bm, BMW_SHELL,
-                        BMW_MASK_NOP, BMW_MASK_NOP, BMW_MASK_NOP,
-                        BMW_FLAG_TEST_HIDDEN,
-                        BMW_NIL_LAY);
+       EDBM_selectmode_flush(em);
 
-               BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
-                       if (BM_elem_flag_test(v, BM_ELEM_TAG)) {
-                               for (e = BMW_begin(&walker, v); e; e = BMW_step(&walker)) {
-                                       BM_edge_select_set(em->bm, e, true);
-                               }
-                       }
-               }
-               BMW_end(&walker);
+       WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit->data);
+       return OPERATOR_FINISHED;
+}
+
+void MESH_OT_select_loose_verts(wmOperatorType *ot)
+{
+       /* identifiers */
+       ot->name = "Select Loose Vertices/Edges";
+       ot->description = "Select vertices with no edges nor faces, and edges with no faces";
+       ot->idname = "MESH_OT_select_loose_verts";
+
+       /* api callbacks */
+       ot->exec = edbm_select_loose_verts_exec;
+       ot->poll = ED_operator_editmesh;
 
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+
+       /* props */
+       RNA_def_boolean(ot->srna, "extend", false, "Extend", "Extend the selection");
+}
+
+
+static int edbm_select_mirror_exec(bContext *C, wmOperator *op)
+{
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = BMEdit_FromObject(obedit);
+       bool extend = RNA_boolean_get(op->ptr, "extend");
+
+       if (em->bm->totvert && em->bm->totvertsel) {
+               EDBM_select_mirrored(obedit, em, extend);
                EDBM_selectmode_flush(em);
+               WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit->data);
        }
 
-       WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit);
-
        return OPERATOR_FINISHED;
 }
 
-void MESH_OT_select_linked(wmOperatorType *ot)
+void MESH_OT_select_mirror(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name = "Select Linked All";
-       ot->idname = "MESH_OT_select_linked";
-       ot->description = "Select all vertices linked to the active mesh";
-       
+       ot->name = "Select Mirror";
+       ot->description = "Select mesh items at mirrored locations";
+       ot->idname = "MESH_OT_select_mirror";
+
        /* api callbacks */
-       ot->exec = edbm_select_linked_exec;
+       ot->exec = edbm_select_mirror_exec;
        ot->poll = ED_operator_editmesh;
-       
+
        /* flags */
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
-       
-       RNA_def_boolean(ot->srna, "limit", 0, "Limit by Seams", "");
+
+       /* props */
+       RNA_def_boolean(ot->srna, "extend", 0, "Extend", "Extend the existing selection");
 }
 
 /* ******************** **************** */
@@ -2756,15 +2986,6 @@ void em_setup_viewcontext(bContext *C, ViewContext *vc)
        }
 }
 
-/* poll call for mesh operators requiring a view3d context */
-int EM_view3d_poll(bContext *C)
-{
-       if (ED_operator_editmesh(C) && ED_operator_view3d_active(C))
-               return 1;
-
-       return 0;
-}
-
 
 static int edbm_select_sharp_edges_exec(bContext *C, wmOperator *op)
 {
@@ -3075,6 +3296,91 @@ void MESH_OT_select_ungrouped(wmOperatorType *ot)
        RNA_def_boolean(ot->srna, "extend", false, "Extend", "Extend the selection");
 }
 
+
+/* BMESH_TODO - some way to select on an arbitrary axis */
+static int edbm_select_axis_exec(bContext *C, wmOperator *op)
+{
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = BMEdit_FromObject(obedit);
+       BMEditSelection *ese = em->bm->selected.last;
+       const int axis = RNA_enum_get(op->ptr, "axis");
+       const int mode = RNA_enum_get(op->ptr, "mode"); /* -1 == aligned, 0 == neg, 1 == pos */
+
+       if (ese == NULL || ese->htype != BM_VERT) {
+               BKE_report(op->reports, RPT_WARNING, "This operator requires an active vertex (last selected)");
+               return OPERATOR_CANCELLED;
+       }
+       else {
+               BMVert *ev, *act_vert = (BMVert *)ese->ele;
+               BMIter iter;
+               float value = act_vert->co[axis];
+               float limit =  CTX_data_tool_settings(C)->doublimit; // XXX
+
+               if (mode == 0)
+                       value -= limit;
+               else if (mode == 1)
+                       value += limit;
+
+               BM_ITER_MESH (ev, &iter, em->bm, BM_VERTS_OF_MESH) {
+                       if (!BM_elem_flag_test(ev, BM_ELEM_HIDDEN)) {
+                               switch (mode) {
+                                       case -1: /* aligned */
+                                               if (fabsf(ev->co[axis] - value) < limit)
+                                                       BM_vert_select_set(em->bm, ev, true);
+                                               break;
+                                       case 0: /* neg */
+                                               if (ev->co[axis] > value)
+                                                       BM_vert_select_set(em->bm, ev, true);
+                                               break;
+                                       case 1: /* pos */
+                                               if (ev->co[axis] < value)
+                                                       BM_vert_select_set(em->bm, ev, true);
+                                               break;
+                               }
+                       }
+               }
+       }
+
+       EDBM_selectmode_flush(em);
+       WM_event_add_notifier(C, NC_GEOM | ND_DATA, obedit->data);
+
+       return OPERATOR_FINISHED;
+}
+
+void MESH_OT_select_axis(wmOperatorType *ot)
+{
+       static EnumPropertyItem axis_mode_items[] = {
+               {0,  "POSITIVE", 0, "Positive Axis", ""},
+               {1,  "NEGATIVE", 0, "Negative Axis", ""},
+               {-1, "ALIGNED",  0, "Aligned Axis", ""},
+               {0, NULL, 0, NULL, NULL}
+       };
+
+       static EnumPropertyItem axis_items_xyz[] = {
+               {0, "X_AXIS", 0, "X Axis", ""},
+               {1, "Y_AXIS", 0, "Y Axis", ""},
+               {2, "Z_AXIS", 0, "Z Axis", ""},
+               {0, NULL, 0, NULL, NULL}
+       };
+
+       /* identifiers */
+       ot->name = "Select Axis";
+       ot->description = "Select all data in the mesh on a single axis";
+       ot->idname = "MESH_OT_select_axis";
+
+       /* api callbacks */
+       ot->exec = edbm_select_axis_exec;
+       ot->poll = ED_operator_editmesh;
+
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+
+       /* properties */
+       RNA_def_enum(ot->srna, "mode", axis_mode_items, 0, "Axis Mode", "Axis side to use when selecting");
+       RNA_def_enum(ot->srna, "axis", axis_items_xyz, 0, "Axis", "Select the axis to compare each vertex on");
+}
+
+
 static int edbm_select_next_loop_exec(bContext *C, wmOperator *UNUSED(op))
 {
        Object *obedit = CTX_data_edit_object(C);
@@ -3371,3 +3677,118 @@ void MESH_OT_loop_to_region(wmOperatorType *ot)
        
        RNA_def_boolean(ot->srna, "select_bigger", 0, "Select Bigger", "Select bigger regions instead of smaller ones");
 }
+
+
+/************************ Vertex Path Operator *************************/
+
+typedef struct PathNode {
+       /* int u; */       /* UNUSED */
+       /* int visited; */ /* UNUSED */
+       ListBase edges;
+} PathNode;
+
+typedef struct PathEdge {
+       struct PathEdge *next, *prev;
+       int v;
+       float w;
+} PathEdge;
+
+static int edbm_select_vertex_path_exec(bContext *C, wmOperator *op)
+{
+       Object *ob = CTX_data_edit_object(C);
+       BMEditMesh *em = BMEdit_FromObject(ob);
+       BMOperator bmop;
+       BMIter iter;
+       BMVert *eve = NULL, *svert = NULL, *evert = NULL;
+       BMEditSelection *sv, *ev;
+
+       /* get the type from RNA */
+       const int type = RNA_enum_get(op->ptr, "type");
+
+       /* first try to find vertices in edit selection */
+       sv = em->bm->selected.last;
+       if (sv != NULL) {
+               ev = sv->prev;
+
+               if (ev && (sv->htype == BM_VERT) && (ev->htype == BM_VERT)) {
+                       svert = (BMVert *)sv->ele;
+                       evert = (BMVert *)ev->ele;
+               }
+       }
+
+       /* if those are not found, because vertices where selected by e.g.
+        * border or circle select, find two selected vertices */
+       if (svert == NULL) {
+               BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
+                       if (!BM_elem_flag_test(eve, BM_ELEM_SELECT) || BM_elem_flag_test(eve, BM_ELEM_HIDDEN))
+                               continue;
+
+                       if (svert == NULL) {
+                               svert = eve;
+                       }
+                       else if (evert == NULL) {
+                               evert = eve;
+                       }
+                       else {
+                               /* more than two vertices are selected,
+                                * show warning message and cancel operator */
+                               svert = evert = NULL;
+                               break;
+                       }
+               }
+       }
+
+       if (svert == NULL || evert == NULL) {
+               BKE_report(op->reports, RPT_WARNING, "Path selection requires two vertices to be selected");
+               return OPERATOR_CANCELLED;
+       }
+
+       /* initialize the bmop using EDBM api, which does various ui error reporting and other stuff */
+       EDBM_op_init(em, &bmop, op,
+                    "shortest_path vert_start=%e vert_end=%e type=%i",
+                    svert, evert, type);
+
+       /* execute the operator */
+       BMO_op_exec(em->bm, &bmop);
+
+       /* DO NOT clear the existing selection */
+       /* EDBM_flag_disable_all(em, BM_ELEM_SELECT); */
+
+       /* select the output */
+       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "verts.out", BM_VERT, BM_ELEM_SELECT, true);
+
+       /* finish the operator */
+       if (!EDBM_op_finish(em, &bmop, op, true)) {
+               return OPERATOR_CANCELLED;
+       }
+
+       EDBM_selectmode_flush(em);
+
+       EDBM_update_generic(em, false, false);
+
+       return OPERATOR_FINISHED;
+}
+
+void MESH_OT_select_vertex_path(wmOperatorType *ot)
+{
+       static const EnumPropertyItem type_items[] = {
+               {VPATH_SELECT_EDGE_LENGTH, "EDGE_LENGTH", 0, "Edge Length", NULL},
+               {VPATH_SELECT_TOPOLOGICAL, "TOPOLOGICAL", 0, "Topological", NULL},
+               {0, NULL, 0, NULL, NULL}
+       };
+
+       /* identifiers */
+       ot->name = "Select Vertex Path";
+       ot->idname = "MESH_OT_select_vertex_path";
+       ot->description = "Selected vertex path between two vertices";
+
+       /* api callbacks */
+       ot->exec = edbm_select_vertex_path_exec;
+       ot->poll = ED_operator_editmesh;
+
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+
+       /* properties */
+       RNA_def_enum(ot->srna, "type", type_items, VPATH_SELECT_EDGE_LENGTH, "Type", "Method to compute distance");
+}
index 3feb8f921dc5fd1101a4d368972500fcdbd3e2e1..c4763e7532792bf8578ee47c71817fd9199b8d4f 100644 (file)
 #include "DNA_mesh_types.h"
 #include "DNA_modifier_types.h"
 #include "DNA_object_types.h"
-#include "DNA_scene_types.h"
 
-#include "BLI_blenlib.h"
+#include "BLI_listbase.h"
 #include "BLI_noise.h"
 #include "BLI_math.h"
 #include "BLI_rand.h"
 
-#include "BLF_translation.h"
-
 #include "BKE_material.h"
 #include "BKE_context.h"
 #include "BKE_depsgraph.h"
-#include "BKE_object.h"
 #include "BKE_report.h"
 #include "BKE_texture.h"
 #include "BKE_main.h"
@@ -62,7 +58,6 @@
 #include "WM_types.h"
 
 #include "ED_mesh.h"
-#include "ED_numinput.h"
 #include "ED_object.h"
 #include "ED_screen.h"
 #include "ED_transform.h"
 #include "UI_interface.h"
 #include "UI_resources.h"
 
-#include "mesh_intern.h"
+#include "mesh_intern.h"  /* own include */
 
 #define USE_FACE_CREATE_SEL_EXTEND
 
-#define MVAL_PIXEL_MARGIN  5.0f
-
-/* allow accumulated normals to form a new direction but don't
- * accept direct opposite directions else they will cancel each other out */
-static void add_normal_aligned(float nor[3], const float add[3])
-{
-       if (dot_v3v3(nor, add) < -0.9999f) {
-               sub_v3_v3(nor, add);
-       }
-       else {
-               add_v3_v3(nor, add);
-       }
-}
-
 static int edbm_subdivide_exec(bContext *C, wmOperator *op)
 {
        Object *obedit = CTX_data_edit_object(C);
@@ -228,873 +209,144 @@ void EMBM_project_snap_verts(bContext *C, ARegion *ar, BMEditMesh *em)
 }
 
 
-/* individual face extrude */
-/* will use vertex normals for extrusion directions, so *nor is unaffected */
-static short edbm_extrude_discrete_faces(BMEditMesh *em, wmOperator *op, const char hflag, float *UNUSED(nor))
-{
-       BMOIter siter;
-       BMIter liter;
-       BMFace *f;
-       BMLoop *l;
-       BMOperator bmop;
-
-       EDBM_op_init(em, &bmop, op, "extrude_discrete_faces faces=%hf", hflag);
-
-       /* deselect original verts */
-       EDBM_flag_disable_all(em, BM_ELEM_SELECT);
-
-       BMO_op_exec(em->bm, &bmop);
-       
-       BMO_ITER (f, &siter, bmop.slots_out, "faces.out", BM_FACE) {
-               BM_face_select_set(em->bm, f, true);
-
-               /* set face vertex normals to face normal */
-               BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
-                       copy_v3_v3(l->v->no, f->no);
-               }
-       }
-
-       if (!EDBM_op_finish(em, &bmop, op, true)) {
-               return 0;
-       }
-
-       return 's';  /* s is shrink/fatten */
-}
-
-/* extrudes individual edges */
-static short edbm_extrude_edges_indiv(BMEditMesh *em, wmOperator *op, const char hflag, float *UNUSED(nor))
-{
-       BMOperator bmop;
-
-       EDBM_op_init(em, &bmop, op, "extrude_edge_only edges=%he", hflag);
-
-       /* deselect original verts */
-       EDBM_flag_disable_all(em, BM_ELEM_SELECT);
-
-       BMO_op_exec(em->bm, &bmop);
-       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "geom.out", BM_VERT | BM_EDGE, BM_ELEM_SELECT, true);
-
-       if (!EDBM_op_finish(em, &bmop, op, true)) {
-               return 0;
-       }
-
-       return 'n';  /* n is normal grab */
-}
-
-/* extrudes individual vertices */
-static short edbm_extrude_verts_indiv(BMEditMesh *em, wmOperator *op, const char hflag, float *UNUSED(nor))
-{
-       BMOperator bmop;
-
-       EDBM_op_init(em, &bmop, op, "extrude_vert_indiv verts=%hv", hflag);
-
-       /* deselect original verts */
-       BMO_slot_buffer_hflag_disable(em->bm, bmop.slots_in, "verts", BM_VERT, BM_ELEM_SELECT, true);
-
-       BMO_op_exec(em->bm, &bmop);
-       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "verts.out", BM_VERT, BM_ELEM_SELECT, true);
-
-       if (!EDBM_op_finish(em, &bmop, op, true)) {
-               return 0;
-       }
-
-       return 'g';  /* g is grab */
-}
-
-static short edbm_extrude_edge(Object *obedit, BMEditMesh *em, const char hflag, float nor[3])
-{
-       BMesh *bm = em->bm;
-       BMIter iter;
-       BMOIter siter;
-       BMOperator extop;
-       BMEdge *edge;
-       BMFace *f;
-       ModifierData *md;
-       BMElem *ele;
-       BMOpSlot *slot_edges_exclude;
-       
-       BMO_op_init(bm, &extop, BMO_FLAG_DEFAULTS, "extrude_face_region");
-       BMO_slot_buffer_from_enabled_hflag(bm, &extop, extop.slots_in, "geom", BM_VERT | BM_EDGE | BM_FACE, hflag);
-
-       slot_edges_exclude = BMO_slot_get(extop.slots_in, "edges_exclude");
-
-       /* If a mirror modifier with clipping is on, we need to adjust some 
-        * of the cases above to handle edges on the line of symmetry.
-        */
-       md = obedit->modifiers.first;
-       for (; md; md = md->next) {
-               if ((md->type == eModifierType_Mirror) && (md->mode & eModifierMode_Realtime)) {
-                       MirrorModifierData *mmd = (MirrorModifierData *) md;
-               
-                       if (mmd->flag & MOD_MIR_CLIPPING) {
-                               float mtx[4][4];
-                               if (mmd->mirror_ob) {
-                                       float imtx[4][4];
-                                       invert_m4_m4(imtx, mmd->mirror_ob->obmat);
-                                       mult_m4_m4m4(mtx, imtx, obedit->obmat);
-                               }
-
-                               BM_ITER_MESH (edge, &iter, bm, BM_EDGES_OF_MESH) {
-                                       if (BM_elem_flag_test(edge, hflag) &&
-                                           BM_edge_is_boundary(edge) &&
-                                           BM_elem_flag_test(edge->l->f, hflag))
-                                       {
-                                               float co1[3], co2[3];
-
-                                               copy_v3_v3(co1, edge->v1->co);
-                                               copy_v3_v3(co2, edge->v2->co);
-
-                                               if (mmd->mirror_ob) {
-                                                       mul_v3_m4v3(co1, mtx, co1);
-                                                       mul_v3_m4v3(co2, mtx, co2);
-                                               }
-
-                                               if (mmd->flag & MOD_MIR_AXIS_X) {
-                                                       if ((fabsf(co1[0]) < mmd->tolerance) &&
-                                                           (fabsf(co2[0]) < mmd->tolerance))
-                                                       {
-                                                               BMO_slot_map_empty_insert(&extop, slot_edges_exclude, edge);
-                                                       }
-                                               }
-                                               if (mmd->flag & MOD_MIR_AXIS_Y) {
-                                                       if ((fabsf(co1[1]) < mmd->tolerance) &&
-                                                           (fabsf(co2[1]) < mmd->tolerance))
-                                                       {
-                                                               BMO_slot_map_empty_insert(&extop, slot_edges_exclude, edge);
-                                                       }
-                                               }
-                                               if (mmd->flag & MOD_MIR_AXIS_Z) {
-                                                       if ((fabsf(co1[2]) < mmd->tolerance) &&
-                                                           (fabsf(co2[2]) < mmd->tolerance))
-                                                       {
-                                                               BMO_slot_map_empty_insert(&extop, slot_edges_exclude, edge);
-                                                       }
-                                               }
-                                       }
-                               }
-                       }
-               }
-       }
-
-       EDBM_flag_disable_all(em, BM_ELEM_SELECT);
-
-       BMO_op_exec(bm, &extop);
-
-       zero_v3(nor);
-       
-       BMO_ITER (ele, &siter, extop.slots_out, "geom.out", BM_ALL) {
-               BM_elem_select_set(bm, ele, true);
-
-               if (ele->head.htype == BM_FACE) {
-                       f = (BMFace *)ele;
-                       add_normal_aligned(nor, f->no);
-               }
-       }
-
-       normalize_v3(nor);
-
-       BMO_op_finish(bm, &extop);
-
-       /* grab / normal constraint */
-       return is_zero_v3(nor) ? 'g' : 'n';
-}
-
-static short edbm_extrude_vert(Object *obedit, BMEditMesh *em, const char hflag, float nor[3])
-{
-       BMIter iter;
-       BMEdge *eed;
-               
-       /* ensure vert flags are consistent for edge selections */
-       BM_ITER_MESH (eed, &iter, em->bm, BM_EDGES_OF_MESH) {
-               if (BM_elem_flag_test(eed, hflag)) {
-                       if (hflag & BM_ELEM_SELECT) {
-                               BM_vert_select_set(em->bm, eed->v1, true);
-                               BM_vert_select_set(em->bm, eed->v2, true);
-                       }
-
-                       BM_elem_flag_enable(eed->v1, hflag & ~BM_ELEM_SELECT);
-                       BM_elem_flag_enable(eed->v2, hflag & ~BM_ELEM_SELECT);
-               }
-               else {
-                       if (BM_elem_flag_test(eed->v1, hflag) && BM_elem_flag_test(eed->v2, hflag)) {
-                               if (hflag & BM_ELEM_SELECT) {
-                                       BM_edge_select_set(em->bm, eed, true);
-                               }
-
-                               BM_elem_flag_enable(eed, hflag & ~BM_ELEM_SELECT);
-                       }
-               }
-       }
-
-       return edbm_extrude_edge(obedit, em, hflag, nor);
-}
+/* Note, these values must match delete_mesh() event values */
+static EnumPropertyItem prop_mesh_delete_types[] = {
+       {0, "VERT",      0, "Vertices", ""},
+       {1,  "EDGE",      0, "Edges", ""},
+       {2,  "FACE",      0, "Faces", ""},
+       {3,  "EDGE_FACE", 0, "Only Edges & Faces", ""},
+       {4,  "ONLY_FACE", 0, "Only Faces", ""},
+       {0, NULL, 0, NULL, NULL}
+};
 
-static int edbm_extrude_repeat_exec(bContext *C, wmOperator *op)
+static int edbm_delete_exec(bContext *C, wmOperator *op)
 {
        Object *obedit = CTX_data_edit_object(C);
        BMEditMesh *em = BMEdit_FromObject(obedit);
-       RegionView3D *rv3d = CTX_wm_region_view3d(C);
-               
-       const int steps = RNA_int_get(op->ptr, "steps");
-       
-       const float offs = RNA_float_get(op->ptr, "offset");
-       float dvec[3], tmat[3][3], bmat[3][3], nor[3] = {0.0, 0.0, 0.0};
-       short a;
-
-       /* dvec */
-       normalize_v3_v3(dvec, rv3d->persinv[2]);
-       mul_v3_fl(dvec, offs);
-
-       /* base correction */
-       copy_m3_m4(bmat, obedit->obmat);
-       invert_m3_m3(tmat, bmat);
-       mul_m3_v3(tmat, dvec);
-
-       for (a = 0; a < steps; a++) {
-               edbm_extrude_edge(obedit, em, BM_ELEM_SELECT, nor);
-               //BMO_op_callf(em->bm, BMO_FLAG_DEFAULTS, "extrude_face_region geom=%hef", BM_ELEM_SELECT);
-               BMO_op_callf(em->bm, BMO_FLAG_DEFAULTS,
-                            "translate vec=%v verts=%hv",
-                            (float *)dvec, BM_ELEM_SELECT);
-               //extrudeflag(obedit, em, SELECT, nor);
-               //translateflag(em, SELECT, dvec);
-       }
-       
-       EDBM_mesh_normals_update(em);
-
-       EDBM_update_generic(em, true, true);
-
-       return OPERATOR_FINISHED;
-}
-
-void MESH_OT_extrude_repeat(wmOperatorType *ot)
-{
-       /* identifiers */
-       ot->name = "Extrude Repeat Mesh";
-       ot->description = "Extrude selected vertices, edges or faces repeatedly";
-       ot->idname = "MESH_OT_extrude_repeat";
-       
-       /* api callbacks */
-       ot->exec = edbm_extrude_repeat_exec;
-       ot->poll = ED_operator_editmesh_view3d;
-       
-       /* flags */
-       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
-       
-       /* props */
-       RNA_def_float(ot->srna, "offset", 2.0f, 0.0f, FLT_MAX, "Offset", "", 0.0f, 100.0f);
-       RNA_def_int(ot->srna, "steps", 10, 0, INT_MAX, "Steps", "", 0, 180);
-}
+       const int type = RNA_enum_get(op->ptr, "type");
 
-/* generic extern called extruder */
-static int edbm_extrude_mesh(Scene *scene, Object *obedit, BMEditMesh *em, wmOperator *op, float *norin)
-{
-       short nr, transmode = 0;
-       float stacknor[3] = {0.0f, 0.0f, 0.0f};
-       float *nor = norin ? norin : stacknor;
-
-       zero_v3(nor);
-
-       /* XXX If those popup menus were to be enabled again, please get rid of this "menu string" syntax! */
-       if (em->selectmode & SCE_SELECT_VERTEX) {
-               if (em->bm->totvertsel == 0) nr = 0;
-               else if (em->bm->totvertsel == 1) nr = 4;
-               else if (em->bm->totedgesel == 0) nr = 4;
-               else if (em->bm->totfacesel == 0)
-                       nr = 3;  /* pupmenu("Extrude %t|Only Edges %x3|Only Vertices %x4"); */
-               else if (em->bm->totfacesel == 1)
-                       nr = 1;  /* pupmenu("Extrude %t|Region %x1|Only Edges% x3|Only Vertices %x4"); */
-               else
-                       nr = 1;  /* pupmenu("Extrude %t|Region %x1|Individual Faces %x2|Only Edges %x3|Only Vertices %x4"); */
+       if (type == 0) {
+               if (!EDBM_op_callf(em, op, "delete geom=%hv context=%i", BM_ELEM_SELECT, DEL_VERTS)) /* Erase Vertices */
+                       return OPERATOR_CANCELLED;
        }
-       else if (em->selectmode & SCE_SELECT_EDGE) {
-               if (em->bm->totedgesel == 0) nr = 0;
-               
-               nr = 1;
-#if 0
-               else if (em->totedgesel == 1) nr = 3;
-               else if (em->totfacesel == 0) nr = 3;
-               else if (em->totfacesel == 1)
-                       nr = 1;  /* pupmenu("Extrude %t|Region %x1|Only Edges %x3"); */
-               else
-                       nr = 1;  /* pupmenu("Extrude %t|Region %x1|Individual Faces %x2|Only Edges %x3"); */
-#endif
+       else if (type == 1) {
+               if (!EDBM_op_callf(em, op, "delete geom=%he context=%i", BM_ELEM_SELECT, DEL_EDGES)) /* Erase Edges */
+                       return OPERATOR_CANCELLED;
        }
-       else {
-               if (em->bm->totfacesel == 0) nr = 0;
-               else if (em->bm->totfacesel == 1) nr = 1;
-               else
-                       nr = 1;  /* pupmenu("Extrude %t|Region %x1|Individual Faces %x2"); */
+       else if (type == 2) {
+               if (!EDBM_op_callf(em, op, "delete geom=%hf context=%i", BM_ELEM_SELECT, DEL_FACES)) /* Erase Faces */
+                       return OPERATOR_CANCELLED;
        }
-
-       if (nr < 1) return 'g';
-
-       if (nr == 1 && (em->selectmode & SCE_SELECT_VERTEX))
-               transmode = edbm_extrude_vert(obedit, em, BM_ELEM_SELECT, nor);
-       else if (nr == 1) transmode = edbm_extrude_edge(obedit, em, BM_ELEM_SELECT, nor);
-       else if (nr == 4) transmode = edbm_extrude_verts_indiv(em, op, BM_ELEM_SELECT, nor);
-       else if (nr == 3) transmode = edbm_extrude_edges_indiv(em, op, BM_ELEM_SELECT, nor);
-       else transmode = edbm_extrude_discrete_faces(em, op, BM_ELEM_SELECT, nor);
-       
-       if (transmode == 0) {
-               BKE_report(op->reports, RPT_ERROR, "Not a valid selection for extrude");
+       else if (type == 3) {
+               if (!EDBM_op_callf(em, op, "delete geom=%hef context=%i", BM_ELEM_SELECT, DEL_EDGESFACES)) /* Edges and Faces */
+                       return OPERATOR_CANCELLED;
        }
-       else {
-               
-               /* We need to force immediate calculation here because
-                * transform may use derived objects (which are now stale).
-                *
-                * This shouldn't be necessary, derived queries should be
-                * automatically building this data if invalid. Or something.
-                */
-//             DAG_object_flush_update(scene, obedit, OB_RECALC_DATA);
-               BKE_object_handle_update(scene, obedit);
-
-               /* individual faces? */
-//             BIF_TransformSetUndo("Extrude");
-               if (nr == 2) {
-//                     initTransform(TFM_SHRINKFATTEN, CTX_NO_PET|CTX_NO_MIRROR);
-//                     Transform();
-               }
-               else {
-//                     initTransform(TFM_TRANSLATION, CTX_NO_PET|CTX_NO_MIRROR);
-                       if (transmode == 'n') {
-                               mul_m4_v3(obedit->obmat, nor);
-                               sub_v3_v3v3(nor, nor, obedit->obmat[3]);
-//                             BIF_setSingleAxisConstraint(nor, "along normal");
-                       }
-//                     Transform();
+       else if (type == 4) {
+               //"Erase Only Faces";
+               if (!EDBM_op_callf(em, op, "delete geom=%hf context=%i",
+                                  BM_ELEM_SELECT, DEL_ONLYFACES))
+               {
+                       return OPERATOR_CANCELLED;
                }
        }
-       
-       return transmode;
-}
-
-/* extrude without transform */
-static int edbm_extrude_region_exec(bContext *C, wmOperator *op)
-{
-       Scene *scene = CTX_data_scene(C);
-       Object *obedit = CTX_data_edit_object(C);
-       BMEditMesh *em = BMEdit_FromObject(obedit);
-       
-       edbm_extrude_mesh(scene, obedit, em, op, NULL);
 
-       /* This normally happens when pushing undo but modal operators
-        * like this one don't push undo data until after modal mode is
-        * done.*/
-       EDBM_mesh_normals_update(em);
+       EDBM_flag_disable_all(em, BM_ELEM_SELECT);
 
        EDBM_update_generic(em, true, true);
        
        return OPERATOR_FINISHED;
 }
 
-void MESH_OT_extrude_region(wmOperatorType *ot)
+void MESH_OT_delete(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name = "Extrude Region";
-       ot->idname = "MESH_OT_extrude_region";
-       ot->description = "Extrude region of faces";
+       ot->name = "Delete";
+       ot->description = "Delete selected vertices, edges or faces";
+       ot->idname = "MESH_OT_delete";
        
        /* api callbacks */
-       //ot->invoke = mesh_extrude_region_invoke;
-       ot->exec = edbm_extrude_region_exec;
+       ot->invoke = WM_menu_invoke;
+       ot->exec = edbm_delete_exec;
+       
        ot->poll = ED_operator_editmesh;
        
        /* flags */
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 
-       RNA_def_boolean(ot->srna, "mirror", 0, "Mirror Editing", "");
+       /* props */
+       ot->prop = RNA_def_enum(ot->srna, "type", prop_mesh_delete_types, 0, "Type", "Method used for deleting mesh data");
 }
 
-static int edbm_extrude_verts_exec(bContext *C, wmOperator *op)
+static int edbm_collapse_edge_exec(bContext *C, wmOperator *op)
 {
        Object *obedit = CTX_data_edit_object(C);
        BMEditMesh *em = BMEdit_FromObject(obedit);
-       float nor[3];
 
-       edbm_extrude_verts_indiv(em, op, BM_ELEM_SELECT, nor);
-       
+       if (!EDBM_op_callf(em, op, "collapse edges=%he", BM_ELEM_SELECT))
+               return OPERATOR_CANCELLED;
+
        EDBM_update_generic(em, true, true);
-       
+
        return OPERATOR_FINISHED;
 }
 
-void MESH_OT_extrude_verts_indiv(wmOperatorType *ot)
+void MESH_OT_edge_collapse(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name = "Extrude Only Vertices";
-       ot->idname = "MESH_OT_extrude_verts_indiv";
-       ot->description = "Extrude individual vertices only";
-       
+       ot->name = "Edge Collapse";
+       ot->description = "Collapse selected edges";
+       ot->idname = "MESH_OT_edge_collapse";
+
        /* api callbacks */
-       ot->exec = edbm_extrude_verts_exec;
+       ot->exec = edbm_collapse_edge_exec;
        ot->poll = ED_operator_editmesh;
-       
+
        /* flags */
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
-
-       /* to give to transform */
-       RNA_def_boolean(ot->srna, "mirror", 0, "Mirror Editing", "");
 }
 
-static int edbm_extrude_edges_exec(bContext *C, wmOperator *op)
+static int edbm_collapse_edge_loop_exec(bContext *C, wmOperator *op)
 {
        Object *obedit = CTX_data_edit_object(C);
        BMEditMesh *em = BMEdit_FromObject(obedit);
-       float nor[3];
 
-       edbm_extrude_edges_indiv(em, op, BM_ELEM_SELECT, nor);
-       
+       if (!EDBM_op_callf(em, op, "dissolve_edge_loop edges=%he", BM_ELEM_SELECT))
+               return OPERATOR_CANCELLED;
+
        EDBM_update_generic(em, true, true);
-       
+
        return OPERATOR_FINISHED;
 }
 
-void MESH_OT_extrude_edges_indiv(wmOperatorType *ot)
+void MESH_OT_edge_collapse_loop(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name = "Extrude Only Edges";
-       ot->idname = "MESH_OT_extrude_edges_indiv";
-       ot->description = "Extrude individual edges only";
-       
+       ot->name = "Edge Collapse Loop";
+       ot->description = "Collapse selected edge loops";
+       ot->idname = "MESH_OT_edge_collapse_loop";
+
        /* api callbacks */
-       ot->exec = edbm_extrude_edges_exec;
+       ot->exec = edbm_collapse_edge_loop_exec;
        ot->poll = ED_operator_editmesh;
-       
+
        /* flags */
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
-
-       /* to give to transform */
-       RNA_def_boolean(ot->srna, "mirror", 0, "Mirror Editing", "");
 }
 
-static int edbm_extrude_faces_exec(bContext *C, wmOperator *op)
+static int edbm_add_edge_face__smooth_get(BMesh *bm)
 {
-       Object *obedit = CTX_data_edit_object(C);
-       BMEditMesh *em = BMEdit_FromObject(obedit);
-       float nor[3];
+       BMEdge *e;
+       BMIter iter;
 
-       edbm_extrude_discrete_faces(em, op, BM_ELEM_SELECT, nor);
-       
-       EDBM_update_generic(em, true, true);
-       
-       return OPERATOR_FINISHED;
-}
+       unsigned int vote_on_smooth[2] = {0, 0};
 
-void MESH_OT_extrude_faces_indiv(wmOperatorType *ot)
-{
-       /* identifiers */
-       ot->name = "Extrude Individual Faces";
-       ot->idname = "MESH_OT_extrude_faces_indiv";
-       ot->description = "Extrude individual faces only";
-       
-       /* api callbacks */
-       ot->exec = edbm_extrude_faces_exec;
-       ot->poll = ED_operator_editmesh;
-       
-       /* flags */
-       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+       BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
+               if (BM_elem_flag_test(e, BM_ELEM_SELECT) && e->l) {
+                       vote_on_smooth[BM_elem_flag_test_bool(e->l->f, BM_ELEM_SMOOTH)]++;
+               }
+       }
 
-       RNA_def_boolean(ot->srna, "mirror", 0, "Mirror Editing", "");
-}
-
-/* ******************** (de)select all operator **************** */
-
-static int edbm_select_all_exec(bContext *C, wmOperator *op)
-{
-       Object *obedit = CTX_data_edit_object(C);
-       BMEditMesh *em = BMEdit_FromObject(obedit);
-       const int action = RNA_enum_get(op->ptr, "action");
-       
-       switch (action) {
-               case SEL_TOGGLE:
-                       EDBM_select_toggle_all(em);
-                       break;
-               case SEL_SELECT:
-                       EDBM_flag_enable_all(em, BM_ELEM_SELECT);
-                       break;
-               case SEL_DESELECT:
-                       EDBM_flag_disable_all(em, BM_ELEM_SELECT);
-                       break;
-               case SEL_INVERT:
-                       EDBM_select_swap(em);
-                       EDBM_selectmode_flush(em);
-                       break;
-       }
-
-       WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit);
-
-       return OPERATOR_FINISHED;
-}
-
-void MESH_OT_select_all(wmOperatorType *ot)
-{
-       /* identifiers */
-       ot->name = "(De)select All";
-       ot->idname = "MESH_OT_select_all";
-       ot->description = "(De)select all vertices, edges or faces";
-       
-       /* api callbacks */
-       ot->exec = edbm_select_all_exec;
-       ot->poll = ED_operator_editmesh;
-       
-       /* flags */
-       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
-
-       WM_operator_properties_select_all(ot);
-}
-
-static int edbm_faces_select_interior_exec(bContext *C, wmOperator *UNUSED(op))
-{
-       Object *obedit = CTX_data_edit_object(C);
-       BMEditMesh *em = BMEdit_FromObject(obedit);
-
-       if (EDBM_select_interior_faces(em)) {
-               WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit);
-
-               return OPERATOR_FINISHED;
-       }
-       else {
-               return OPERATOR_CANCELLED;
-       }
-
-}
-
-void MESH_OT_select_interior_faces(wmOperatorType *ot)
-{
-       /* identifiers */
-       ot->name = "Select Interior Faces";
-       ot->idname = "MESH_OT_select_interior_faces";
-       ot->description = "Select faces where all edges have more than 2 face users";
-
-       /* api callbacks */
-       ot->exec = edbm_faces_select_interior_exec;
-       ot->poll = ED_operator_editmesh;
-
-       /* flags */
-       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
-}
-
-/* *************** add-click-mesh (extrude) operator ************** */
-static int edbm_dupli_extrude_cursor_invoke(bContext *C, wmOperator *op, const wmEvent *event)
-{
-       ViewContext vc;
-       BMVert *v1;
-       BMIter iter;
-       float min[3], max[3];
-       bool done = false;
-       bool use_proj;
-       
-       em_setup_viewcontext(C, &vc);
-
-       ED_view3d_init_mats_rv3d(vc.obedit, vc.rv3d);
-
-
-       use_proj = ((vc.scene->toolsettings->snap_flag & SCE_SNAP) &&
-                   (vc.scene->toolsettings->snap_mode == SCE_SNAP_MODE_FACE));
-
-       INIT_MINMAX(min, max);
-       
-       BM_ITER_MESH (v1, &iter, vc.em->bm, BM_VERTS_OF_MESH) {
-               if (BM_elem_flag_test(v1, BM_ELEM_SELECT)) {
-                       minmax_v3v3_v3(min, max, v1->co);
-                       done = true;
-               }
-       }
-
-       /* call extrude? */
-       if (done) {
-               const bool rot_src = RNA_boolean_get(op->ptr, "rotate_source");
-               BMEdge *eed;
-               float vec[3], cent[3], mat[3][3];
-               float nor[3] = {0.0, 0.0, 0.0};
-
-               /* 2D normal calc */
-               const float mval_f[2] = {(float)event->mval[0],
-                                        (float)event->mval[1]};
-
-               /* check for edges that are half selected, use for rotation */
-               done = false;
-               BM_ITER_MESH (eed, &iter, vc.em->bm, BM_EDGES_OF_MESH) {
-                       if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) {
-                               float co1[2], co2[2];
-
-                               if ((ED_view3d_project_float_object(vc.ar, eed->v1->co, co1, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK) &&
-                                   (ED_view3d_project_float_object(vc.ar, eed->v2->co, co2, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK))
-                               {
-                                       /* 2D rotate by 90d while adding.
-                                        *  (x, y) = (y, -x)
-                                        *
-                                        * accumulate the screenspace normal in 2D,
-                                        * with screenspace edge length weighting the result. */
-                                       if (line_point_side_v2(co1, co2, mval_f) >= 0.0f) {
-                                               nor[0] +=  (co1[1] - co2[1]);
-                                               nor[1] += -(co1[0] - co2[0]);
-                                       }
-                                       else {
-                                               nor[0] +=  (co2[1] - co1[1]);
-                                               nor[1] += -(co2[0] - co1[0]);
-                                       }
-                                       done = true;
-                               }
-                       }
-               }
-
-               if (done) {
-                       float view_vec[3], cross[3];
-
-                       /* convert the 2D nomal into 3D */
-                       mul_mat3_m4_v3(vc.rv3d->viewinv, nor); /* worldspace */
-                       mul_mat3_m4_v3(vc.obedit->imat, nor); /* local space */
-
-                       /* correct the normal to be aligned on the view plane */
-                       copy_v3_v3(view_vec, vc.rv3d->viewinv[2]);
-                       mul_mat3_m4_v3(vc.obedit->imat, view_vec);
-                       cross_v3_v3v3(cross, nor, view_vec);
-                       cross_v3_v3v3(nor, view_vec, cross);
-                       normalize_v3(nor);
-               }
-               
-               /* center */
-               mid_v3_v3v3(cent, min, max);
-               copy_v3_v3(min, cent);
-
-               mul_m4_v3(vc.obedit->obmat, min);  /* view space */
-               ED_view3d_win_to_3d_int(vc.ar, min, event->mval, min);
-               mul_m4_v3(vc.obedit->imat, min); // back in object space
-
-               sub_v3_v3(min, cent);
-               
-               /* calculate rotation */
-               unit_m3(mat);
-               if (done) {
-                       float angle;
-
-                       normalize_v3_v3(vec, min);
-
-                       angle = angle_normalized_v3v3(vec, nor);
-
-                       if (angle != 0.0f) {
-                               float axis[3];
-
-                               cross_v3_v3v3(axis, nor, vec);
-
-                               /* halve the rotation if its applied twice */
-                               if (rot_src) {
-                                       angle *= 0.5f;
-                               }
-
-                               axis_angle_to_mat3(mat, axis, angle);
-                       }
-               }
-               
-               if (rot_src) {
-                       EDBM_op_callf(vc.em, op, "rotate verts=%hv cent=%v matrix=%m3",
-                                     BM_ELEM_SELECT, cent, mat);
-
-                       /* also project the source, for retopo workflow */
-                       if (use_proj)
-                               EMBM_project_snap_verts(C, vc.ar, vc.em);
-               }
-
-               edbm_extrude_edge(vc.obedit, vc.em, BM_ELEM_SELECT, nor);
-               EDBM_op_callf(vc.em, op, "rotate verts=%hv cent=%v matrix=%m3",
-                             BM_ELEM_SELECT, cent, mat);
-               EDBM_op_callf(vc.em, op, "translate verts=%hv vec=%v",
-                             BM_ELEM_SELECT, min);
-       }
-       else {
-               const float *curs = give_cursor(vc.scene, vc.v3d);
-               BMOperator bmop;
-               BMOIter oiter;
-               
-               copy_v3_v3(min, curs);
-               ED_view3d_win_to_3d_int(vc.ar, min, event->mval, min);
-
-               invert_m4_m4(vc.obedit->imat, vc.obedit->obmat);
-               mul_m4_v3(vc.obedit->imat, min); // back in object space
-               
-               EDBM_op_init(vc.em, &bmop, op, "create_vert co=%v", min);
-               BMO_op_exec(vc.em->bm, &bmop);
-
-               BMO_ITER (v1, &oiter, bmop.slots_out, "vert.out", BM_VERT) {
-                       BM_vert_select_set(vc.em->bm, v1, true);
-               }
-
-               if (!EDBM_op_finish(vc.em, &bmop, op, true)) {
-                       return OPERATOR_CANCELLED;
-               }
-       }
-
-       if (use_proj)
-               EMBM_project_snap_verts(C, vc.ar, vc.em);
-
-       /* This normally happens when pushing undo but modal operators
-        * like this one don't push undo data until after modal mode is
-        * done. */
-       EDBM_mesh_normals_update(vc.em);
-
-       EDBM_update_generic(vc.em, true, true);
-
-       return OPERATOR_FINISHED;
-}
-
-void MESH_OT_dupli_extrude_cursor(wmOperatorType *ot)
-{
-       /* identifiers */
-       ot->name = "Duplicate or Extrude at 3D Cursor";
-       ot->idname = "MESH_OT_dupli_extrude_cursor";
-       ot->description = "Duplicate and extrude selected vertices, edges or faces towards the mouse cursor";
-       
-       /* api callbacks */
-       ot->invoke = edbm_dupli_extrude_cursor_invoke;
-       ot->poll = ED_operator_editmesh;
-       
-       /* flags */
-       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
-
-       RNA_def_boolean(ot->srna, "rotate_source", 1, "Rotate Source", "Rotate initial selection giving better shape");
-}
-
-/* Note, these values must match delete_mesh() event values */
-static EnumPropertyItem prop_mesh_delete_types[] = {
-       {0, "VERT",      0, "Vertices", ""},
-       {1,  "EDGE",      0, "Edges", ""},
-       {2,  "FACE",      0, "Faces", ""},
-       {3,  "EDGE_FACE", 0, "Only Edges & Faces", ""},
-       {4,  "ONLY_FACE", 0, "Only Faces", ""},
-       {0, NULL, 0, NULL, NULL}
-};
-
-static int edbm_delete_exec(bContext *C, wmOperator *op)
-{
-       Object *obedit = CTX_data_edit_object(C);
-       BMEditMesh *em = BMEdit_FromObject(obedit);
-       const int type = RNA_enum_get(op->ptr, "type");
-
-       if (type == 0) {
-               if (!EDBM_op_callf(em, op, "delete geom=%hv context=%i", BM_ELEM_SELECT, DEL_VERTS)) /* Erase Vertices */
-                       return OPERATOR_CANCELLED;
-       }
-       else if (type == 1) {
-               if (!EDBM_op_callf(em, op, "delete geom=%he context=%i", BM_ELEM_SELECT, DEL_EDGES)) /* Erase Edges */
-                       return OPERATOR_CANCELLED;
-       }
-       else if (type == 2) {
-               if (!EDBM_op_callf(em, op, "delete geom=%hf context=%i", BM_ELEM_SELECT, DEL_FACES)) /* Erase Faces */
-                       return OPERATOR_CANCELLED;
-       }
-       else if (type == 3) {
-               if (!EDBM_op_callf(em, op, "delete geom=%hef context=%i", BM_ELEM_SELECT, DEL_EDGESFACES)) /* Edges and Faces */
-                       return OPERATOR_CANCELLED;
-       }
-       else if (type == 4) {
-               //"Erase Only Faces";
-               if (!EDBM_op_callf(em, op, "delete geom=%hf context=%i",
-                                  BM_ELEM_SELECT, DEL_ONLYFACES))
-               {
-                       return OPERATOR_CANCELLED;
-               }
-       }
-
-       EDBM_flag_disable_all(em, BM_ELEM_SELECT);
-
-       EDBM_update_generic(em, true, true);
-       
-       return OPERATOR_FINISHED;
-}
-
-void MESH_OT_delete(wmOperatorType *ot)
-{
-       /* identifiers */
-       ot->name = "Delete";
-       ot->description = "Delete selected vertices, edges or faces";
-       ot->idname = "MESH_OT_delete";
-       
-       /* api callbacks */
-       ot->invoke = WM_menu_invoke;
-       ot->exec = edbm_delete_exec;
-       
-       ot->poll = ED_operator_editmesh;
-       
-       /* flags */
-       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
-
-       /* props */
-       ot->prop = RNA_def_enum(ot->srna, "type", prop_mesh_delete_types, 0, "Type", "Method used for deleting mesh data");
-}
-
-static int edbm_collapse_edge_exec(bContext *C, wmOperator *op)
-{
-       Object *obedit = CTX_data_edit_object(C);
-       BMEditMesh *em = BMEdit_FromObject(obedit);
-
-       if (!EDBM_op_callf(em, op, "collapse edges=%he", BM_ELEM_SELECT))
-               return OPERATOR_CANCELLED;
-
-       EDBM_update_generic(em, true, true);
-
-       return OPERATOR_FINISHED;
-}
-
-void MESH_OT_edge_collapse(wmOperatorType *ot)
-{
-       /* identifiers */
-       ot->name = "Edge Collapse";
-       ot->description = "Collapse selected edges";
-       ot->idname = "MESH_OT_edge_collapse";
-
-       /* api callbacks */
-       ot->exec = edbm_collapse_edge_exec;
-       ot->poll = ED_operator_editmesh;
-
-       /* flags */
-       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
-}
-
-static int edbm_collapse_edge_loop_exec(bContext *C, wmOperator *op)
-{
-       Object *obedit = CTX_data_edit_object(C);
-       BMEditMesh *em = BMEdit_FromObject(obedit);
-
-       if (!EDBM_op_callf(em, op, "dissolve_edge_loop edges=%he", BM_ELEM_SELECT))
-               return OPERATOR_CANCELLED;
-
-       EDBM_update_generic(em, true, true);
-
-       return OPERATOR_FINISHED;
-}
-
-void MESH_OT_edge_collapse_loop(wmOperatorType *ot)
-{
-       /* identifiers */
-       ot->name = "Edge Collapse Loop";
-       ot->description = "Collapse selected edge loops";
-       ot->idname = "MESH_OT_edge_collapse_loop";
-
-       /* api callbacks */
-       ot->exec = edbm_collapse_edge_loop_exec;
-       ot->poll = ED_operator_editmesh;
-
-       /* flags */
-       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
-}
-
-static int edbm_add_edge_face__smooth_get(BMesh *bm)
-{
-       BMEdge *e;
-       BMIter iter;
-
-       unsigned int vote_on_smooth[2] = {0, 0};
-
-       BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
-               if (BM_elem_flag_test(e, BM_ELEM_SELECT) && e->l) {
-                       vote_on_smooth[BM_elem_flag_test_bool(e->l->f, BM_ELEM_SMOOTH)]++;
-               }
-       }
-
-       return (vote_on_smooth[0] < vote_on_smooth[1]);
+       return (vote_on_smooth[0] < vote_on_smooth[1]);
 }
 
 #ifdef USE_FACE_CREATE_SEL_EXTEND
@@ -2013,7 +1265,6 @@ static int edbm_rotate_uvs_exec(bContext *C, wmOperator *op)
 
        EDBM_update_generic(em, false, false);
 
-       /* we succeeded */
        return OPERATOR_FINISHED;
 }
 
@@ -2036,7 +1287,6 @@ static int edbm_reverse_uvs_exec(bContext *C, wmOperator *op)
 
        EDBM_update_generic(em, false, false);
 
-       /* we succeeded */
        return OPERATOR_FINISHED;
 }
 
@@ -2063,7 +1313,6 @@ static int edbm_rotate_colors_exec(bContext *C, wmOperator *op)
        /* dependencies graph and notification stuff */
        EDBM_update_generic(em, false, false);
 
-       /* we succeeded */
        return OPERATOR_FINISHED;
 }
 
@@ -2087,7 +1336,6 @@ static int edbm_reverse_colors_exec(bContext *C, wmOperator *op)
 
        EDBM_update_generic(em, false, false);
 
-       /* we succeeded */
        return OPERATOR_FINISHED;
 }
 
@@ -2109,7 +1357,6 @@ void MESH_OT_uvs_rotate(wmOperatorType *ot)
        RNA_def_boolean(ot->srna, "use_ccw", false, "Counter Clockwise", "");
 }
 
-//void MESH_OT_uvs_mirror(wmOperatorType *ot)
 void MESH_OT_uvs_reverse(wmOperatorType *ot)
 {
        /* identifiers */
@@ -2427,125 +1674,8 @@ void MESH_OT_remove_doubles(wmOperatorType *ot)
        RNA_def_boolean(ot->srna, "use_unselected", 0, "Unselected", "Merge selected to other unselected vertices");
 }
 
-/************************ Vertex Path Operator *************************/
 
-typedef struct PathNode {
-       /* int u; */       /* UNUSED */
-       /* int visited; */ /* UNUSED */
-       ListBase edges;
-} PathNode;
-
-typedef struct PathEdge {
-       struct PathEdge *next, *prev;
-       int v;
-       float w;
-} PathEdge;
-
-
-
-static int edbm_select_vertex_path_exec(bContext *C, wmOperator *op)
-{
-       Object *ob = CTX_data_edit_object(C);
-       BMEditMesh *em = BMEdit_FromObject(ob);
-       BMOperator bmop;
-       BMIter iter;
-       BMVert *eve = NULL, *svert = NULL, *evert = NULL;
-       BMEditSelection *sv, *ev;
-
-       /* get the type from RNA */
-       const int type = RNA_enum_get(op->ptr, "type");
-
-       /* first try to find vertices in edit selection */
-       sv = em->bm->selected.last;
-       if (sv != NULL) {
-               ev = sv->prev;
-
-               if (ev && (sv->htype == BM_VERT) && (ev->htype == BM_VERT)) {
-                       svert = (BMVert *)sv->ele;
-                       evert = (BMVert *)ev->ele;
-               }
-       }
-
-       /* if those are not found, because vertices where selected by e.g.
-        * border or circle select, find two selected vertices */
-       if (svert == NULL) {
-               BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
-                       if (!BM_elem_flag_test(eve, BM_ELEM_SELECT) || BM_elem_flag_test(eve, BM_ELEM_HIDDEN))
-                               continue;
-
-                       if (svert == NULL) {
-                               svert = eve;
-                       }
-                       else if (evert == NULL) {
-                               evert = eve;
-                       }
-                       else {
-                               /* more than two vertices are selected,
-                                * show warning message and cancel operator */
-                               svert = evert = NULL;
-                               break;
-                       }
-               }
-       }
-
-       if (svert == NULL || evert == NULL) {
-               BKE_report(op->reports, RPT_WARNING, "Path selection requires two vertices to be selected");
-               return OPERATOR_CANCELLED;
-       }
-
-       /* initialize the bmop using EDBM api, which does various ui error reporting and other stuff */
-       EDBM_op_init(em, &bmop, op,
-                    "shortest_path vert_start=%e vert_end=%e type=%i",
-                    svert, evert, type);
-
-       /* execute the operator */
-       BMO_op_exec(em->bm, &bmop);
-
-       /* DO NOT clear the existing selection */
-       /* EDBM_flag_disable_all(em, BM_ELEM_SELECT); */
-
-       /* select the output */
-       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "verts.out", BM_VERT, BM_ELEM_SELECT, true);
-
-       /* finish the operator */
-       if (!EDBM_op_finish(em, &bmop, op, true)) {
-               return OPERATOR_CANCELLED;
-       }
-
-       EDBM_selectmode_flush(em);
-
-       EDBM_update_generic(em, false, false);
-
-       /* we succeeded */
-       return OPERATOR_FINISHED;
-}
-
-void MESH_OT_select_vertex_path(wmOperatorType *ot)
-{
-       static const EnumPropertyItem type_items[] = {
-               {VPATH_SELECT_EDGE_LENGTH, "EDGE_LENGTH", 0, "Edge Length", NULL},
-               {VPATH_SELECT_TOPOLOGICAL, "TOPOLOGICAL", 0, "Topological", NULL},
-               {0, NULL, 0, NULL, NULL}
-       };
-
-       /* identifiers */
-       ot->name = "Select Vertex Path";
-       ot->idname = "MESH_OT_select_vertex_path";
-       ot->description = "Selected vertex path between two vertices";
-
-       /* api callbacks */
-       ot->exec = edbm_select_vertex_path_exec;
-       ot->poll = ED_operator_editmesh;
-
-       /* flags */
-       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
-
-       /* properties */
-       RNA_def_enum(ot->srna, "type", type_items, VPATH_SELECT_EDGE_LENGTH, "Type", "Method to compute distance");
-}
-/********************** Rip Operator *************************/
-
-/************************ Shape Operators *************************/
+/************************ Shape Operators *************************/
 
 /* BMESH_TODO this should be properly encapsulated in a bmop.  but later.*/
 static void shape_propagate(BMEditMesh *em, wmOperator *op)
@@ -2739,89 +1869,6 @@ void MESH_OT_blend_from_shape(wmOperatorType *ot)
        RNA_def_boolean(ot->srna, "add", 1, "Add", "Add rather than blend between shapes");
 }
 
-/* BMESH_TODO - some way to select on an arbitrary axis */
-static int edbm_select_axis_exec(bContext *C, wmOperator *op)
-{
-       Object *obedit = CTX_data_edit_object(C);
-       BMEditMesh *em = BMEdit_FromObject(obedit);
-       BMEditSelection *ese = em->bm->selected.last;
-       const int axis = RNA_enum_get(op->ptr, "axis");
-       const int mode = RNA_enum_get(op->ptr, "mode"); /* -1 == aligned, 0 == neg, 1 == pos */
-
-       if (ese == NULL || ese->htype != BM_VERT) {
-               BKE_report(op->reports, RPT_WARNING, "This operator requires an active vertex (last selected)");
-               return OPERATOR_CANCELLED;
-       }
-       else {
-               BMVert *ev, *act_vert = (BMVert *)ese->ele;
-               BMIter iter;
-               float value = act_vert->co[axis];
-               float limit =  CTX_data_tool_settings(C)->doublimit; // XXX
-
-               if (mode == 0)
-                       value -= limit;
-               else if (mode == 1)
-                       value += limit;
-
-               BM_ITER_MESH (ev, &iter, em->bm, BM_VERTS_OF_MESH) {
-                       if (!BM_elem_flag_test(ev, BM_ELEM_HIDDEN)) {
-                               switch (mode) {
-                                       case -1: /* aligned */
-                                               if (fabsf(ev->co[axis] - value) < limit)
-                                                       BM_vert_select_set(em->bm, ev, true);
-                                               break;
-                                       case 0: /* neg */
-                                               if (ev->co[axis] > value)
-                                                       BM_vert_select_set(em->bm, ev, true);
-                                               break;
-                                       case 1: /* pos */
-                                               if (ev->co[axis] < value)
-                                                       BM_vert_select_set(em->bm, ev, true);
-                                               break;
-                               }
-                       }
-               }
-       }
-
-       EDBM_selectmode_flush(em);
-       WM_event_add_notifier(C, NC_GEOM | ND_DATA, obedit->data);
-
-       return OPERATOR_FINISHED;
-}
-
-void MESH_OT_select_axis(wmOperatorType *ot)
-{
-       static EnumPropertyItem axis_mode_items[] = {
-               {0,  "POSITIVE", 0, "Positive Axis", ""},
-               {1,  "NEGATIVE", 0, "Negative Axis", ""},
-               {-1, "ALIGNED",  0, "Aligned Axis", ""},
-               {0, NULL, 0, NULL, NULL}
-       };
-
-       static EnumPropertyItem axis_items_xyz[] = {
-               {0, "X_AXIS", 0, "X Axis", ""},
-               {1, "Y_AXIS", 0, "Y Axis", ""},
-               {2, "Z_AXIS", 0, "Z Axis", ""},
-               {0, NULL, 0, NULL, NULL}
-       };
-
-       /* identifiers */
-       ot->name = "Select Axis";
-       ot->description = "Select all data in the mesh on a single axis";
-       ot->idname = "MESH_OT_select_axis";
-
-       /* api callbacks */
-       ot->exec = edbm_select_axis_exec;
-       ot->poll = ED_operator_editmesh;
-
-       /* flags */
-       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
-
-       /* properties */
-       RNA_def_enum(ot->srna, "mode", axis_mode_items, 0, "Axis Mode", "Axis side to use when selecting");
-       RNA_def_enum(ot->srna, "axis", axis_items_xyz, 0, "Axis", "Select the axis to compare each vertex on");
-}
-
 static int edbm_solidify_exec(bContext *C, wmOperator *op)
 {
        Object *obedit = CTX_data_edit_object(C);
@@ -3196,7 +2243,7 @@ void MESH_OT_knife_cut(wmOperatorType *ot)
        ot->modal = WM_gesture_lines_modal;
        ot->exec = edbm_knife_cut_exec;
        
-       ot->poll = EM_view3d_poll;
+       ot->poll = EDBM_view3d_poll;
        
        /* flags */
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
@@ -3841,507 +2888,147 @@ void MESH_OT_split(wmOperatorType *ot)
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 }
 
+/******************************************************************************
+ * qsort routines.
+ * Now unified, for vertices/edges/faces. */
 
-static int edbm_spin_exec(bContext *C, wmOperator *op)
-{
-       Object *obedit = CTX_data_edit_object(C);
-       BMEditMesh *em = BMEdit_FromObject(obedit);
-       BMesh *bm = em->bm;
-       BMOperator spinop;
-       float cent[3], axis[3], imat[3][3];
-       float d[3] = {0.0f, 0.0f, 0.0f};
-       int steps, dupli;
-       float angle;
-
-       RNA_float_get_array(op->ptr, "center", cent);
-       RNA_float_get_array(op->ptr, "axis", axis);
-       steps = RNA_int_get(op->ptr, "steps");
-       angle = RNA_float_get(op->ptr, "angle");
-       //if (ts->editbutflag & B_CLOCKWISE)
-       angle = -angle;
-       dupli = RNA_boolean_get(op->ptr, "dupli");
-
-       /* undo object transformation */
-       copy_m3_m4(imat, obedit->imat);
-       sub_v3_v3(cent, obedit->obmat[3]);
-       mul_m3_v3(imat, cent);
-       mul_m3_v3(imat, axis);
-
-       if (!EDBM_op_init(em, &spinop, op,
-                         "spin geom=%hvef cent=%v axis=%v dvec=%v steps=%i angle=%f use_duplicate=%b",
-                         BM_ELEM_SELECT, cent, axis, d, steps, angle, dupli))
-       {
-               return OPERATOR_CANCELLED;
-       }
-       BMO_op_exec(bm, &spinop);
-       EDBM_flag_disable_all(em, BM_ELEM_SELECT);
-       BMO_slot_buffer_hflag_enable(bm, spinop.slots_out, "geom_last.out", BM_ALL_NOLOOP, BM_ELEM_SELECT, true);
-       if (!EDBM_op_finish(em, &spinop, op, true)) {
-               return OPERATOR_CANCELLED;
-       }
-
-       EDBM_update_generic(em, true, true);
+enum {
+       SRT_VIEW_ZAXIS = 1,  /* Use view Z (deep) axis. */
+       SRT_VIEW_XAXIS,      /* Use view X (left to right) axis. */
+       SRT_CURSOR_DISTANCE, /* Use distance from element to 3D cursor. */
+       SRT_MATERIAL,        /* Face only: use mat number. */
+       SRT_SELECTED,        /* Move selected elements in first, without modifying 
+                             * relative order of selected and unselected elements. */
+       SRT_RANDOMIZE,       /* Randomize selected elements. */
+       SRT_REVERSE,         /* Reverse current order of selected elements. */
+};
 
-       return OPERATOR_FINISHED;
-}
+typedef struct BMElemSort {
+       float srt; /* Sort factor */
+       int org_idx; /* Original index of this element _in its mempool_ */
+} BMElemSort;
 
-/* get center and axis, in global coords */
-static int edbm_spin_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
+static int bmelemsort_comp(const void *v1, const void *v2)
 {
-       Scene *scene = CTX_data_scene(C);
-       View3D *v3d = CTX_wm_view3d(C);
-       RegionView3D *rv3d = ED_view3d_context_rv3d(C);
-
-       RNA_float_set_array(op->ptr, "center", give_cursor(scene, v3d));
-       RNA_float_set_array(op->ptr, "axis", rv3d->viewinv[2]);
+       const BMElemSort *x1 = v1, *x2 = v2;
 
-       return edbm_spin_exec(C, op);
+       return (x1->srt > x2->srt) - (x1->srt < x2->srt);
 }
 
-void MESH_OT_spin(wmOperatorType *ot)
+/* Reorders vertices/edges/faces using a given methods. Loops are not supported. */
+static void sort_bmelem_flag(Scene *scene, Object *ob,
+                             View3D *v3d, RegionView3D *rv3d,
+                             const int types, const int flag, const int action,
+                             const int reverse, const unsigned int seed)
 {
-       PropertyRNA *prop;
-
-       /* identifiers */
-       ot->name = "Spin";
-       ot->description = "Extrude selected vertices in a circle around the cursor in indicated viewport";
-       ot->idname = "MESH_OT_spin";
+       BMEditMesh *em = BMEdit_FromObject(ob);
 
-       /* api callbacks */
-       ot->invoke = edbm_spin_invoke;
-       ot->exec = edbm_spin_exec;
-       ot->poll = EM_view3d_poll;
+       BMVert *ve;
+       BMEdge *ed;
+       BMFace *fa;
+       BMIter iter;
 
-       /* flags */
-       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+       /* In all five elements below, 0 = vertices, 1 = edges, 2 = faces. */
+       /* Just to mark protected elements. */
+       char *pblock[3] = {NULL, NULL, NULL}, *pb;
+       BMElemSort *sblock[3] = {NULL, NULL, NULL}, *sb;
+       int *map[3] = {NULL, NULL, NULL}, *mp;
+       int totelem[3] = {0, 0, 0};
+       int affected[3] = {0, 0, 0};
+       int i, j;
 
-       /* props */
-       RNA_def_int(ot->srna, "steps", 9, 0, INT_MAX, "Steps", "Steps", 0, INT_MAX);
-       RNA_def_boolean(ot->srna, "dupli", 0, "Dupli", "Make Duplicates");
-       prop = RNA_def_float(ot->srna, "angle", DEG2RADF(90.0f), -FLT_MAX, FLT_MAX, "Angle", "Angle", DEG2RADF(-360.0f), DEG2RADF(360.0f));
-       RNA_def_property_subtype(prop, PROP_ANGLE);
+       if (!(types && flag && action))
+               return;
 
-       RNA_def_float_vector(ot->srna, "center", 3, NULL, -FLT_MAX, FLT_MAX, "Center", "Center in global view space", -FLT_MAX, FLT_MAX);
-       RNA_def_float_vector(ot->srna, "axis", 3, NULL, -FLT_MAX, FLT_MAX, "Axis", "Axis in global view space", -1.0f, 1.0f);
+       if (types & BM_VERT)
+               totelem[0] = em->bm->totvert;
+       if (types & BM_EDGE)
+               totelem[1] = em->bm->totedge;
+       if (types & BM_FACE)
+               totelem[2] = em->bm->totface;
 
-}
+       if (ELEM(action, SRT_VIEW_ZAXIS, SRT_VIEW_XAXIS)) {
+               float mat[4][4];
+               float fact = reverse ? -1.0 : 1.0;
+               int coidx = (action == SRT_VIEW_ZAXIS) ? 2 : 0;
 
-static int edbm_screw_exec(bContext *C, wmOperator *op)
-{
-       Object *obedit = CTX_data_edit_object(C);
-       BMEditMesh *em = BMEdit_FromObject(obedit);
-       BMesh *bm = em->bm;
-       BMEdge *eed;
-       BMVert *eve, *v1, *v2;
-       BMIter iter, eiter;
-       BMOperator spinop;
-       float dvec[3], nor[3], cent[3], axis[3];
-       float imat[3][3];
-       int steps, turns;
-       int valence;
+               mult_m4_m4m4(mat, rv3d->viewmat, ob->obmat);  /* Apply the view matrix to the object matrix. */
 
+               if (totelem[0]) {
+                       pb = pblock[0] = MEM_callocN(sizeof(char) * totelem[0], "sort_bmelem vert pblock");
+                       sb = sblock[0] = MEM_callocN(sizeof(BMElemSort) * totelem[0], "sort_bmelem vert sblock");
 
-       turns = RNA_int_get(op->ptr, "turns");
-       steps = RNA_int_get(op->ptr, "steps");
-       RNA_float_get_array(op->ptr, "center", cent);
-       RNA_float_get_array(op->ptr, "axis", axis);
+                       BM_ITER_MESH_INDEX (ve, &iter, em->bm, BM_VERTS_OF_MESH, i) {
+                               if (BM_elem_flag_test(ve, flag)) {
+                                       float co[3];
+                                       mul_v3_m4v3(co, mat, ve->co);
 
-       /* undo object transformation */
-       copy_m3_m4(imat, obedit->imat);
-       sub_v3_v3(cent, obedit->obmat[3]);
-       mul_m3_v3(imat, cent);
-       mul_m3_v3(imat, axis);
+                                       pb[i] = false;
+                                       sb[affected[0]].org_idx = i;
+                                       sb[affected[0]++].srt = co[coidx] * fact;
+                               }
+                               else {
+                                       pb[i] = true;
+                               }
+                       }
+               }
 
+               if (totelem[1]) {
+                       pb = pblock[1] = MEM_callocN(sizeof(char) * totelem[1], "sort_bmelem edge pblock");
+                       sb = sblock[1] = MEM_callocN(sizeof(BMElemSort) * totelem[1], "sort_bmelem edge sblock");
 
-       /* find two vertices with valence count == 1, more or less is wrong */
-       v1 = NULL;
-       v2 = NULL;
+                       BM_ITER_MESH_INDEX (ed, &iter, em->bm, BM_EDGES_OF_MESH, i) {
+                               if (BM_elem_flag_test(ed, flag)) {
+                                       float co[3];
+                                       mid_v3_v3v3(co, ed->v1->co, ed->v2->co);
+                                       mul_m4_v3(mat, co);
 
-       BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
-               valence = 0;
-               BM_ITER_ELEM (eed, &eiter, eve, BM_EDGES_OF_VERT) {
-                       if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) {
-                               valence++;
+                                       pb[i] = false;
+                                       sb[affected[1]].org_idx = i;
+                                       sb[affected[1]++].srt = co[coidx] * fact;
+                               }
+                               else {
+                                       pb[i] = true;
+                               }
                        }
                }
 
-               if (valence == 1) {
-                       if (v1 == NULL) {
-                               v1 = eve;
-                       }
-                       else if (v2 == NULL) {
-                               v2 = eve;
-                       }
-                       else {
-                               v1 = NULL;
-                               break;
+               if (totelem[2]) {
+                       pb = pblock[2] = MEM_callocN(sizeof(char) * totelem[2], "sort_bmelem face pblock");
+                       sb = sblock[2] = MEM_callocN(sizeof(BMElemSort) * totelem[2], "sort_bmelem face sblock");
+
+                       BM_ITER_MESH_INDEX (fa, &iter, em->bm, BM_FACES_OF_MESH, i) {
+                               if (BM_elem_flag_test(fa, flag)) {
+                                       float co[3];
+                                       BM_face_calc_center_mean(fa, co);
+                                       mul_m4_v3(mat, co);
+
+                                       pb[i] = false;
+                                       sb[affected[2]].org_idx = i;
+                                       sb[affected[2]++].srt = co[coidx] * fact;
+                               }
+                               else {
+                                       pb[i] = true;
+                               }
                        }
                }
        }
 
-       if (v1 == NULL || v2 == NULL) {
-               BKE_report(op->reports, RPT_ERROR, "You have to select a string of connected vertices too");
-               return OPERATOR_CANCELLED;
-       }
+       else if (action == SRT_CURSOR_DISTANCE) {
+               float cur[3];
+               float mat[4][4];
+               float fact = reverse ? -1.0 : 1.0;
 
-       /* calculate dvec */
-       sub_v3_v3v3(dvec, v1->co, v2->co);
-       mul_v3_fl(dvec, 1.0f / steps);
+               if (v3d && v3d->localvd)
+                       copy_v3_v3(cur, v3d->cursor);
+               else
+                       copy_v3_v3(cur, scene->cursor);
+               invert_m4_m4(mat, ob->obmat);
+               mul_m4_v3(mat, cur);
 
-       if (dot_v3v3(nor, dvec) > 0.000f)
-               negate_v3(dvec);
-
-       if (!EDBM_op_init(em, &spinop, op,
-                         "spin geom=%hvef cent=%v axis=%v dvec=%v steps=%i angle=%f use_duplicate=%b",
-                         BM_ELEM_SELECT, cent, axis, dvec, turns * steps, DEG2RADF(360.0f * turns), false))
-       {
-               return OPERATOR_CANCELLED;
-       }
-       BMO_op_exec(bm, &spinop);
-       EDBM_flag_disable_all(em, BM_ELEM_SELECT);
-       BMO_slot_buffer_hflag_enable(bm, spinop.slots_out, "geom_last.out", BM_ALL_NOLOOP, BM_ELEM_SELECT, true);
-       if (!EDBM_op_finish(em, &spinop, op, true)) {
-               return OPERATOR_CANCELLED;
-       }
-
-       EDBM_update_generic(em, true, true);
-
-       return OPERATOR_FINISHED;
-}
-
-/* get center and axis, in global coords */
-static int edbm_screw_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
-{
-       Scene *scene = CTX_data_scene(C);
-       View3D *v3d = CTX_wm_view3d(C);
-       RegionView3D *rv3d = ED_view3d_context_rv3d(C);
-
-       RNA_float_set_array(op->ptr, "center", give_cursor(scene, v3d));
-       RNA_float_set_array(op->ptr, "axis", rv3d->viewinv[1]);
-
-       return edbm_screw_exec(C, op);
-}
-
-void MESH_OT_screw(wmOperatorType *ot)
-{
-       /* identifiers */
-       ot->name = "Screw";
-       ot->description = "Extrude selected vertices in screw-shaped rotation around the cursor in indicated viewport";
-       ot->idname = "MESH_OT_screw";
-
-       /* api callbacks */
-       ot->invoke = edbm_screw_invoke;
-       ot->exec = edbm_screw_exec;
-       ot->poll = EM_view3d_poll;
-
-       /* flags */
-       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
-
-       /* props */
-       RNA_def_int(ot->srna, "steps", 9, 1, INT_MAX, "Steps", "Steps", 3, 256);
-       RNA_def_int(ot->srna, "turns", 1, 1, INT_MAX, "Turns", "Turns", 1, 256);
-
-       RNA_def_float_vector(ot->srna, "center", 3, NULL, -FLT_MAX, FLT_MAX,
-                            "Center", "Center in global view space", -FLT_MAX, FLT_MAX);
-       RNA_def_float_vector(ot->srna, "axis", 3, NULL, -FLT_MAX, FLT_MAX,
-                            "Axis", "Axis in global view space", -1.0f, 1.0f);
-}
-
-static int edbm_select_face_by_sides_exec(bContext *C, wmOperator *op)
-{
-       Object *obedit = CTX_data_edit_object(C);
-       BMEditMesh *em = BMEdit_FromObject(obedit);
-       BMFace *efa;
-       BMIter iter;
-       const int numverts = RNA_int_get(op->ptr, "number");
-       const int type = RNA_enum_get(op->ptr, "type");
-
-       if (!RNA_boolean_get(op->ptr, "extend"))
-               EDBM_flag_disable_all(em, BM_ELEM_SELECT);
-
-       BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
-
-               int select;
-
-               switch (type) {
-                       case 0:
-                               select = (efa->len < numverts);
-                               break;
-                       case 1:
-                               select = (efa->len == numverts);
-                               break;
-                       case 2:
-                               select = (efa->len > numverts);
-                               break;
-                       case 3:
-                               select = (efa->len != numverts);
-                               break;
-                       default:
-                               BLI_assert(0);
-                               select = false;
-                               break;
-               }
-
-               if (select) {
-                       BM_face_select_set(em->bm, efa, true);
-               }
-       }
-
-       EDBM_selectmode_flush(em);
-
-       WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit->data);
-       return OPERATOR_FINISHED;
-}
-
-void MESH_OT_select_face_by_sides(wmOperatorType *ot)
-{
-       static const EnumPropertyItem type_items[] = {
-               {0, "LESS", 0, "Less Than", ""},
-               {1, "EQUAL", 0, "Equal To", ""},
-               {2, "GREATER", 0, "Greater Than", ""},
-               {3, "NOTEQUAL", 0, "Not Equal To", ""},
-               {0, NULL, 0, NULL, NULL}
-       };
-
-       /* identifiers */
-       ot->name = "Select Faces by Sides";
-       ot->description = "Select vertices or faces by the number of polygon sides";
-       ot->idname = "MESH_OT_select_face_by_sides";
-       
-       /* api callbacks */
-       ot->exec = edbm_select_face_by_sides_exec;
-       ot->poll = ED_operator_editmesh;
-       
-       /* flags */
-       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
-
-       /* properties */
-       RNA_def_int(ot->srna, "number", 4, 3, INT_MAX, "Number of Vertices", "", 3, INT_MAX);
-       RNA_def_enum(ot->srna, "type", type_items, 1, "Type", "Type of comparison to make");
-       RNA_def_boolean(ot->srna, "extend", true, "Extend", "Extend the selection");
-}
-
-static int edbm_select_loose_verts_exec(bContext *C, wmOperator *op)
-{
-       Object *obedit = CTX_data_edit_object(C);
-       BMEditMesh *em = BMEdit_FromObject(obedit);
-       BMVert *eve;
-       BMEdge *eed;
-       BMIter iter;
-
-       if (!RNA_boolean_get(op->ptr, "extend"))
-               EDBM_flag_disable_all(em, BM_ELEM_SELECT);
-
-       BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
-               if (!eve->e) {
-                       BM_vert_select_set(em->bm, eve, true);
-               }
-       }
-
-       BM_ITER_MESH (eed, &iter, em->bm, BM_EDGES_OF_MESH) {
-               if (!eed->l) {
-                       BM_edge_select_set(em->bm, eed, true);
-               }
-       }
-
-       EDBM_selectmode_flush(em);
-
-       WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit->data);
-       return OPERATOR_FINISHED;
-}
-
-void MESH_OT_select_loose_verts(wmOperatorType *ot)
-{
-       /* identifiers */
-       ot->name = "Select Loose Vertices/Edges";
-       ot->description = "Select vertices with no edges nor faces, and edges with no faces";
-       ot->idname = "MESH_OT_select_loose_verts";
-
-       /* api callbacks */
-       ot->exec = edbm_select_loose_verts_exec;
-       ot->poll = ED_operator_editmesh;
-
-       /* flags */
-       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
-
-       /* props */
-       RNA_def_boolean(ot->srna, "extend", false, "Extend", "Extend the selection");
-}
-
-static int edbm_select_mirror_exec(bContext *C, wmOperator *op)
-{
-       Object *obedit = CTX_data_edit_object(C);
-       BMEditMesh *em = BMEdit_FromObject(obedit);
-       bool extend = RNA_boolean_get(op->ptr, "extend");
-
-       if (em->bm->totvert && em->bm->totvertsel) {
-               EDBM_select_mirrored(obedit, em, extend);
-               EDBM_selectmode_flush(em);
-               WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit->data);
-       }
-
-       return OPERATOR_FINISHED;
-}
-
-void MESH_OT_select_mirror(wmOperatorType *ot)
-{
-       /* identifiers */
-       ot->name = "Select Mirror";
-       ot->description = "Select mesh items at mirrored locations";
-       ot->idname = "MESH_OT_select_mirror";
-
-       /* api callbacks */
-       ot->exec = edbm_select_mirror_exec;
-       ot->poll = ED_operator_editmesh;
-
-       /* flags */
-       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
-
-       /* props */
-       RNA_def_boolean(ot->srna, "extend", 0, "Extend", "Extend the existing selection");
-}
-
-/******************************************************************************
- * qsort routines.
- * Now unified, for vertices/edges/faces. */
-
-enum {
-       SRT_VIEW_ZAXIS = 1,  /* Use view Z (deep) axis. */
-       SRT_VIEW_XAXIS,      /* Use view X (left to right) axis. */
-       SRT_CURSOR_DISTANCE, /* Use distance from element to 3D cursor. */
-       SRT_MATERIAL,        /* Face only: use mat number. */
-       SRT_SELECTED,        /* Move selected elements in first, without modifying 
-                             * relative order of selected and unselected elements. */
-       SRT_RANDOMIZE,       /* Randomize selected elements. */
-       SRT_REVERSE,         /* Reverse current order of selected elements. */
-};
-
-typedef struct BMElemSort {
-       float srt; /* Sort factor */
-       int org_idx; /* Original index of this element _in its mempool_ */
-} BMElemSort;
-
-static int bmelemsort_comp(const void *v1, const void *v2)
-{
-       const BMElemSort *x1 = v1, *x2 = v2;
-
-       return (x1->srt > x2->srt) - (x1->srt < x2->srt);
-}
-
-/* Reorders vertices/edges/faces using a given methods. Loops are not supported. */
-static void sort_bmelem_flag(Scene *scene, Object *ob,
-                             View3D *v3d, RegionView3D *rv3d,
-                             const int types, const int flag, const int action,
-                             const int reverse, const unsigned int seed)
-{
-       BMEditMesh *em = BMEdit_FromObject(ob);
-
-       BMVert *ve;
-       BMEdge *ed;
-       BMFace *fa;
-       BMIter iter;
-
-       /* In all five elements below, 0 = vertices, 1 = edges, 2 = faces. */
-       /* Just to mark protected elements. */
-       char *pblock[3] = {NULL, NULL, NULL}, *pb;
-       BMElemSort *sblock[3] = {NULL, NULL, NULL}, *sb;
-       int *map[3] = {NULL, NULL, NULL}, *mp;
-       int totelem[3] = {0, 0, 0};
-       int affected[3] = {0, 0, 0};
-       int i, j;
-
-       if (!(types && flag && action))
-               return;
-
-       if (types & BM_VERT)
-               totelem[0] = em->bm->totvert;
-       if (types & BM_EDGE)
-               totelem[1] = em->bm->totedge;
-       if (types & BM_FACE)
-               totelem[2] = em->bm->totface;
-
-       if (ELEM(action, SRT_VIEW_ZAXIS, SRT_VIEW_XAXIS)) {
-               float mat[4][4];
-               float fact = reverse ? -1.0 : 1.0;
-               int coidx = (action == SRT_VIEW_ZAXIS) ? 2 : 0;
-
-               mult_m4_m4m4(mat, rv3d->viewmat, ob->obmat);  /* Apply the view matrix to the object matrix. */
-
-               if (totelem[0]) {
-                       pb = pblock[0] = MEM_callocN(sizeof(char) * totelem[0], "sort_bmelem vert pblock");
-                       sb = sblock[0] = MEM_callocN(sizeof(BMElemSort) * totelem[0], "sort_bmelem vert sblock");
-
-                       BM_ITER_MESH_INDEX (ve, &iter, em->bm, BM_VERTS_OF_MESH, i) {
-                               if (BM_elem_flag_test(ve, flag)) {
-                                       float co[3];
-                                       mul_v3_m4v3(co, mat, ve->co);
-
-                                       pb[i] = false;
-                                       sb[affected[0]].org_idx = i;
-                                       sb[affected[0]++].srt = co[coidx] * fact;
-                               }
-                               else {
-                                       pb[i] = true;
-                               }
-                       }
-               }
-
-               if (totelem[1]) {
-                       pb = pblock[1] = MEM_callocN(sizeof(char) * totelem[1], "sort_bmelem edge pblock");
-                       sb = sblock[1] = MEM_callocN(sizeof(BMElemSort) * totelem[1], "sort_bmelem edge sblock");
-
-                       BM_ITER_MESH_INDEX (ed, &iter, em->bm, BM_EDGES_OF_MESH, i) {
-                               if (BM_elem_flag_test(ed, flag)) {
-                                       float co[3];
-                                       mid_v3_v3v3(co, ed->v1->co, ed->v2->co);
-                                       mul_m4_v3(mat, co);
-
-                                       pb[i] = false;
-                                       sb[affected[1]].org_idx = i;
-                                       sb[affected[1]++].srt = co[coidx] * fact;
-                               }
-                               else {
-                                       pb[i] = true;
-                               }
-                       }
-               }
-
-               if (totelem[2]) {
-                       pb = pblock[2] = MEM_callocN(sizeof(char) * totelem[2], "sort_bmelem face pblock");
-                       sb = sblock[2] = MEM_callocN(sizeof(BMElemSort) * totelem[2], "sort_bmelem face sblock");
-
-                       BM_ITER_MESH_INDEX (fa, &iter, em->bm, BM_FACES_OF_MESH, i) {
-                               if (BM_elem_flag_test(fa, flag)) {
-                                       float co[3];
-                                       BM_face_calc_center_mean(fa, co);
-                                       mul_m4_v3(mat, co);
-
-                                       pb[i] = false;
-                                       sb[affected[2]].org_idx = i;
-                                       sb[affected[2]++].srt = co[coidx] * fact;
-                               }
-                               else {
-                                       pb[i] = true;
-                               }
-                       }
-               }
-       }
-
-       else if (action == SRT_CURSOR_DISTANCE) {
-               float cur[3];
-               float mat[4][4];
-               float fact = reverse ? -1.0 : 1.0;
-
-               if (v3d && v3d->localvd)
-                       copy_v3_v3(cur, v3d->cursor);
-               else
-                       copy_v3_v3(cur, scene->cursor);
-               invert_m4_m4(mat, ob->obmat);
-               mul_m4_v3(mat, cur);
-
-               if (totelem[0]) {
-                       pb = pblock[0] = MEM_callocN(sizeof(char) * totelem[0], "sort_bmelem vert pblock");
-                       sb = sblock[0] = MEM_callocN(sizeof(BMElemSort) * totelem[0], "sort_bmelem vert sblock");
+               if (totelem[0]) {
+                       pb = pblock[0] = MEM_callocN(sizeof(char) * totelem[0], "sort_bmelem vert pblock");
+                       sb = sblock[0] = MEM_callocN(sizeof(BMElemSort) * totelem[0], "sort_bmelem vert sblock");
 
                        BM_ITER_MESH_INDEX (ve, &iter, em->bm, BM_VERTS_OF_MESH, i) {
                                if (BM_elem_flag_test(ve, flag)) {
@@ -4749,422 +3436,108 @@ void MESH_OT_sort_elements(wmOperatorType *ot)
                               "(WARNING: this will affect unselected elements' indices as well!)"},
                {SRT_RANDOMIZE, "RANDOMIZE", 0, "Randomize", "Randomize order of selected elements"},
                {SRT_REVERSE, "REVERSE", 0, "Reverse", "Reverse current order of selected elements"},
-               {0, NULL, 0, NULL, NULL},
-       };
-
-       static EnumPropertyItem elem_items[] = {
-               {BM_VERT, "VERT", 0, "Vertices", ""},
-               {BM_EDGE, "EDGE", 0, "Edges", ""},
-               {BM_FACE, "FACE", 0, "Faces", ""},
-               {0, NULL, 0, NULL, NULL},
-       };
-
-       /* identifiers */
-       ot->name = "Sort Mesh Elements";
-       ot->description = "The order of selected vertices/edges/faces is modified, based on a given method";
-       ot->idname = "MESH_OT_sort_elements";
-
-       /* api callbacks */
-       ot->invoke = WM_menu_invoke;
-       ot->exec = edbm_sort_elements_exec;
-       ot->poll = ED_operator_editmesh;
-       ot->ui = edbm_sort_elements_ui;
-
-       /* flags */
-       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
-
-       /* properties */
-       ot->prop = RNA_def_enum(ot->srna, "type", type_items, 0, "Type", "Type of re-ordering operation to apply");
-       RNA_def_enum_flag(ot->srna, "elements", elem_items, 0, "Elements",
-                         "Which elements to affect (vertices, edges and/or faces)");
-       RNA_def_boolean(ot->srna, "reverse", false, "Reverse", "Reverse the sorting effect");
-       RNA_def_int(ot->srna, "seed", 0, 0, INT_MAX, "Seed", "Seed for random-based operations", 0, 255);
-}
-
-/****** end of qsort stuff ****/
-
-static int edbm_noise_exec(bContext *C, wmOperator *op)
-{
-       Object *obedit = CTX_data_edit_object(C);
-       BMEditMesh *em = BMEdit_FromObject(obedit);
-       Material *ma;
-       Tex *tex;
-       BMVert *eve;
-       BMIter iter;
-       const float fac = RNA_float_get(op->ptr, "factor");
-
-       if (em == NULL) {
-               return OPERATOR_FINISHED;
-       }
-
-       if ((ma  = give_current_material(obedit, obedit->actcol)) == NULL ||
-           (tex = give_current_material_texture(ma)) == NULL)
-       {
-               BKE_report(op->reports, RPT_WARNING, "Mesh has no material or texture assigned");
-               return OPERATOR_FINISHED;
-       }
-
-       if (tex->type == TEX_STUCCI) {
-               float b2, vec[3];
-               float ofs = tex->turbul / 200.0f;
-               BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
-                       if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
-                               b2 = BLI_hnoise(tex->noisesize, eve->co[0], eve->co[1], eve->co[2]);
-                               if (tex->stype) ofs *= (b2 * b2);
-                               vec[0] = fac * (b2 - BLI_hnoise(tex->noisesize, eve->co[0] + ofs, eve->co[1], eve->co[2]));
-                               vec[1] = fac * (b2 - BLI_hnoise(tex->noisesize, eve->co[0], eve->co[1] + ofs, eve->co[2]));
-                               vec[2] = fac * (b2 - BLI_hnoise(tex->noisesize, eve->co[0], eve->co[1], eve->co[2] + ofs));
-                               
-                               add_v3_v3(eve->co, vec);
-                       }
-               }
-       }
-       else {
-               BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
-                       if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
-                               float tin, dum;
-                               externtex(ma->mtex[0], eve->co, &tin, &dum, &dum, &dum, &dum, 0, NULL);
-                               eve->co[2] += fac * tin;
-                       }
-               }
-       }
-
-       EDBM_mesh_normals_update(em);
-
-       EDBM_update_generic(em, true, false);
-
-       return OPERATOR_FINISHED;
-}
-
-void MESH_OT_noise(wmOperatorType *ot)
-{
-       /* identifiers */
-       ot->name = "Noise";
-       ot->description = "Use vertex coordinate as texture coordinate";
-       ot->idname = "MESH_OT_noise";
-
-       /* api callbacks */
-       ot->exec = edbm_noise_exec;
-       ot->poll = ED_operator_editmesh;
-
-       /* flags */
-       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
-
-       RNA_def_float(ot->srna, "factor", 0.1f, -FLT_MAX, FLT_MAX, "Factor", "", 0.0f, 1.0f);
-}
-
-typedef struct {
-       BMEditMesh *em;
-       BMBackup mesh_backup;
-       int mcenter[2];
-       float initial_length;
-       float pixel_size;  /* use when mouse input is interpreted as spatial distance */
-       int is_modal;
-       NumInput num_input;
-       float shift_factor; /* The current factor when shift is pressed. Negative when shift not active. */
-} BevelData;
-
-#define HEADER_LENGTH 180
-
-static void edbm_bevel_update_header(wmOperator *op, bContext *C)
-{
-       const char *str = IFACE_("Confirm: Enter/LClick, Cancel: (Esc/RMB), Offset: %s, Segments: %d");
-
-       char msg[HEADER_LENGTH];
-       ScrArea *sa = CTX_wm_area(C);
-
-       if (sa) {
-               char offset_str[NUM_STR_REP_LEN];
-               BLI_snprintf(offset_str, NUM_STR_REP_LEN, "%f", RNA_float_get(op->ptr, "offset"));
-               BLI_snprintf(msg, HEADER_LENGTH, str,
-                            offset_str,
-                            RNA_int_get(op->ptr, "segments")
-                           );
-
-               ED_area_headerprint(sa, msg);
-       }
-}
-
-static int edbm_bevel_init(bContext *C, wmOperator *op, int is_modal)
-{
-       Object *obedit = CTX_data_edit_object(C);
-       BMEditMesh *em = BMEdit_FromObject(obedit);
-       BevelData *opdata;
-       
-       if (em == NULL) {
-               return 0;
-       }
-
-       op->customdata = opdata = MEM_mallocN(sizeof(BevelData), "beveldata_mesh_operator");
-       
-       opdata->em = em;
-       opdata->is_modal = is_modal;
-       opdata->shift_factor = -1.0f;
-
-       initNumInput(&opdata->num_input);
-       opdata->num_input.flag = NUM_NO_NEGATIVE;
-
-       /* avoid the cost of allocating a bm copy */
-       if (is_modal)
-               opdata->mesh_backup = EDBM_redo_state_store(em);
-
-       return 1;
-}
-
-static int edbm_bevel_calc(wmOperator *op)
-{
-       BevelData *opdata = op->customdata;
-       BMEditMesh *em = opdata->em;
-       BMOperator bmop;
-       const float offset = RNA_float_get(op->ptr, "offset");
-       const int segments = RNA_int_get(op->ptr, "segments");
-       const bool vertex_only = RNA_boolean_get(op->ptr, "vertex_only");
-
-       /* revert to original mesh */
-       if (opdata->is_modal) {
-               EDBM_redo_state_restore(opdata->mesh_backup, em, false);
-       }
-
-       if (!EDBM_op_init(em, &bmop, op,
-                             "bevel geom=%hev offset=%f segments=%i vertex_only=%b",
-                             BM_ELEM_SELECT, offset, segments, vertex_only))
-       {
-               return 0;
-       }
-
-       BMO_op_exec(em->bm, &bmop);
-
-       if (offset != 0.0f) {
-               /* not essential, but we may have some loose geometry that
-                * won't get bevel'd and better not leave it selected */
-               EDBM_flag_disable_all(em, BM_ELEM_SELECT);
-               BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faces.out", BM_FACE, BM_ELEM_SELECT, true);
-       }
-
-       /* no need to de-select existing geometry */
-       if (!EDBM_op_finish(em, &bmop, op, true))
-               return 0;
-       
-       EDBM_mesh_normals_update(opdata->em);
-       
-       EDBM_update_generic(opdata->em, true, true);
-
-       return 1;
-}
-
-static void edbm_bevel_exit(bContext *C, wmOperator *op)
-{
-       BevelData *opdata = op->customdata;
-
-       ScrArea *sa = CTX_wm_area(C);
-
-       if (sa) {
-               ED_area_headerprint(sa, NULL);
-       }
-
-       if (opdata->is_modal) {
-               EDBM_redo_state_free(&opdata->mesh_backup, NULL, false);
-       }
-       MEM_freeN(opdata);
-       op->customdata = NULL;
-}
-
-static int edbm_bevel_cancel(bContext *C, wmOperator *op)
-{
-       BevelData *opdata = op->customdata;
-       if (opdata->is_modal) {
-               EDBM_redo_state_free(&opdata->mesh_backup, opdata->em, true);
-               EDBM_update_generic(opdata->em, false, true);
-       }
-
-       edbm_bevel_exit(C, op);
-
-       /* need to force redisplay or we may still view the modified result */
-       ED_region_tag_redraw(CTX_wm_region(C));
-       return OPERATOR_CANCELLED;
-}
-
-/* bevel! yay!!*/
-static int edbm_bevel_exec(bContext *C, wmOperator *op)
-{
-       if (!edbm_bevel_init(C, op, false)) {
-               edbm_bevel_exit(C, op);
-               return OPERATOR_CANCELLED;
-       }
-
-       if (!edbm_bevel_calc(op)) {
-               edbm_bevel_cancel(C, op);
-               return OPERATOR_CANCELLED;
-       }
-
-       edbm_bevel_exit(C, op);
-
-       return OPERATOR_FINISHED;
-}
-
-static int edbm_bevel_invoke(bContext *C, wmOperator *op, const wmEvent *event)
-{
-       /* TODO make modal keymap (see fly mode) */
-       RegionView3D *rv3d = CTX_wm_region_view3d(C);
-       BevelData *opdata;
-       float mlen[2];
-       float center_3d[3];
-
-       if (!edbm_bevel_init(C, op, true)) {
-               return OPERATOR_CANCELLED;
-       }
-
-       opdata = op->customdata;
+               {0, NULL, 0, NULL, NULL},
+       };
 
-       /* initialize mouse values */
-       if (!calculateTransformCenter(C, V3D_CENTROID, center_3d, opdata->mcenter)) {
-               /* in this case the tool will likely do nothing,
-                * ideally this will never happen and should be checked for above */
-               opdata->mcenter[0] = opdata->mcenter[1] = 0;
-       }
-       mlen[0] = opdata->mcenter[0] - event->mval[0];
-       mlen[1] = opdata->mcenter[1] - event->mval[1];
-       opdata->initial_length = len_v2(mlen);
-       opdata->pixel_size = rv3d ? ED_view3d_pixel_size(rv3d, center_3d) : 1.0f;
+       static EnumPropertyItem elem_items[] = {
+               {BM_VERT, "VERT", 0, "Vertices", ""},
+               {BM_EDGE, "EDGE", 0, "Edges", ""},
+               {BM_FACE, "FACE", 0, "Faces", ""},
+               {0, NULL, 0, NULL, NULL},
+       };
 
-       edbm_bevel_update_header(op, C);
+       /* identifiers */
+       ot->name = "Sort Mesh Elements";
+       ot->description = "The order of selected vertices/edges/faces is modified, based on a given method";
+       ot->idname = "MESH_OT_sort_elements";
 
-       if (!edbm_bevel_calc(op)) {
-               edbm_bevel_cancel(C, op);
-               return OPERATOR_CANCELLED;
-       }
+       /* api callbacks */
+       ot->invoke = WM_menu_invoke;
+       ot->exec = edbm_sort_elements_exec;
+       ot->poll = ED_operator_editmesh;
+       ot->ui = edbm_sort_elements_ui;
 
-       WM_event_add_modal_handler(C, op);
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 
-       return OPERATOR_RUNNING_MODAL;
+       /* properties */
+       ot->prop = RNA_def_enum(ot->srna, "type", type_items, 0, "Type", "Type of re-ordering operation to apply");
+       RNA_def_enum_flag(ot->srna, "elements", elem_items, 0, "Elements",
+                         "Which elements to affect (vertices, edges and/or faces)");
+       RNA_def_boolean(ot->srna, "reverse", false, "Reverse", "Reverse the sorting effect");
+       RNA_def_int(ot->srna, "seed", 0, 0, INT_MAX, "Seed", "Seed for random-based operations", 0, 255);
 }
 
-static float edbm_bevel_mval_factor(wmOperator *op, const wmEvent *event)
-{
-       BevelData *opdata = op->customdata;
-       int use_dist = true;
-       float mdiff[2];
-       float factor;
+/****** end of qsort stuff ****/
 
-       mdiff[0] = opdata->mcenter[0] - event->mval[0];
-       mdiff[1] = opdata->mcenter[1] - event->mval[1];
+static int edbm_noise_exec(bContext *C, wmOperator *op)
+{
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = BMEdit_FromObject(obedit);
+       Material *ma;
+       Tex *tex;
+       BMVert *eve;
+       BMIter iter;
+       const float fac = RNA_float_get(op->ptr, "factor");
 
-       if (use_dist) {
-               factor = ((len_v2(mdiff) - MVAL_PIXEL_MARGIN) - opdata->initial_length) * opdata->pixel_size;
-       }
-       else {
-               factor = (len_v2(mdiff) - MVAL_PIXEL_MARGIN) / opdata->initial_length;
-               factor = factor - 1.0f;  /* a different kind of buffer where nothing happens */
+       if (em == NULL) {
+               return OPERATOR_FINISHED;
        }
 
-       /* Fake shift-transform... */
-       if (event->shift) {
-               if (opdata->shift_factor < 0.0f) {
-                       opdata->shift_factor = RNA_float_get(op->ptr, "offset");
-               }
-               factor = (factor - opdata->shift_factor) * 0.1f + opdata->shift_factor;
+       if ((ma  = give_current_material(obedit, obedit->actcol)) == NULL ||
+           (tex = give_current_material_texture(ma)) == NULL)
+       {
+               BKE_report(op->reports, RPT_WARNING, "Mesh has no material or texture assigned");
+               return OPERATOR_FINISHED;
        }
-       else if (opdata->shift_factor >= 0.0f)
-               opdata->shift_factor = -1.0f;
 
-       /* clamp differently based on distance/factor */
-       if (use_dist) {
-               if (factor < 0.0f) factor = 0.0f;
+       if (tex->type == TEX_STUCCI) {
+               float b2, vec[3];
+               float ofs = tex->turbul / 200.0f;
+               BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
+                       if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
+                               b2 = BLI_hnoise(tex->noisesize, eve->co[0], eve->co[1], eve->co[2]);
+                               if (tex->stype) ofs *= (b2 * b2);
+                               vec[0] = fac * (b2 - BLI_hnoise(tex->noisesize, eve->co[0] + ofs, eve->co[1], eve->co[2]));
+                               vec[1] = fac * (b2 - BLI_hnoise(tex->noisesize, eve->co[0], eve->co[1] + ofs, eve->co[2]));
+                               vec[2] = fac * (b2 - BLI_hnoise(tex->noisesize, eve->co[0], eve->co[1], eve->co[2] + ofs));
+                               
+                               add_v3_v3(eve->co, vec);
+                       }
+               }
        }
        else {
-               CLAMP(factor, 0.0f, 1.0f);
-       }
-
-       return factor;
-}
-
-static int edbm_bevel_modal(bContext *C, wmOperator *op, const wmEvent *event)
-{
-       BevelData *opdata = op->customdata;
-       int segments = RNA_int_get(op->ptr, "segments");
-
-       if (event->val == KM_PRESS) {
-               /* Try to handle numeric inputs... */
-
-               if (handleNumInput(&opdata->num_input, event)) {
-                       float value = RNA_float_get(op->ptr, "offset");
-                       applyNumInput(&opdata->num_input, &value);
-                       RNA_float_set(op->ptr, "offset", value);
-                       edbm_bevel_calc(op);
-                       edbm_bevel_update_header(op, C);
-                       return OPERATOR_RUNNING_MODAL;
+               BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
+                       if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
+                               float tin, dum;
+                               externtex(ma->mtex[0], eve->co, &tin, &dum, &dum, &dum, &dum, 0, NULL);
+                               eve->co[2] += fac * tin;
+                       }
                }
        }
 
-       switch (event->type) {
-               case ESCKEY:
-               case RIGHTMOUSE:
-                       edbm_bevel_cancel(C, op);
-                       return OPERATOR_CANCELLED;
-
-               case MOUSEMOVE:
-                       if (!hasNumInput(&opdata->num_input)) {
-                               const float factor = edbm_bevel_mval_factor(op, event);
-                               RNA_float_set(op->ptr, "offset", factor);
-
-                               edbm_bevel_calc(op);
-                               edbm_bevel_update_header(op, C);
-                       }
-                       break;
-
-               case LEFTMOUSE:
-               case PADENTER:
-               case RETKEY:
-                       edbm_bevel_calc(op);
-                       edbm_bevel_exit(C, op);
-                       return OPERATOR_FINISHED;
-
-               case WHEELUPMOUSE:  /* change number of segments */
-               case PAGEUPKEY:
-                       if (event->val == KM_RELEASE)
-                               break;
-
-                       segments++;
-                       RNA_int_set(op->ptr, "segments", segments);
-                       edbm_bevel_calc(op);
-                       edbm_bevel_update_header(op, C);
-                       break;
-
-               case WHEELDOWNMOUSE:  /* change number of segments */
-               case PAGEDOWNKEY:
-                       if (event->val == KM_RELEASE)
-                               break;
+       EDBM_mesh_normals_update(em);
 
-                       segments = max_ii(segments - 1, 1);
-                       RNA_int_set(op->ptr, "segments", segments);
-                       edbm_bevel_calc(op);
-                       edbm_bevel_update_header(op, C);
-                       break;
-       }
+       EDBM_update_generic(em, true, false);
 
-       return OPERATOR_RUNNING_MODAL;
+       return OPERATOR_FINISHED;
 }
 
-void MESH_OT_bevel(wmOperatorType *ot)
+void MESH_OT_noise(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name = "Bevel";
-       ot->description = "Edge Bevel";
-       ot->idname = "MESH_OT_bevel";
+       ot->name = "Noise";
+       ot->description = "Use vertex coordinate as texture coordinate";
+       ot->idname = "MESH_OT_noise";
 
        /* api callbacks */
-       ot->exec = edbm_bevel_exec;
-       ot->invoke = edbm_bevel_invoke;
-       ot->modal = edbm_bevel_modal;
-       ot->cancel = edbm_bevel_cancel;
+       ot->exec = edbm_noise_exec;
        ot->poll = ED_operator_editmesh;
 
        /* flags */
-       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_GRAB_POINTER | OPTYPE_BLOCKING;
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 
-       RNA_def_float(ot->srna, "offset", 0.0f, -FLT_MAX, FLT_MAX, "Offset", "", 0.0f, 1.0f);
-       RNA_def_int(ot->srna, "segments", 1, 1, 50, "Segments", "Segments for curved edge", 1, 8);
-       RNA_def_boolean(ot->srna, "vertex_only", false, "Vertex only", "Bevel only vertices");
+       RNA_def_float(ot->srna, "factor", 0.1f, -FLT_MAX, FLT_MAX, "Factor", "", 0.0f, 1.0f);
 }
 
 static int edbm_bridge_edge_loops_exec(bContext *C, wmOperator *op)
@@ -5217,382 +3590,6 @@ void MESH_OT_bridge_edge_loops(wmOperatorType *ot)
        RNA_def_float(ot->srna, "merge_factor", 0.5f, 0.0f, 1.0f, "Merge Factor", "", 0.0f, 1.0f);
 }
 
-typedef struct {
-       float old_thickness;
-       float old_depth;
-       int mcenter[2];
-       int modify_depth;
-       float initial_length;
-       float pixel_size;  /* use when mouse input is interpreted as spatial distance */
-       int is_modal;
-       int shift;
-       float shift_amount;
-       BMBackup backup;
-       BMEditMesh *em;
-       NumInput num_input;
-} InsetData;
-
-static void edbm_inset_update_header(wmOperator *op, bContext *C)
-{
-       InsetData *opdata = op->customdata;
-
-       const char *str = IFACE_("Confirm: Enter/LClick, Cancel: (Esc/RClick), Thickness: %s, "
-                                "Depth (Ctrl to tweak): %s (%s), Outset (O): (%s), Boundary (B): (%s)");
-
-       char msg[HEADER_LENGTH];
-       ScrArea *sa = CTX_wm_area(C);
-
-       if (sa) {
-               char flts_str[NUM_STR_REP_LEN * 2];
-               if (hasNumInput(&opdata->num_input))
-                       outputNumInput(&opdata->num_input, flts_str);
-               else {
-                       BLI_snprintf(flts_str, NUM_STR_REP_LEN, "%f", RNA_float_get(op->ptr, "thickness"));
-                       BLI_snprintf(flts_str + NUM_STR_REP_LEN, NUM_STR_REP_LEN, "%f", RNA_float_get(op->ptr, "depth"));
-               }
-               BLI_snprintf(msg, HEADER_LENGTH, str,
-                            flts_str,
-                            flts_str + NUM_STR_REP_LEN,
-                            opdata->modify_depth ? IFACE_("On") : IFACE_("Off"),
-                            RNA_boolean_get(op->ptr, "use_outset") ? IFACE_("On") : IFACE_("Off"),
-                            RNA_boolean_get(op->ptr, "use_boundary") ? IFACE_("On") : IFACE_("Off")
-                           );
-
-               ED_area_headerprint(sa, msg);
-       }
-}
-
-
-static int edbm_inset_init(bContext *C, wmOperator *op, int is_modal)
-{
-       InsetData *opdata;
-       Object *obedit = CTX_data_edit_object(C);
-       BMEditMesh *em = BMEdit_FromObject(obedit);
-
-       op->customdata = opdata = MEM_mallocN(sizeof(InsetData), "inset_operator_data");
-
-       opdata->old_thickness = 0.01;
-       opdata->old_depth = 0.0;
-       opdata->modify_depth = false;
-       opdata->shift = false;
-       opdata->shift_amount = 0.0f;
-       opdata->is_modal = is_modal;
-       opdata->em = em;
-
-       initNumInput(&opdata->num_input);
-       opdata->num_input.idx_max = 1; /* Two elements. */
-
-       if (is_modal)
-               opdata->backup = EDBM_redo_state_store(em);
-
-       return 1;
-}
-
-static void edbm_inset_exit(bContext *C, wmOperator *op)
-{
-       InsetData *opdata;
-       ScrArea *sa = CTX_wm_area(C);
-
-       opdata = op->customdata;
-
-       if (opdata->is_modal)
-               EDBM_redo_state_free(&opdata->backup, NULL, false);
-
-       if (sa) {
-               ED_area_headerprint(sa, NULL);
-       }
-       MEM_freeN(op->customdata);
-}
-
-static int edbm_inset_cancel(bContext *C, wmOperator *op)
-{
-       InsetData *opdata;
-
-       opdata = op->customdata;
-       if (opdata->is_modal) {
-               EDBM_redo_state_free(&opdata->backup, opdata->em, true);
-               EDBM_update_generic(opdata->em, false, true);
-       }
-
-       edbm_inset_exit(C, op);
-
-       /* need to force redisplay or we may still view the modified result */
-       ED_region_tag_redraw(CTX_wm_region(C));
-       return OPERATOR_CANCELLED;
-}
-
-static int edbm_inset_calc(wmOperator *op)
-{
-       InsetData *opdata;
-       BMEditMesh *em;
-       BMOperator bmop;
-
-       const bool use_boundary        = RNA_boolean_get(op->ptr, "use_boundary");
-       const bool use_even_offset     = RNA_boolean_get(op->ptr, "use_even_offset");
-       const bool use_relative_offset = RNA_boolean_get(op->ptr, "use_relative_offset");
-       const float thickness          = RNA_float_get(op->ptr,   "thickness");
-       const float depth              = RNA_float_get(op->ptr,   "depth");
-       const bool use_outset          = RNA_boolean_get(op->ptr, "use_outset");
-       const bool use_select_inset    = RNA_boolean_get(op->ptr, "use_select_inset"); /* not passed onto the BMO */
-
-       opdata = op->customdata;
-       em = opdata->em;
-
-       if (opdata->is_modal) {
-               EDBM_redo_state_restore(opdata->backup, em, false);
-       }
-
-       EDBM_op_init(em, &bmop, op,
-                    "inset faces=%hf use_boundary=%b use_even_offset=%b use_relative_offset=%b "
-                    "thickness=%f depth=%f use_outset=%b",
-                    BM_ELEM_SELECT, use_boundary, use_even_offset, use_relative_offset,
-                    thickness, depth, use_outset);
-
-       BMO_op_exec(em->bm, &bmop);
-
-       if (use_select_inset) {
-               /* deselect original faces/verts */
-               EDBM_flag_disable_all(em, BM_ELEM_SELECT);
-               BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faces.out", BM_FACE, BM_ELEM_SELECT, true);
-       }
-       else {
-               BM_mesh_elem_hflag_disable_all(em->bm, BM_VERT | BM_EDGE, BM_ELEM_SELECT, false);
-               BMO_slot_buffer_hflag_disable(em->bm, bmop.slots_out, "faces.out", BM_FACE, BM_ELEM_SELECT, false);
-               /* re-select faces so the verts and edges get selected too */
-               BM_mesh_elem_hflag_enable_test(em->bm, BM_FACE, BM_ELEM_SELECT, true, BM_ELEM_SELECT);
-       }
-
-       if (!EDBM_op_finish(em, &bmop, op, true)) {
-               return 0;
-       }
-       else {
-               EDBM_update_generic(em, true, true);
-               return 1;
-       }
-}
-
-static int edbm_inset_exec(bContext *C, wmOperator *op)
-{
-       edbm_inset_init(C, op, false);
-
-       if (!edbm_inset_calc(op)) {
-               edbm_inset_exit(C, op);
-               return OPERATOR_CANCELLED;
-       }
-
-       edbm_inset_exit(C, op);
-       return OPERATOR_FINISHED;
-}
-
-static int edbm_inset_invoke(bContext *C, wmOperator *op, const wmEvent *event)
-{
-       RegionView3D *rv3d = CTX_wm_region_view3d(C);
-       InsetData *opdata;
-       float mlen[2];
-       float center_3d[3];
-
-       edbm_inset_init(C, op, true);
-
-       opdata = op->customdata;
-
-       /* initialize mouse values */
-       if (!calculateTransformCenter(C, V3D_CENTROID, center_3d, opdata->mcenter)) {
-               /* in this case the tool will likely do nothing,
-                * ideally this will never happen and should be checked for above */
-               opdata->mcenter[0] = opdata->mcenter[1] = 0;
-       }
-       mlen[0] = opdata->mcenter[0] - event->mval[0];
-       mlen[1] = opdata->mcenter[1] - event->mval[1];
-       opdata->initial_length = len_v2(mlen);
-       opdata->pixel_size = rv3d ? ED_view3d_pixel_size(rv3d, center_3d) : 1.0f;
-
-       edbm_inset_calc(op);
-
-       edbm_inset_update_header(op, C);
-
-       WM_event_add_modal_handler(C, op);
-       return OPERATOR_RUNNING_MODAL;
-}
-
-static int edbm_inset_modal(bContext *C, wmOperator *op, const wmEvent *event)
-{
-       InsetData *opdata = op->customdata;
-
-       if (event->val == KM_PRESS) {
-               /* Try to handle numeric inputs... */
-
-               if (handleNumInput(&opdata->num_input, event)) {
-                       float amounts[2] = {RNA_float_get(op->ptr, "thickness"),
-                                           RNA_float_get(op->ptr, "depth")};
-                       applyNumInput(&opdata->num_input, amounts);
-                       amounts[0] = max_ff(amounts[0], 0.0f);
-                       RNA_float_set(op->ptr, "thickness", amounts[0]);
-                       RNA_float_set(op->ptr, "depth", amounts[1]);
-
-                       if (edbm_inset_calc(op)) {
-                               edbm_inset_update_header(op, C);
-                               return OPERATOR_RUNNING_MODAL;
-                       }
-                       else {
-                               edbm_inset_cancel(C, op);
-                               return OPERATOR_CANCELLED;
-                       }
-               }
-       }
-
-       switch (event->type) {
-               case ESCKEY:
-               case RIGHTMOUSE:
-                       edbm_inset_cancel(C, op);
-                       return OPERATOR_CANCELLED;
-
-               case MOUSEMOVE:
-                       if (!hasNumInput(&opdata->num_input)) {
-                               float mdiff[2];
-                               float amount;
-
-                               mdiff[0] = opdata->mcenter[0] - event->mval[0];
-                               mdiff[1] = opdata->mcenter[1] - event->mval[1];
-
-                               if (opdata->modify_depth)
-                                       amount = opdata->old_depth     + ((len_v2(mdiff) - opdata->initial_length) * opdata->pixel_size);
-                               else
-                                       amount = opdata->old_thickness - ((len_v2(mdiff) - opdata->initial_length) * opdata->pixel_size);
-
-                               /* Fake shift-transform... */
-                               if (opdata->shift)
-                                       amount = (amount - opdata->shift_amount) * 0.1f + opdata->shift_amount;
-
-                               if (opdata->modify_depth)
-                                       RNA_float_set(op->ptr, "depth", amount);
-                               else {
-                                       amount = max_ff(amount, 0.0f);
-                                       RNA_float_set(op->ptr, "thickness", amount);
-                               }
-
-                               if (edbm_inset_calc(op))
-                                       edbm_inset_update_header(op, C);
-                               else {
-                                       edbm_inset_cancel(C, op);
-                                       return OPERATOR_CANCELLED;
-                               }
-                       }
-                       break;
-
-               case LEFTMOUSE:
-               case PADENTER:
-               case RETKEY:
-                       edbm_inset_calc(op);
-                       edbm_inset_exit(C, op);
-                       return OPERATOR_FINISHED;
-
-               case LEFTSHIFTKEY:
-               case RIGHTSHIFTKEY:
-                       if (event->val == KM_PRESS) {
-                               if (opdata->modify_depth)
-                                       opdata->shift_amount = RNA_float_get(op->ptr, "depth");
-                               else
-                                       opdata->shift_amount = RNA_float_get(op->ptr, "thickness");
-                               opdata->shift = true;
-                       }
-                       else {
-                               opdata->shift_amount = 0.0f;
-                               opdata->shift = false;
-                       }
-                       break;
-
-               case LEFTCTRLKEY:
-               case RIGHTCTRLKEY:
-               {
-                       float mlen[2];
-
-                       mlen[0] = opdata->mcenter[0] - event->mval[0];
-                       mlen[1] = opdata->mcenter[1] - event->mval[1];
-
-                       if (event->val == KM_PRESS) {
-                               opdata->old_thickness = RNA_float_get(op->ptr, "thickness");
-                               if (opdata->shift)
-                                       opdata->shift_amount = opdata->old_thickness;
-                               opdata->modify_depth = true;
-                       }
-                       else {
-                               opdata->old_depth = RNA_float_get(op->ptr, "depth");
-                               if (opdata->shift)
-                                       opdata->shift_amount = opdata->old_depth;
-                               opdata->modify_depth = false;
-                       }
-                       opdata->initial_length = len_v2(mlen);
-
-                       edbm_inset_update_header(op, C);
-                       break;
-               }
-
-               case OKEY:
-                       if (event->val == KM_PRESS) {
-                               const bool use_outset = RNA_boolean_get(op->ptr, "use_outset");
-                               RNA_boolean_set(op->ptr, "use_outset", !use_outset);
-                               if (edbm_inset_calc(op)) {
-                                       edbm_inset_update_header(op, C);
-                               }
-                               else {
-                                       edbm_inset_cancel(C, op);
-                                       return OPERATOR_CANCELLED;
-                               }
-                       }
-                       break;
-               case BKEY:
-                       if (event->val == KM_PRESS) {
-                               const bool use_boundary = RNA_boolean_get(op->ptr, "use_boundary");
-                               RNA_boolean_set(op->ptr, "use_boundary", !use_boundary);
-                               if (edbm_inset_calc(op)) {
-                                       edbm_inset_update_header(op, C);
-                               }
-                               else {
-                                       edbm_inset_cancel(C, op);
-                                       return OPERATOR_CANCELLED;
-                               }
-                       }
-                       break;
-       }
-
-       return OPERATOR_RUNNING_MODAL;
-}
-
-
-void MESH_OT_inset(wmOperatorType *ot)
-{
-       PropertyRNA *prop;
-
-       /* identifiers */
-       ot->name = "Inset Faces";
-       ot->idname = "MESH_OT_inset";
-       ot->description = "Inset new faces into selected faces";
-
-       /* api callbacks */
-       ot->invoke = edbm_inset_invoke;
-       ot->modal = edbm_inset_modal;
-       ot->exec = edbm_inset_exec;
-       ot->cancel = edbm_inset_cancel;
-       ot->poll = ED_operator_editmesh;
-
-       /* flags */
-       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_GRAB_POINTER | OPTYPE_BLOCKING;
-
-       /* properties */
-       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");
-
-       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);
-       prop = RNA_def_float(ot->srna, "depth", 0.0f, -FLT_MAX, FLT_MAX, "Depth", "", -10.0f, 10.0f);
-       RNA_def_property_ui_range(prop, -10.0f, 10.0f, 0.01, 4);
-
-       RNA_def_boolean(ot->srna, "use_outset", false, "Outset", "Outset rather than inset");
-       RNA_def_boolean(ot->srna, "use_select_inset", true, "Select Outer", "Select the new inset faces");
-}
-
 static int edbm_wireframe_exec(bContext *C, wmOperator *op)
 {
        Object *obedit = CTX_data_edit_object(C);
index cb15fdef88042ee6f42efddf5feedacbdf5cb5c5..9020e133b33cc6a84557bea10597774297a58f66 100644 (file)
@@ -33,7 +33,6 @@
 
 #include "DNA_mesh_types.h"
 #include "DNA_object_types.h"
-#include "DNA_scene_types.h"
 
 #include "BLI_math.h"
 
 #include "WM_types.h"
 
 #include "ED_mesh.h"
+#include "ED_screen.h"
 #include "ED_util.h"
 
-
-#include "mesh_intern.h"
+#include "mesh_intern.h"  /* own include */
 
 /* mesh backup implementation. This would greatly benefit from some sort of binary diffing
  * just as the undo stack would. So leaving this as an interface for further work */
@@ -1367,3 +1366,12 @@ void EDBM_update_generic(BMEditMesh *em, const bool do_tessface, const bool is_d
                BLI_assert(EDBM_index_arrays_check(em) == true);
        }
 }
+
+/* poll call for mesh operators requiring a view3d context */
+int EDBM_view3d_poll(bContext *C)
+{
+       if (ED_operator_editmesh(C) && ED_operator_view3d_active(C))
+               return 1;
+
+       return 0;
+}
index 20633aa0c876e2765f3fcadff2f6de915c42fe64..cbaa80718ee5d58ff3bba01c0fa5f7e860e7957f 100644 (file)
@@ -61,7 +61,7 @@
 #include "ED_uvedit.h"
 #include "ED_view3d.h"
 
-#include "mesh_intern.h"
+#include "mesh_intern.h"  /* own include */
 
 
 static CustomData *mesh_customdata_get_type(Mesh *me, const char htype, int *r_tot)
index 2013335dac663c2a8efcbf67dfc11ec753f38eb0..996ee9fc549c3d52b70905bfcd40b1de3870d112 100644 (file)
@@ -29,7 +29,6 @@
  *  \ingroup edmesh
  */
 
-
 /* Internal for editmesh_xxxx.c functions */
 
 #ifndef __MESH_INTERN_H__
@@ -50,21 +49,18 @@ struct wmOperator;
 struct wmOperatorType;
 struct LinkNode;
 
-/* ******************** editmesh_utils.c */
+/* *** editmesh_utils.c *** */
 
 /*
  * ok: the EDBM module is for editmode bmesh stuff.  in contrast, the 
  * BMEdit module is for code shared with blenkernel that concerns
- * the BMEditMesh structure.
- */
+ * the BMEditMesh structure. */
 
-/*calls a bmesh op, reporting errors to the user, etc*/
+/* Calls a bmesh op, reporting errors to the user, etc */
 bool EDBM_op_callf(struct BMEditMesh *em, struct wmOperator *op, const char *fmt, ...);
-
 bool EDBM_op_call_and_selectf(struct BMEditMesh *em, struct wmOperator *op,
                               const char *selectslot, const char *fmt, ...);
-
-/* same as above, but doesn't report errors.*/
+/* Same as above, but doesn't report errors.*/
 bool EDBM_op_call_silentf(struct BMEditMesh *em, const char *fmt, ...);
 
 /* these next two functions are the split version of EDBM_op_callf, so you can
@@ -74,17 +70,16 @@ bool EDBM_op_call_silentf(struct BMEditMesh *em, const char *fmt, ...);
  * execute the operator with BM_Exec_Op */
 bool EDBM_op_init(struct BMEditMesh *em, struct BMOperator *bmop,
                   struct wmOperator *op, const char *fmt, ...);
-/*cleans up after a bmesh operator*/
+/* Cleans up after a bmesh operator */
 bool EDBM_op_finish(struct BMEditMesh *em, struct BMOperator *bmop,
                     struct wmOperator *op, const bool do_report);
 
 void EDBM_stats_update(struct BMEditMesh *em);
 
-/* ******************** editface.c */
+int  EDBM_view3d_poll(struct bContext *C);
 
-void MESH_OT_separate(struct wmOperatorType *ot);
 
-/* ******************* editmesh_add.c */
+/* *** editmesh_add.c *** */
 void MESH_OT_primitive_plane_add(struct wmOperatorType *ot);
 void MESH_OT_primitive_cube_add(struct wmOperatorType *ot);
 void MESH_OT_primitive_circle_add(struct wmOperatorType *ot);
@@ -95,95 +90,121 @@ void MESH_OT_primitive_monkey_add(struct wmOperatorType *ot);
 void MESH_OT_primitive_uv_sphere_add(struct wmOperatorType *ot);
 void MESH_OT_primitive_ico_sphere_add(struct wmOperatorType *ot);
 
-void MESH_OT_edge_face_add(struct wmOperatorType *ot);
+
+/* *** editmesh_bevel.c *** */
+void MESH_OT_bevel(struct wmOperatorType *ot);
+
+
+/* *** editmesh_extrude.c *** */
+void MESH_OT_extrude_repeat(struct wmOperatorType *ot);
+void MESH_OT_extrude_region(struct wmOperatorType *ot);
+void MESH_OT_extrude_verts_indiv(struct wmOperatorType *ot);
+void MESH_OT_extrude_edges_indiv(struct wmOperatorType *ot);
+void MESH_OT_extrude_faces_indiv(struct wmOperatorType *ot);
 void MESH_OT_dupli_extrude_cursor(struct wmOperatorType *ot);
-void MESH_OT_duplicate(struct wmOperatorType *ot);
+void MESH_OT_spin(struct wmOperatorType *ot);
+void MESH_OT_screw(struct wmOperatorType *ot);
+
 
-extern int EM_view3d_poll(struct bContext *C);
+/* *** editmesh_inset.c *** */
+void MESH_OT_inset(struct wmOperatorType *ot);
+
+
+/* *** editmesh_knife.c *** */
+void MESH_OT_knife_tool(struct wmOperatorType *ot);
+void MESH_OT_knife_project(wmOperatorType *ot);
+void EDBM_mesh_knife(struct bContext *C, struct LinkNode *polys, bool use_tag);
 
 struct wmKeyMap *knifetool_modal_keymap(struct wmKeyConfig *keyconf);
 
-/* ******************* knifetool.c */
 
-void MESH_OT_knife_cut(struct wmOperatorType *ot);
+/* *** editmesh_loopcut.c *** */
+void MESH_OT_loopcut(struct wmOperatorType *ot);
 
-/* ******************* bmesh_select.c */
+
+/* *** editmesh_rip.c *** */
+void MESH_OT_rip(struct wmOperatorType *ot);
+
+
+/* *** editmesh_select.c *** */
+void MESH_OT_select_similar(struct wmOperatorType *ot);
+void MESH_OT_select_mode(struct wmOperatorType *ot);
+void MESH_OT_loop_multi_select(struct wmOperatorType *ot);
 void MESH_OT_loop_select(struct wmOperatorType *ot);
+void MESH_OT_edgering_select(struct wmOperatorType *ot);
 void MESH_OT_select_all(struct wmOperatorType *ot);
 void MESH_OT_select_interior_faces(struct wmOperatorType *ot);
-void MESH_OT_select_more(struct wmOperatorType *ot);
-void MESH_OT_select_less(struct wmOperatorType *ot);
-void MESH_OT_select_non_manifold(struct wmOperatorType *ot);
+void MESH_OT_select_shortest_path(struct wmOperatorType *ot);
 void MESH_OT_select_linked(struct wmOperatorType *ot);
 void MESH_OT_select_linked_pick(struct wmOperatorType *ot);
-void MESH_OT_hide(struct wmOperatorType *ot);
-void MESH_OT_reveal(struct wmOperatorType *ot);
 void MESH_OT_select_face_by_sides(struct wmOperatorType *ot);
 void MESH_OT_select_loose_verts(struct wmOperatorType *ot);
 void MESH_OT_select_mirror(struct wmOperatorType *ot);
-void MESH_OT_normals_make_consistent(struct wmOperatorType *ot);
-void MESH_OT_faces_select_linked_flat(struct wmOperatorType *ot);
+void MESH_OT_select_more(struct wmOperatorType *ot);
+void MESH_OT_select_less(struct wmOperatorType *ot);
+void MESH_OT_select_nth(struct wmOperatorType *ot);
 void MESH_OT_edges_select_sharp(struct wmOperatorType *ot);
-void MESH_OT_select_shortest_path(struct wmOperatorType *ot);
-void MESH_OT_select_similar(struct wmOperatorType *ot);
-void MESH_OT_select_mode(struct wmOperatorType *ot);
+void MESH_OT_faces_select_linked_flat(struct wmOperatorType *ot);
+void MESH_OT_select_non_manifold(struct wmOperatorType *ot);
 void MESH_OT_select_random(struct wmOperatorType *ot);
 void MESH_OT_select_ungrouped(struct wmOperatorType *ot);
-void MESH_OT_loop_multi_select(struct wmOperatorType *ot);
-void MESH_OT_mark_seam(struct wmOperatorType *ot);
-void MESH_OT_mark_sharp(struct wmOperatorType *ot);
-void MESH_OT_vertices_smooth(struct wmOperatorType *ot);
-void MESH_OT_vertices_smooth_laplacian(struct wmOperatorType *ot);
-void MESH_OT_noise(struct wmOperatorType *ot);
-void MESH_OT_flip_normals(struct wmOperatorType *ot);
-void MESH_OT_solidify(struct wmOperatorType *ot);
-void MESH_OT_select_nth(struct wmOperatorType *ot);
+void MESH_OT_select_axis(struct wmOperatorType *ot);
 void MESH_OT_select_next_loop(struct wmOperatorType *ot);
+void MESH_OT_region_to_loop(struct wmOperatorType *ot);
+void MESH_OT_loop_to_region(struct wmOperatorType *ot);
+void MESH_OT_select_vertex_path(struct wmOperatorType *ot);
 
 extern struct EnumPropertyItem *corner_type_items;
 
-void MESH_OT_merge(struct wmOperatorType *ot);
+
+/* *** editmesh_tools.c *** */
 void MESH_OT_subdivide(struct wmOperatorType *ot);
 void MESH_OT_unsubdivide(struct wmOperatorType *ot);
-void MESH_OT_remove_doubles(struct wmOperatorType *ot);
-void MESH_OT_spin(struct wmOperatorType *ot);
-void MESH_OT_screw(struct wmOperatorType *ot);
-
-void MESH_OT_fill(struct wmOperatorType *ot);
-void MESH_OT_beautify_fill(struct wmOperatorType *ot);
-void MESH_OT_quads_convert_to_tris(struct wmOperatorType *ot);
-void MESH_OT_tris_convert_to_quads(struct wmOperatorType *ot);
-void MESH_OT_dissolve(struct wmOperatorType *ot);
-void MESH_OT_dissolve_limited(struct wmOperatorType *ot);
-void MESH_OT_faces_shade_smooth(struct wmOperatorType *ot);
-void MESH_OT_faces_shade_flat(struct wmOperatorType *ot);
-void MESH_OT_split(struct wmOperatorType *ot);
-void MESH_OT_extrude_repeat(struct wmOperatorType *ot);
-void MESH_OT_edge_rotate(struct wmOperatorType *ot);
-void MESH_OT_select_vertex_path(struct wmOperatorType *ot);
-void MESH_OT_loop_to_region(struct wmOperatorType *ot);
-void MESH_OT_region_to_loop(struct wmOperatorType *ot);
-void MESH_OT_select_axis(struct wmOperatorType *ot);
-
+void MESH_OT_normals_make_consistent(struct wmOperatorType *ot);
+void MESH_OT_vertices_smooth(struct wmOperatorType *ot);
+void MESH_OT_vertices_smooth_laplacian(struct wmOperatorType *ot);
+void MESH_OT_vert_connect(struct wmOperatorType *ot);
+void MESH_OT_edge_split(struct wmOperatorType *ot);
+void MESH_OT_bridge_edge_loops(struct wmOperatorType *ot);
+void MESH_OT_wireframe(struct wmOperatorType *ot);
+void MESH_OT_convex_hull(struct wmOperatorType *ot);
+void MESH_OT_symmetrize(struct wmOperatorType *ot);
+void MESH_OT_shape_propagate_to_all(struct wmOperatorType *ot);
+void MESH_OT_blend_from_shape(struct wmOperatorType *ot);
+void MESH_OT_sort_elements(struct wmOperatorType *ot);
 void MESH_OT_uvs_rotate(struct wmOperatorType *ot);
-//void MESH_OT_uvs_mirror(struct wmOperatorType *ot);
 void MESH_OT_uvs_reverse(struct wmOperatorType *ot);
 void MESH_OT_colors_rotate(struct wmOperatorType *ot);
-//void MESH_OT_colors_mirror(struct wmOperatorType *ot);
-
 void MESH_OT_colors_reverse(struct wmOperatorType *ot);
-
 void MESH_OT_delete(struct wmOperatorType *ot);
 void MESH_OT_edge_collapse(struct wmOperatorType *ot);
 void MESH_OT_edge_collapse_loop(struct wmOperatorType *ot);
-void MESH_OT_rip(struct wmOperatorType *ot);
-
-void MESH_OT_shape_propagate_to_all(struct wmOperatorType *ot);
-void MESH_OT_blend_from_shape(struct wmOperatorType *ot);
-void MESH_OT_sort_elements(struct wmOperatorType *ot);
+void MESH_OT_faces_shade_smooth(struct wmOperatorType *ot);
+void MESH_OT_faces_shade_flat(struct wmOperatorType *ot);
+void MESH_OT_split(struct wmOperatorType *ot);
+void MESH_OT_edge_rotate(struct wmOperatorType *ot);
+void MESH_OT_hide(struct wmOperatorType *ot);
+void MESH_OT_reveal(struct wmOperatorType *ot);
+void MESH_OT_mark_seam(struct wmOperatorType *ot);
+void MESH_OT_mark_sharp(struct wmOperatorType *ot);
+void MESH_OT_noise(struct wmOperatorType *ot);
+void MESH_OT_flip_normals(struct wmOperatorType *ot);
+void MESH_OT_solidify(struct wmOperatorType *ot);
+void MESH_OT_knife_cut(struct wmOperatorType *ot);
+void MESH_OT_separate(struct wmOperatorType *ot);
+void MESH_OT_fill(struct wmOperatorType *ot);
+void MESH_OT_beautify_fill(struct wmOperatorType *ot);
+void MESH_OT_quads_convert_to_tris(struct wmOperatorType *ot);
+void MESH_OT_tris_convert_to_quads(struct wmOperatorType *ot);
+void MESH_OT_dissolve(struct wmOperatorType *ot);
+void MESH_OT_dissolve_limited(struct wmOperatorType *ot);
+void MESH_OT_edge_face_add(struct wmOperatorType *ot);
+void MESH_OT_duplicate(struct wmOperatorType *ot);
+void MESH_OT_merge(struct wmOperatorType *ot);
+void MESH_OT_remove_doubles(struct wmOperatorType *ot);
 
-/* ******************* mesh_data.c */
 
+/* *** mesh_data.c *** */
 void MESH_OT_uv_texture_add(struct wmOperatorType *ot);
 void MESH_OT_uv_texture_remove(struct wmOperatorType *ot);
 void MESH_OT_vertex_color_add(struct wmOperatorType *ot);
@@ -191,40 +212,15 @@ void MESH_OT_vertex_color_remove(struct wmOperatorType *ot);
 /* no create_mask yet */
 void MESH_OT_customdata_clear_mask(struct wmOperatorType *ot);
 void MESH_OT_customdata_clear_skin(struct wmOperatorType *ot);
-
 void MESH_OT_drop_named_image(struct wmOperatorType *ot);
 
-/* ************* bmesh_tools.c ***********/
-void MESH_OT_vert_connect(struct wmOperatorType *ot);
-void MESH_OT_edge_split(struct wmOperatorType *ot);
-void MESH_OT_extrude_region(struct wmOperatorType *ot);
-void MESH_OT_extrude_verts_indiv(struct wmOperatorType *ot);
-void MESH_OT_extrude_edges_indiv(struct wmOperatorType *ot);
-void MESH_OT_extrude_faces_indiv(struct wmOperatorType *ot);
-
-void MESH_OT_edgering_select(struct wmOperatorType *ot);
-void MESH_OT_loopcut(struct wmOperatorType *ot);
-
-void MESH_OT_knife_tool(struct wmOperatorType *ot);
-void MESH_OT_knife_project(wmOperatorType *ot);
-
-void MESH_OT_bevel(struct wmOperatorType *ot);
 
-void MESH_OT_bridge_edge_loops(struct wmOperatorType *ot);
-void MESH_OT_inset(struct wmOperatorType *ot);
-void MESH_OT_wireframe(struct wmOperatorType *ot);
-
-void MESH_OT_convex_hull(struct wmOperatorType *ot);
-
-void MESH_OT_symmetrize(struct wmOperatorType *ot);
-
-/* ******************* mesh_navmesh.c */
+/* *** mesh_navmesh.c *** */
 void MESH_OT_navmesh_make(struct wmOperatorType *ot);
 void MESH_OT_navmesh_face_copy(struct wmOperatorType *ot);
 void MESH_OT_navmesh_face_add(struct wmOperatorType *ot);
 void MESH_OT_navmesh_reset(struct wmOperatorType *ot);
 void MESH_OT_navmesh_clear(struct wmOperatorType *ot);
 
-void EDBM_mesh_knife(struct bContext *C, struct LinkNode *polys, bool use_tag);
 
 #endif  /* __MESH_INTERN_H__ */
index 2111b6f34094073818ffb6737353238a8fc9c9a3..e6c36274687a56bb3292a865cd7030abf3cca622 100644 (file)
 #include "WM_api.h"
 #include "WM_types.h"
 
-#include "mesh_intern.h"
 #include "recast-capi.h"
 
+#include "mesh_intern.h"  /* own include */
+
 
 static void createVertsTrisData(bContext *C, LinkNode *obs,
                                 int *nverts_r, float **verts_r, int *ntris_r, int **tris_r, unsigned int *r_lay)
index 8a22a5533873a6de5c119286a5abdf2f1138e13e..a79923a4fdbe48c05011d688fed45dded1fe505b 100644 (file)
  *  \ingroup edmesh
  */
 
-
-
-
-
 #include "BLI_math.h"
 
-
 #include "RNA_access.h"
 
 #include "WM_api.h"
@@ -44,8 +39,7 @@
 #include "ED_mesh.h"
 #include "ED_screen.h"
 
-
-#include "mesh_intern.h"
+#include "mesh_intern.h"  /* own include */
 
 /**************************** registration **********************************/
 
index 562bc4a8e02cbb1470704dc14c31c0e4ebf76dc4..b34f43cd0821aa18f51b2139b7ea525ee266a212 100644 (file)
@@ -60,7 +60,6 @@
 #include "BKE_tessmesh.h"
 #include "BKE_multires.h"
 
-
 #include "ED_mesh.h"
 #include "ED_object.h"
 #include "ED_view3d.h"