code cleanup: make bmesh operator names more consistant since python has access to...
authorCampbell Barton <ideasman42@gmail.com>
Tue, 20 Nov 2012 05:50:19 +0000 (05:50 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Tue, 20 Nov 2012 05:50:19 +0000 (05:50 +0000)
all output values currently have ".out" suffix, this may go in the future, but for now it makes it clear in C code what are inputs and outputs.

36 files changed:
release/scripts/startup/bl_ui/space_view3d.py
source/blender/bmesh/intern/bmesh_opdefines.c
source/blender/bmesh/intern/bmesh_operators.h
source/blender/bmesh/operators/bmo_bevel.c
source/blender/bmesh/operators/bmo_connect.c
source/blender/bmesh/operators/bmo_create.c
source/blender/bmesh/operators/bmo_dissolve.c
source/blender/bmesh/operators/bmo_dupe.c
source/blender/bmesh/operators/bmo_edgesplit.c
source/blender/bmesh/operators/bmo_extrude.c
source/blender/bmesh/operators/bmo_hull.c
source/blender/bmesh/operators/bmo_inset.c
source/blender/bmesh/operators/bmo_mesh_conv.c
source/blender/bmesh/operators/bmo_mirror.c
source/blender/bmesh/operators/bmo_primitive.c
source/blender/bmesh/operators/bmo_removedoubles.c
source/blender/bmesh/operators/bmo_similar.c
source/blender/bmesh/operators/bmo_slide.c
source/blender/bmesh/operators/bmo_smooth_laplacian.c
source/blender/bmesh/operators/bmo_subdivide.c
source/blender/bmesh/operators/bmo_symmetrize.c
source/blender/bmesh/operators/bmo_triangulate.c
source/blender/bmesh/operators/bmo_utils.c
source/blender/bmesh/operators/bmo_wireframe.c
source/blender/editors/armature/editarmature.c
source/blender/editors/mesh/editmesh_add.c
source/blender/editors/mesh/editmesh_knife.c
source/blender/editors/mesh/editmesh_select.c
source/blender/editors/mesh/editmesh_slide.c
source/blender/editors/mesh/editmesh_tools.c
source/blender/editors/mesh/editmesh_utils.c
source/blender/makesdna/DNA_modifier_types.h
source/blender/makesrna/intern/rna_modifier.c
source/blender/modifiers/intern/MOD_array.c
source/blender/modifiers/intern/MOD_laplaciansmooth.c
source/blender/modifiers/intern/MOD_skin.c

index dad3f4a72ef7e208ce18eb8758de668a04fca387..b1dfc397ce0b61f1a7675c7c2813ba87a8454e69 100644 (file)
@@ -1838,8 +1838,8 @@ class VIEW3D_MT_edit_mesh_edges(Menu):
 
         layout.separator()
 
-        layout.operator("mesh.edge_rotate", text="Rotate Edge CW").direction = 'CW'
-        layout.operator("mesh.edge_rotate", text="Rotate Edge CCW").direction = 'CCW'
+        layout.operator("mesh.edge_rotate", text="Rotate Edge CW").use_ccw = False
+        layout.operator("mesh.edge_rotate", text="Rotate Edge CCW").use_ccw = True
 
         layout.separator()
 
@@ -1888,13 +1888,13 @@ class VIEW3D_MT_edit_mesh_faces(Menu):
 
         layout.separator()
 
-        layout.operator("mesh.edge_rotate", text="Rotate Edge CW").direction = 'CW'
+        layout.operator("mesh.edge_rotate", text="Rotate Edge CW").use_ccw = False
 
         layout.separator()
 
-        layout.operator_menu_enum("mesh.uvs_rotate", "direction")
+        layout.operator("mesh.uvs_rotate")
         layout.operator("mesh.uvs_reverse")
-        layout.operator_menu_enum("mesh.colors_rotate", "direction")
+        layout.operator("mesh.colors_rotate")
         layout.operator("mesh.colors_reverse")
 
 
index 539682454eadbd7c157719183fa3dfa05ea058d2..ec07eb5d9f7920beef96357d01a9d0794e210534 100644 (file)
@@ -47,9 +47,9 @@
  * "in" (e.g. edgefacein).  for three-type slots, use geom.
  *
  * for output slots, for single-type geometry slots, use the type name plus "out",
- * (e.g. vertout), for double-type slots, use the two type names plus "out",
- * (e.g. vertfaceout), for three-type slots, use geom.  note that you can also
- * use more esohteric names (e.g. skirtout) so long as the comment next to the
+ * (e.g. verts.out), for double-type slots, use the two type names plus "out",
+ * (e.g. vertfaces.out), for three-type slots, use geom.  note that you can also
+ * use more esohteric names (e.g. geom_skirt.out) so long as the comment next to the
  * slot definition tells you what types of elements are in it.
  *
  */
@@ -82,7 +82,7 @@
  * would be extracted from comments
  * next to them, e.g.
  *
- * {BMO_OP_SLOT_ELEMENT_BUF, "geomout"}, //output slot, boundary region
+ * {BMO_OP_SLOT_ELEMENT_BUF, "geom.out"}, //output slot, boundary region
  *
  * the doc generator would automatically detect the presence of "output slot"
  * and flag the slot as an output.  the same happens for "input slot".  also
  */
 static BMOpDefine bmo_smooth_vert_def = {
        "smooth_vert",
-       {{BMO_OP_SLOT_ELEMENT_BUF, "verts"}, /* input vertices */
-        {BMO_OP_SLOT_BOOL, "mirror_clip_x"}, /* set vertices close to the x axis before the operation to 0 */
-        {BMO_OP_SLOT_BOOL, "mirror_clip_y"}, /* set vertices close to the y axis before the operation to 0 */
-        {BMO_OP_SLOT_BOOL, "mirror_clip_z"}, /* set vertices close to the z axis before the operation to 0 */
-        {BMO_OP_SLOT_FLT, "clipdist"}, /* clipping threshod for the above three slots */
-        {BMO_OP_SLOT_BOOL, "use_axis_x"}, /* smooth vertices along X axis */
-        {BMO_OP_SLOT_BOOL, "use_axis_y"}, /* smooth vertices along Y axis */
-        {BMO_OP_SLOT_BOOL, "use_axis_z"}, /* smooth vertices along Z axis */
-       {0} /* null-terminating sentinel */,
+       /* slots_in */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "verts"},    /* input vertices */
+        {BMO_OP_SLOT_BOOL, "mirror_clip_x"},   /* set vertices close to the x axis before the operation to 0 */
+        {BMO_OP_SLOT_BOOL, "mirror_clip_y"},   /* set vertices close to the y axis before the operation to 0 */
+        {BMO_OP_SLOT_BOOL, "mirror_clip_z"},   /* set vertices close to the z axis before the operation to 0 */
+        {BMO_OP_SLOT_FLT,  "clip_dist"},       /* clipping threshod for the above three slots */
+        {BMO_OP_SLOT_BOOL, "use_axis_x"},      /* smooth vertices along X axis */
+        {BMO_OP_SLOT_BOOL, "use_axis_y"},      /* smooth vertices along Y axis */
+        {BMO_OP_SLOT_BOOL, "use_axis_z"},      /* smooth vertices along Z axis */
+       {0},
        },
        {{0}},  /* no output */
        bmo_smooth_vert_exec,
@@ -121,14 +122,15 @@ static BMOpDefine bmo_smooth_vert_def = {
  */
 static BMOpDefine bmo_smooth_laplacian_vert_def = {
        "smooth_laplacian_vert",
-       {{BMO_OP_SLOT_ELEMENT_BUF, "verts"}, //input vertices
-        {BMO_OP_SLOT_FLT, "lambda"}, //lambda param
-        {BMO_OP_SLOT_FLT, "lambda_border"}, //lambda param in border
-        {BMO_OP_SLOT_BOOL, "use_x"}, //Smooth object along X axis
-        {BMO_OP_SLOT_BOOL, "use_y"}, //Smooth object along Y axis
-        {BMO_OP_SLOT_BOOL, "use_z"}, //Smooth object along Z axis
-        {BMO_OP_SLOT_BOOL, "volume_preservation"}, //Apply volume preservation after smooth
-       {0} /* null-terminating sentinel */,
+       /* slots_in */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "verts"},    /* input vertices */
+        {BMO_OP_SLOT_FLT, "lambda"},           /* lambda param */
+        {BMO_OP_SLOT_FLT, "lambda_border"},    /* lambda param in border */
+        {BMO_OP_SLOT_BOOL, "use_x"},           /* Smooth object along X axis */
+        {BMO_OP_SLOT_BOOL, "use_y"},           /* Smooth object along Y axis */
+        {BMO_OP_SLOT_BOOL, "use_z"},           /* Smooth object along Z axis */
+        {BMO_OP_SLOT_BOOL, "preserve_volume"}, /* Apply volume preservation after smooth */
+       {0},
        },
        {{0}},  /* no output */
        bmo_smooth_laplacian_vert_exec,
@@ -143,9 +145,10 @@ static BMOpDefine bmo_smooth_laplacian_vert_def = {
 
 static BMOpDefine bmo_recalc_face_normals_def = {
        "recalc_face_normals",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "faces"},
-        {BMO_OP_SLOT_BOOL, "do_flip"}, /* internal flag, used by bmesh_rationalize_normals */
-        {0} /* null-terminating sentinel */,
+        {BMO_OP_SLOT_BOOL, "use_flip"},        /* internal flag, used by bmesh_rationalize_normals */
+        {0},
        },
        {{0}},  /* no output */
        bmo_recalc_face_normals_exec,
@@ -157,20 +160,22 @@ static BMOpDefine bmo_recalc_face_normals_def = {
  *
  * used to implement the select more/less tools.
  * this puts some geometry surrounding regions of
- * geometry in geom into geomout.
+ * geometry in geom into geom.out.
  *
- * if usefaces is 0 then geomout spits out verts and edges,
+ * if usefaces is 0 then geom.out spits out verts and edges,
  * otherwise it spits out faces.
  */
 static BMOpDefine bmo_region_extend_def = {
        "region_extend",
-       {{BMO_OP_SLOT_ELEMENT_BUF, "geom"}, /* input geometry */
-        {BMO_OP_SLOT_BOOL, "constrict"}, /* find boundary inside the regions, not outside. */
-        {BMO_OP_SLOT_BOOL, "use_faces"}, /* extend from faces instead of edges */
-        {0} /* null-terminating sentinel */,
+       /* slots_in */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "geom"},     /* input geometry */
+        {BMO_OP_SLOT_BOOL, "use_constrict"},   /* find boundary inside the regions, not outside. */
+        {BMO_OP_SLOT_BOOL, "use_faces"},       /* extend from faces instead of edges */
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "geomout"}, /* output slot, computed boundary geometry. */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "geom.out"}, /* output slot, computed boundary geometry. */
+        {0},
        },
        bmo_region_extend_exec,
        0
@@ -184,12 +189,14 @@ static BMOpDefine bmo_region_extend_def = {
  */
 static BMOpDefine bmo_rotate_edges_def = {
        "rotate_edges",
-       {{BMO_OP_SLOT_ELEMENT_BUF, "edges"}, /* input edges */
-        {BMO_OP_SLOT_BOOL, "ccw"}, /* rotate edge counter-clockwise if true, othewise clockwise */
-        {0} /* null-terminating sentinel */,
+       /* slots_in */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "edges"},    /* input edges */
+        {BMO_OP_SLOT_BOOL, "use_ccw"},         /* rotate edge counter-clockwise if true, othewise clockwise */
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "edgeout"}, /* newly spun edges */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "edges.out"}, /* newly spun edges */
+        {0},
        },
        bmo_rotate_edges_exec,
        BMO_OP_FLAG_UNTAN_MULTIRES
@@ -203,8 +210,9 @@ static BMOpDefine bmo_rotate_edges_def = {
  */
 static BMOpDefine bmo_reverse_faces_def = {
        "reverse_faces",
-       {{BMO_OP_SLOT_ELEMENT_BUF, "faces"}, /* input faces */
-        {0} /* null-terminating sentinel */,
+       /* slots_in */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "faces"},    /* input faces */
+        {0},
        },
        {{0}},  /* no output */
        bmo_reverse_faces_exec,
@@ -219,12 +227,14 @@ static BMOpDefine bmo_reverse_faces_def = {
  */
 static BMOpDefine bmo_bisect_edges_def = {
        "bisect_edges",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "edges"}, /* input edges */
-        {BMO_OP_SLOT_INT, "numcuts"}, /* number of cuts */
-        {0} /* null-terminating sentinel */,
+        {BMO_OP_SLOT_INT, "cuts"}, /* number of cuts */
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "splitout"}, /* newly created vertices and edges */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "geom_split.out"}, /* newly created vertices and edges */
+        {0},
        },
        bmo_bisect_edges_exec,
        BMO_OP_FLAG_UNTAN_MULTIRES
@@ -234,22 +244,24 @@ static BMOpDefine bmo_bisect_edges_def = {
  * Mirror
  *
  * Mirrors geometry along an axis.  The resulting geometry is welded on using
- * mergedist.  Pairs of original/mirrored vertices are welded using the mergedist
+ * merge_dist.  Pairs of original/mirrored vertices are welded using the merge_dist
  * parameter (which defines the minimum distance for welding to happen).
  */
 
 static BMOpDefine bmo_mirror_def = {
        "mirror",
-       {{BMO_OP_SLOT_ELEMENT_BUF, "geom"}, /* input geometry */
-        {BMO_OP_SLOT_MAT, "mat"}, /* matrix defining the mirror transformation */
-        {BMO_OP_SLOT_FLT, "mergedist"}, /* maximum distance for merging.  does no merging if 0. */
-        {BMO_OP_SLOT_INT,         "axis"}, /* the axis to use, 0, 1, or 2 for x, y, z */
+       /* slots_in */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "geom"},     /* input geometry */
+        {BMO_OP_SLOT_MAT,         "mat"},      /* matrix defining the mirror transformation */
+        {BMO_OP_SLOT_FLT, "merge_dist"},       /* maximum distance for merging.  does no merging if 0. */
+        {BMO_OP_SLOT_INT,         "axis"},     /* the axis to use, 0, 1, or 2 for x, y, z */
         {BMO_OP_SLOT_BOOL,        "mirror_u"}, /* mirror UVs across the u axis */
         {BMO_OP_SLOT_BOOL,        "mirror_v"}, /* mirror UVs across the v axis */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "newout"}, /* output geometry, mirrored */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "geom.out"}, /* output geometry, mirrored */
+        {0},
        },
        bmo_mirror_exec,
        0,
@@ -266,13 +278,15 @@ static BMOpDefine bmo_mirror_def = {
  */
 static BMOpDefine bmo_find_doubles_def = {
        "find_doubles",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "verts"}, /* input vertices */
         {BMO_OP_SLOT_ELEMENT_BUF, "keep_verts"}, /* list of verts to keep */
         {BMO_OP_SLOT_FLT,         "dist"}, /* minimum distance */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
-       {{BMO_OP_SLOT_MAPPING, "targetmapout"},
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_MAPPING, "targetmap.out"},
+        {0},
        },
        bmo_find_doubles_exec,
        0,
@@ -286,9 +300,10 @@ static BMOpDefine bmo_find_doubles_def = {
  */
 static BMOpDefine bmo_remove_doubles_def = {
        "remove_doubles",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "verts"}, /* input verts */
         {BMO_OP_SLOT_FLT,         "dist"}, /* minimum distance */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
        {{0}},  /* no output */
        bmo_remove_doubles_exec,
@@ -304,9 +319,10 @@ static BMOpDefine bmo_remove_doubles_def = {
  */
 static BMOpDefine bmo_automerge_def = {
        "automerge",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "verts"}, /* input verts */
         {BMO_OP_SLOT_FLT,         "dist"}, /* minimum distance */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
        {{0}},  /* no output */
        bmo_automerge_exec,
@@ -320,8 +336,9 @@ static BMOpDefine bmo_automerge_def = {
  */
 static BMOpDefine bmo_collapse_def = {
        "collapse",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "edges"}, /* input edge */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
        {{0}},  /* no output */
        bmo_collapse_exec,
@@ -336,9 +353,10 @@ static BMOpDefine bmo_collapse_def = {
  */
 static BMOpDefine bmo_pointmerge_facedata_def = {
        "pointmerge_facedata",
-       {{BMO_OP_SLOT_ELEMENT_BUF, "verts"}, /* input vertice */
-        {BMO_OP_SLOT_ELEMENT_BUF, "snapv"}, /* snap verte */
-        {0} /* null-terminating sentinel */,
+       /* slots_in */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "verts"},    /* input vertices */
+        {BMO_OP_SLOT_ELEMENT_BUF, "snapv"},    /* snap vertex */
+        {0},
        },
        {{0}},  /* no output */
        bmo_pointmerge_facedata_exec,
@@ -354,8 +372,9 @@ static BMOpDefine bmo_pointmerge_facedata_def = {
  */
 static BMOpDefine bmo_average_vert_facedata_def = {
        "average_vert_facedata",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "verts"}, /* input vertice */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
        {{0}},  /* no output */
        bmo_average_vert_facedata_exec,
@@ -369,9 +388,10 @@ static BMOpDefine bmo_average_vert_facedata_def = {
  */
 static BMOpDefine bmo_pointmerge_def = {
        "pointmerge",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "verts"}, /* input vertice */
         {BMO_OP_SLOT_VEC,         "merge_co"},
-        {0} /* null-terminating sentinel */,
+        {0},
        },
        {{0}},  /* no output */
        bmo_pointmerge_exec,
@@ -385,8 +405,9 @@ static BMOpDefine bmo_pointmerge_def = {
  */
 static BMOpDefine bmo_collapse_uvs_def = {
        "collapse_uvs",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "edges"}, /* input edge */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
        {{0}},  /* no output */
        bmo_collapse_uvs_exec,
@@ -402,8 +423,9 @@ static BMOpDefine bmo_collapse_uvs_def = {
  */
 static BMOpDefine bmo_weld_verts_def = {
        "weld_verts",
+       /* slots_in */
        {{BMO_OP_SLOT_MAPPING, "targetmap"}, /* maps welded vertices to verts they should weld to */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
        {{0}},  /* no output */
        bmo_weld_verts_exec,
@@ -418,11 +440,13 @@ static BMOpDefine bmo_weld_verts_def = {
  */
 static BMOpDefine bmo_create_vert_def = {
        "create_vert",
+       /* slots_in */
        {{BMO_OP_SLOT_VEC, "co"},  /* the coordinate of the new vert */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "newvertout"},  /* the new vert */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "vert.out"},  /* the new vert */
+        {0},
        },
        bmo_create_vert_exec,
        0,
@@ -436,16 +460,18 @@ static BMOpDefine bmo_create_vert_def = {
  */
 static BMOpDefine bmo_join_triangles_def = {
        "join_triangles",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "faces"},    /* input geometry. */
         {BMO_OP_SLOT_BOOL, "cmp_sharp"},
         {BMO_OP_SLOT_BOOL, "cmp_uvs"},
         {BMO_OP_SLOT_BOOL, "cmp_vcols"},
         {BMO_OP_SLOT_BOOL, "cmp_materials"},
         {BMO_OP_SLOT_FLT, "limit"},
-        {0} /* null-terminating sentinel */,
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "faceout"},  /* joined faces */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "faces.out"},  /* joined faces */
+        {0},
        },
        bmo_join_triangles_exec,
        BMO_OP_FLAG_UNTAN_MULTIRES,
@@ -464,15 +490,17 @@ static BMOpDefine bmo_join_triangles_def = {
  */
 static BMOpDefine bmo_contextual_create_def = {
        "contextual_create",
-       {{BMO_OP_SLOT_ELEMENT_BUF, "geom"}, /* input geometry. */
-        {BMO_OP_SLOT_INT,         "mat_nr"},      /* material to use */
-        {BMO_OP_SLOT_BOOL,        "use_smooth"},  /* smooth to use */
-        {0} /* null-terminating sentinel */,
-       },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "faceout"},     /* newly-made face(s) */
+       /* slots_in */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "geom"},     /* input geometry. */
+        {BMO_OP_SLOT_INT,         "mat_nr"},   /* material to use */
+        {BMO_OP_SLOT_BOOL,        "use_smooth"}, /* smooth to use */
+        {0},
+       },
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "faces.out"}, /* newly-made face(s) */
        /* note, this is for stand-alone edges only, not edges which are apart of newly created faces */
-        {BMO_OP_SLOT_ELEMENT_BUF, "edgeout"},     /* newly-made edge(s) */
-        {0} /* null-terminating sentinel */,
+        {BMO_OP_SLOT_ELEMENT_BUF, "edges.out"}, /* newly-made edge(s) */
+        {0},
        },
        bmo_contextual_create_exec,
        BMO_OP_FLAG_UNTAN_MULTIRES,
@@ -483,13 +511,15 @@ static BMOpDefine bmo_contextual_create_def = {
  */
 static BMOpDefine bmo_bridge_loops_def = {
        "bridge_loops",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "edges"}, /* input edge */
         {BMO_OP_SLOT_BOOL,        "use_merge"},
         {BMO_OP_SLOT_FLT,         "merge_factor"},
-        {0} /* null-terminating sentinel */,
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "faceout"}, /* new faces */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "faces.out"}, /* new faces */
+        {0},
        },
        bmo_bridge_loops_exec,
        0,
@@ -497,18 +527,20 @@ static BMOpDefine bmo_bridge_loops_def = {
 
 static BMOpDefine bmo_edgenet_fill_def = {
        "edgenet_fill",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "edges"}, /* input edge */
         {BMO_OP_SLOT_MAPPING,     "restrict"}, /* restricts edges to groups.  maps edges to integer */
         {BMO_OP_SLOT_BOOL,        "use_restrict"},
         {BMO_OP_SLOT_BOOL,        "use_fill_check"},
-        {BMO_OP_SLOT_ELEMENT_BUF, "excludefaces"}, /* list of faces to ignore for manifold check */
+        {BMO_OP_SLOT_ELEMENT_BUF, "exclude_faces"}, /* list of faces to ignore for manifold check */
         {BMO_OP_SLOT_INT,         "mat_nr"},      /* material to use */
         {BMO_OP_SLOT_BOOL,        "use_smooth"},  /* material to use */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
-       {{BMO_OP_SLOT_MAPPING,     "face_groupmap_out"}, /* maps new faces to the group numbers they came fro */
-        {BMO_OP_SLOT_ELEMENT_BUF, "faceout"},     /* new face */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_MAPPING,     "face_groupmap.out"}, /* maps new faces to the group numbers they came from */
+        {BMO_OP_SLOT_ELEMENT_BUF, "faces.out"},     /* new face */
+        {0},
        },
        bmo_edgenet_fill_exec,
        0,
@@ -526,11 +558,13 @@ static BMOpDefine bmo_edgenet_fill_def = {
  */
 static BMOpDefine bmo_edgenet_prepare_def = {
        "edgenet_prepare",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "edges"},    /* input edges */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "edgeout"},  /* new edges */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "edges.out"},  /* new edges */
+        {0},
        },
        bmo_edgenet_prepare,
        0,
@@ -544,10 +578,11 @@ static BMOpDefine bmo_edgenet_prepare_def = {
  */
 static BMOpDefine bmo_rotate_def = {
        "rotate",
+       /* slots_in */
        {{BMO_OP_SLOT_VEC, "cent"},  /* center of rotation */
         {BMO_OP_SLOT_MAT, "mat"},   /* matrix defining rotation */
         {BMO_OP_SLOT_ELEMENT_BUF, "verts"},  /* input vertices */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
        {{0}},  /* no output */
        bmo_rotate_exec,
@@ -562,9 +597,10 @@ static BMOpDefine bmo_rotate_def = {
  */
 static BMOpDefine bmo_translate_def = {
        "translate",
+       /* slots_in */
        {{BMO_OP_SLOT_VEC, "vec"},  /* translation offset */
         {BMO_OP_SLOT_ELEMENT_BUF, "verts"},  /* input vertices */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
        {{0}},  /* no output */
        bmo_translate_exec,
@@ -578,9 +614,10 @@ static BMOpDefine bmo_translate_def = {
  */
 static BMOpDefine bmo_scale_def = {
        "scale",
+       /* slots_in */
        {{BMO_OP_SLOT_VEC, "vec"},  /* scale factor */
         {BMO_OP_SLOT_ELEMENT_BUF, "verts"},  /* input vertices */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
        {{0}},  /* no output */
        bmo_scale_exec,
@@ -596,9 +633,10 @@ static BMOpDefine bmo_scale_def = {
  */
 static BMOpDefine bmo_transform_def = {
        "transform",
+       /* slots_in */
        {{BMO_OP_SLOT_MAT, "mat"},  /* transform matrix */
         {BMO_OP_SLOT_ELEMENT_BUF, "verts"},  /* input vertices */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
        {{0}},  /* no output */
        bmo_transform_exec,
@@ -613,9 +651,10 @@ static BMOpDefine bmo_transform_def = {
  */
 static BMOpDefine bmo_object_load_bmesh_def = {
        "object_load_bmesh",
+       /* slots_in */
        {{BMO_OP_SLOT_PTR, "scene"},
         {BMO_OP_SLOT_PTR, "object"},
-        {0} /* null-terminating sentinel */,
+        {0},
        },
        {{0}},  /* no output */
        bmo_object_load_bmesh_exec,
@@ -630,10 +669,11 @@ static BMOpDefine bmo_object_load_bmesh_def = {
  */
 static BMOpDefine bmo_bmesh_to_mesh_def = {
        "bmesh_to_mesh",
+       /* slots_in */
        {{BMO_OP_SLOT_PTR, "mesh"},    /* pointer to a mesh structure to fill in */
         {BMO_OP_SLOT_PTR, "object"},  /* pointer to an object structure */
-        {BMO_OP_SLOT_BOOL, "notessellation"},  /* don't calculate mfaces */
-        {0} /* null-terminating sentinel */,
+        {BMO_OP_SLOT_BOOL, "skip_tessface"},  /* don't calculate mfaces */
+        {0},
        },
        {{0}},  /* no output */
        bmo_bmesh_to_mesh_exec,
@@ -648,10 +688,11 @@ static BMOpDefine bmo_bmesh_to_mesh_def = {
  */
 static BMOpDefine bmo_mesh_to_bmesh_def = {
        "mesh_to_bmesh",
+       /* slots_in */
        {{BMO_OP_SLOT_PTR, "mesh"},    /* pointer to a Mesh structure */
         {BMO_OP_SLOT_PTR, "object"},  /* pointer to an Object structure */
-        {BMO_OP_SLOT_BOOL, "set_shapekey"},  /* load active shapekey coordinates into verts */
-        {0} /* null-terminating sentinel */,
+        {BMO_OP_SLOT_BOOL, "use_shapekey"},  /* load active shapekey coordinates into verts */
+        {0},
        },
        {{0}},  /* no output */
        bmo_mesh_to_bmesh_exec,
@@ -665,12 +706,14 @@ static BMOpDefine bmo_mesh_to_bmesh_def = {
  */
 static BMOpDefine bmo_extrude_discrete_faces_def = {
        "extrude_discrete_faces",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "faces"},     /* input faces */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "faceout"},   /* output faces */
-        {BMO_OP_SLOT_ELEMENT_BUF, "skirtout"},  /* output skirt geometry, faces and edges */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "faces.out"},   /* output faces */
+        {BMO_OP_SLOT_ELEMENT_BUF, "geom_skirt.out"},  /* output skirt geometry, faces and edges */
+        {0},
        },
        bmo_extrude_discrete_faces_exec,
        0
@@ -684,11 +727,13 @@ static BMOpDefine bmo_extrude_discrete_faces_def = {
  */
 static BMOpDefine bmo_extrude_edge_only_def = {
        "extrude_edge_only",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "edges"},    /* input vertices */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "geomout"},  /* output geometry */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "geom.out"},  /* output geometry */
+        {0},
        },
        bmo_extrude_edge_only_exec,
        0
@@ -701,12 +746,14 @@ static BMOpDefine bmo_extrude_edge_only_def = {
  */
 static BMOpDefine bmo_extrude_vert_indiv_def = {
        "extrude_vert_indiv",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "verts"},    /* input vertices */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "edgeout"},  /* output wire edges */
-        {BMO_OP_SLOT_ELEMENT_BUF, "vertout"},  /* output vertices */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "edges.out"},  /* output wire edges */
+        {BMO_OP_SLOT_ELEMENT_BUF, "verts.out"},  /* output vertices */
+        {0},
        },
        bmo_extrude_vert_indiv_exec,
        0
@@ -714,11 +761,13 @@ static BMOpDefine bmo_extrude_vert_indiv_def = {
 
 static BMOpDefine bmo_connect_verts_def = {
        "connect_verts",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "verts"},
-        {0} /* null-terminating sentinel */,
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "edgeout"},
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "edges.out"},
+        {0},
        },
        bmo_connect_verts_exec,
        BMO_OP_FLAG_UNTAN_MULTIRES
@@ -726,13 +775,15 @@ static BMOpDefine bmo_connect_verts_def = {
 
 static BMOpDefine bmo_extrude_face_region_def = {
        "extrude_face_region",
-       {{BMO_OP_SLOT_ELEMENT_BUF, "edgefacein"},
-        {BMO_OP_SLOT_MAPPING, "exclude"},
-        {BMO_OP_SLOT_BOOL, "alwayskeeporig"},
-        {0} /* null-terminating sentinel */,
+       /* slots_in */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "geom"},     /* edges and faces */
+        {BMO_OP_SLOT_MAPPING, "edges_exclude"},
+        {BMO_OP_SLOT_BOOL, "use_keep_orig"},   /* keep original geometry */
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "geomout"},
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "geom.out"},
+        {0},
        },
        bmo_extrude_face_region_exec,
        0
@@ -740,8 +791,9 @@ static BMOpDefine bmo_extrude_face_region_def = {
 
 static BMOpDefine bmo_dissolve_verts_def = {
        "dissolve_verts",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "verts"},
-        {0} /* null-terminating sentinel */,
+        {0},
        },
        {{0}},  /* no output */
        bmo_dissolve_verts_exec,
@@ -750,12 +802,14 @@ static BMOpDefine bmo_dissolve_verts_def = {
 
 static BMOpDefine bmo_dissolve_edges_def = {
        "dissolve_edges",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "edges"},
         {BMO_OP_SLOT_BOOL, "use_verts"},  /* dissolve verts left between only 2 edges. */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "regionout"},
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "region.out"},
+        {0},
        },
        bmo_dissolve_edges_exec,
        BMO_OP_FLAG_UNTAN_MULTIRES
@@ -763,11 +817,13 @@ static BMOpDefine bmo_dissolve_edges_def = {
 
 static BMOpDefine bmo_dissolve_edge_loop_def = {
        "dissolve_edge_loop",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "edges"},
-        {0} /* null-terminating sentinel */,
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "regionout"},
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "region.out"},
+        {0},
        },
        bmo_dissolve_edgeloop_exec,
        BMO_OP_FLAG_UNTAN_MULTIRES
@@ -775,12 +831,14 @@ static BMOpDefine bmo_dissolve_edge_loop_def = {
 
 static BMOpDefine bmo_dissolve_faces_def = {
        "dissolve_faces",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "faces"},
         {BMO_OP_SLOT_BOOL, "use_verts"},  /* dissolve verts left between only 2 edges. */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "regionout"},
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "region.out"},
+        {0},
        },
        bmo_dissolve_faces_exec,
        BMO_OP_FLAG_UNTAN_MULTIRES
@@ -788,11 +846,12 @@ static BMOpDefine bmo_dissolve_faces_def = {
 
 static BMOpDefine bmo_dissolve_limit_def = {
        "dissolve_limit",
+       /* slots_in */
        {{BMO_OP_SLOT_FLT, "angle_limit"}, /* total rotation angle (degrees) */
         {BMO_OP_SLOT_BOOL, "use_dissolve_boundaries"},
         {BMO_OP_SLOT_ELEMENT_BUF, "verts"},
         {BMO_OP_SLOT_ELEMENT_BUF, "edges"},
-        {0} /* null-terminating sentinel */,
+        {0},
        },
        {{0}},  /* no output */
        bmo_dissolve_limit_exec,
@@ -801,14 +860,16 @@ static BMOpDefine bmo_dissolve_limit_def = {
 
 static BMOpDefine bmo_triangulate_def = {
        "triangulate",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "faces"},
         {BMO_OP_SLOT_BOOL, "use_beauty"},
-        {0} /* null-terminating sentinel */,
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "edgeout"},
-        {BMO_OP_SLOT_ELEMENT_BUF, "faceout"},
-        {BMO_OP_SLOT_MAPPING, "facemap_out"},
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "edges.out"},
+        {BMO_OP_SLOT_ELEMENT_BUF, "faces.out"},
+        {BMO_OP_SLOT_MAPPING, "facemap.out"},
+        {0},
        },
        bmo_triangulate_exec,
        BMO_OP_FLAG_UNTAN_MULTIRES
@@ -816,9 +877,10 @@ static BMOpDefine bmo_triangulate_def = {
 
 static BMOpDefine bmo_unsubdivide_def = {
        "unsubdivide",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "verts"}, /* input vertices */
         {BMO_OP_SLOT_INT, "iterations"},
-        {0} /* null-terminating sentinel */,
+        {0},
        },
        {{0}},  /* no output */
        bmo_unsubdivide_exec,
@@ -827,26 +889,28 @@ static BMOpDefine bmo_unsubdivide_def = {
 
 static BMOpDefine bmo_subdivide_edges_def = {
        "subdivide_edges",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "edges"},
         {BMO_OP_SLOT_FLT, "smooth"},
         {BMO_OP_SLOT_FLT, "fractal"},
         {BMO_OP_SLOT_FLT, "along_normal"},
-        {BMO_OP_SLOT_INT, "numcuts"},
+        {BMO_OP_SLOT_INT, "cuts"},
         {BMO_OP_SLOT_INT, "seed"},
         {BMO_OP_SLOT_MAPPING, "custompatterns"},
         {BMO_OP_SLOT_MAPPING, "edgepercents"},
 
-        {BMO_OP_SLOT_INT,  "quadcornertype"}, /* quad corner type, see bmesh_operators.h */
+        {BMO_OP_SLOT_INT,  "quad_corner_type"}, /* quad corner type, see bmesh_operators.h */
         {BMO_OP_SLOT_BOOL, "use_gridfill"},   /* fill in fully-selected faces with a grid */
         {BMO_OP_SLOT_BOOL, "use_singleedge"}, /* tessellate the case of one edge selected in a quad or triangle */
         {BMO_OP_SLOT_BOOL, "use_sphere"},     /* for making new primitives only */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
+       /* slots_out */
        {/* these next three can have multiple types of elements in them */
-        {BMO_OP_SLOT_ELEMENT_BUF, "innerout"},
-        {BMO_OP_SLOT_ELEMENT_BUF, "splitout"},
-        {BMO_OP_SLOT_ELEMENT_BUF, "geomout"}, /* contains all output geometr */
-        {0} /* null-terminating sentinel */,
+        {BMO_OP_SLOT_ELEMENT_BUF, "geom_inner.out"},
+        {BMO_OP_SLOT_ELEMENT_BUF, "geom_split.out"},
+        {BMO_OP_SLOT_ELEMENT_BUF, "geom.out"}, /* contains all output geometr */
+        {0},
        },
        bmo_subdivide_edges_exec,
        BMO_OP_FLAG_UNTAN_MULTIRES
@@ -854,9 +918,10 @@ static BMOpDefine bmo_subdivide_edges_def = {
 
 static BMOpDefine bmo_delete_def = {
        "delete",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "geom"},
         {BMO_OP_SLOT_INT, "context"},
-        {0} /* null-terminating sentinel */,
+        {0},
        },
        {{0}},  /* no output */
        bmo_delete_exec,
@@ -865,18 +930,20 @@ static BMOpDefine bmo_delete_def = {
 
 static BMOpDefine bmo_duplicate_def = {
        "duplicate",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "geom"},
         {BMO_OP_SLOT_PTR, "dest"}, /* destination bmesh, if NULL will use current on */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "origout"},
-        {BMO_OP_SLOT_ELEMENT_BUF, "newout"},
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "geom_orig.out"},
+        {BMO_OP_SLOT_ELEMENT_BUF, "geom.out"},
        /* facemap maps from source faces to dupe
         * faces, and from dupe faces to source faces */
-        {BMO_OP_SLOT_MAPPING, "facemap_out"},
-        {BMO_OP_SLOT_MAPPING, "boundarymap_out"},
-        {BMO_OP_SLOT_MAPPING, "isovertmap_out"},
-       {0} /* null-terminating sentinel */,
+        {BMO_OP_SLOT_MAPPING, "facemap.out"},
+        {BMO_OP_SLOT_MAPPING, "boundarymap.out"},
+        {BMO_OP_SLOT_MAPPING, "isovertmap.out"},
+       {0},
        },
        bmo_duplicate_exec,
        0
@@ -884,15 +951,17 @@ static BMOpDefine bmo_duplicate_def = {
 
 static BMOpDefine bmo_split_def = {
        "split",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "geom"},
-        {BMO_OP_SLOT_PTR, "dest"}, /* destination bmesh, if NULL will use current on */
-        {BMO_OP_SLOT_BOOL, "use_only_faces"}, /* when enabled. don't duplicate loose verts/edges */
-        {0} /* null-terminating sentinel */,
+        {BMO_OP_SLOT_PTR, "dest"},             /* destination bmesh, if NULL will use current one */
+        {BMO_OP_SLOT_BOOL, "use_only_faces"},  /* when enabled. don't duplicate loose verts/edges */
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "geomout"},
-        {BMO_OP_SLOT_MAPPING, "boundarymap_out"},
-        {BMO_OP_SLOT_MAPPING, "isovertmap_out"},
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "geom.out"},
+        {BMO_OP_SLOT_MAPPING, "boundarymap.out"},
+        {BMO_OP_SLOT_MAPPING, "isovertmap.out"},
+        {0},
        },
        bmo_split_exec,
        0
@@ -906,17 +975,19 @@ static BMOpDefine bmo_split_def = {
  */
 static BMOpDefine bmo_spin_def = {
        "spin",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "geom"},
-        {BMO_OP_SLOT_VEC, "cent"}, /* rotation center */
-        {BMO_OP_SLOT_VEC, "axis"}, /* rotation axis */
-        {BMO_OP_SLOT_VEC, "dvec"}, /* translation delta per step */
-        {BMO_OP_SLOT_FLT, "ang"}, /* total rotation angle (degrees) */
-        {BMO_OP_SLOT_INT, "steps"}, /* number of steps */
-        {BMO_OP_SLOT_BOOL, "do_dupli"}, /* duplicate or extrude? */
-        {0} /* null-terminating sentinel */,
-       },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "lastout"}, /* result of last step */
-        {0} /* null-terminating sentinel */,
+        {BMO_OP_SLOT_VEC, "cent"},             /* rotation center */
+        {BMO_OP_SLOT_VEC, "axis"},             /* rotation axis */
+        {BMO_OP_SLOT_VEC, "dvec"},             /* translation delta per step */
+        {BMO_OP_SLOT_FLT, "angle"},            /* total rotation angle (degrees) */
+        {BMO_OP_SLOT_INT, "steps"},            /* number of steps */
+        {BMO_OP_SLOT_BOOL, "use_duplicate"},   /* duplicate or extrude? */
+        {0},
+       },
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "geom_last.out"}, /* result of last step */
+        {0},
        },
        bmo_spin_exec,
        0
@@ -930,14 +1001,16 @@ static BMOpDefine bmo_spin_def = {
  */
 static BMOpDefine bmo_similar_faces_def = {
        "similar_faces",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "faces"},    /* input faces */
         {BMO_OP_SLOT_INT, "type"},             /* type of selection */
         {BMO_OP_SLOT_FLT, "thresh"},           /* threshold of selection */
         {BMO_OP_SLOT_INT, "compare"},          /* comparison method */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "faceout"},  /* output faces */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "faces.out"},  /* output faces */
+        {0},
        },
        bmo_similar_faces_exec,
        0
@@ -950,14 +1023,16 @@ static BMOpDefine bmo_similar_faces_def = {
  */
 static BMOpDefine bmo_similar_edges_def = {
        "similar_edges",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "edges"},    /* input edges */
         {BMO_OP_SLOT_INT, "type"},             /* type of selection */
         {BMO_OP_SLOT_FLT, "thresh"},           /* threshold of selection */
         {BMO_OP_SLOT_INT, "compare"},          /* comparison method */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "edgeout"},  /* output edges */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "edges.out"},  /* output edges */
+        {0},
        },
        bmo_similar_edges_exec,
        0
@@ -970,14 +1045,16 @@ static BMOpDefine bmo_similar_edges_def = {
  */
 static BMOpDefine bmo_similar_verts_def = {
        "similar_verts",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "verts"},    /* input vertices */
         {BMO_OP_SLOT_INT, "type"},             /* type of selection */
         {BMO_OP_SLOT_FLT, "thresh"},           /* threshold of selection */
         {BMO_OP_SLOT_INT, "compare"},          /* comparison method */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "vertout"},  /* output vertices */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "verts.out"},  /* output vertices */
+        {0},
        },
        bmo_similar_verts_exec,
        0
@@ -989,10 +1066,12 @@ static BMOpDefine bmo_similar_verts_def = {
  */
 static BMOpDefine bmo_rotate_uvs_def = {
        "rotate_uvs",
-       {{BMO_OP_SLOT_ELEMENT_BUF, "faces"}, /* input faces */
-        {BMO_OP_SLOT_INT, "dir"},                      /* direction */
-        {0} /* null-terminating sentinel */,
+       /* slots_in */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "faces"},    /* input faces */
+        {BMO_OP_SLOT_BOOL, "use_ccw"},         /* rotate counter-clockwise if true, othewise clockwise */
+        {0},
        },
+       /* slots_out */
        {{0}},  /* no output */
        bmo_rotate_uvs_exec,
        0
@@ -1004,8 +1083,9 @@ static BMOpDefine bmo_rotate_uvs_def = {
  */
 static BMOpDefine bmo_reverse_uvs_def = {
        "reverse_uvs",
-       {{BMO_OP_SLOT_ELEMENT_BUF, "faces"}, /* input faces */
-        {0} /* null-terminating sentinel */,
+       /* slots_in */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "faces"},    /* input faces */
+        {0},
        },
        {{0}},  /* no output */
        bmo_reverse_uvs_exec,
@@ -1018,9 +1098,10 @@ static BMOpDefine bmo_reverse_uvs_def = {
  */
 static BMOpDefine bmo_rotate_colors_def = {
        "rotate_colors",
-       {{BMO_OP_SLOT_ELEMENT_BUF, "faces"}, /* input faces */
-        {BMO_OP_SLOT_INT, "dir"},           /* direction */
-        {0} /* null-terminating sentinel */,
+       /* slots_in */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "faces"},    /* input faces */
+        {BMO_OP_SLOT_BOOL, "use_ccw"},         /* rotate counter-clockwise if true, othewise clockwise */
+        {0},
        },
        {{0}},  /* no output */
        bmo_rotate_colors_exec,
@@ -1033,8 +1114,9 @@ static BMOpDefine bmo_rotate_colors_def = {
  */
 static BMOpDefine bmo_reverse_colors_def = {
        "reverse_colors",
-       {{BMO_OP_SLOT_ELEMENT_BUF, "faces"}, /* input faces */
-        {0} /* null-terminating sentinel */,
+       /* slots_in */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "faces"},    /* input faces */
+        {0},
        },
        {{0}},  /* no output */
        bmo_reverse_colors_exec,
@@ -1048,13 +1130,15 @@ static BMOpDefine bmo_reverse_colors_def = {
  */
 static BMOpDefine bmo_shortest_path_def = {
        "shortest_path",
-       {{BMO_OP_SLOT_ELEMENT_BUF, "startv"}, /* start vertex */
-        {BMO_OP_SLOT_ELEMENT_BUF, "endv"}, /* end vertex */
-        {BMO_OP_SLOT_INT, "type"},                     /* type of selection */
-        {0} /* null-terminating sentinel */,
+       /* slots_in */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "startv"},   /* start vertex */
+        {BMO_OP_SLOT_ELEMENT_BUF, "endv"},     /* end vertex */
+        {BMO_OP_SLOT_INT, "type"},             /* type of selection */
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "vertout"}, /* output vertices */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "verts.out"}, /* output vertices */
+        {0},
        },
        bmo_shortest_path_exec,
        0
@@ -1067,14 +1151,16 @@ static BMOpDefine bmo_shortest_path_def = {
  */
 static BMOpDefine bmo_split_edges_def = {
        "split_edges",
-       {{BMO_OP_SLOT_ELEMENT_BUF, "edges"}, /* input edges */
+       /* slots_in */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "edges"},    /* input edges */
         /* needed for vertex rip so we can rip only half an edge at a boundary wich would otherwise split off */
-        {BMO_OP_SLOT_ELEMENT_BUF, "verts"}, /* optional tag verts, use to have greater control of splits */
+        {BMO_OP_SLOT_ELEMENT_BUF, "verts"},    /* optional tag verts, use to have greater control of splits */
         {BMO_OP_SLOT_BOOL,        "use_verts"}, /* use 'verts' for splitting, else just find verts to split from edges */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "edgeout"}, /* old output disconnected edges */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "edges.out"}, /* old output disconnected edges */
+        {0},
        },
        bmo_split_edges_exec,
        BMO_OP_FLAG_UNTAN_MULTIRES
@@ -1087,14 +1173,16 @@ static BMOpDefine bmo_split_edges_def = {
  */
 static BMOpDefine bmo_create_grid_def = {
        "create_grid",
-       {{BMO_OP_SLOT_INT,         "xsegments"}, /* number of x segments */
-        {BMO_OP_SLOT_INT,         "ysegments"}, /* number of y segments */
-        {BMO_OP_SLOT_FLT,         "size"}, /* size of the grid */
-        {BMO_OP_SLOT_MAT,         "mat"}, /* matrix to multiply the new geometry with */
-        {0} /* null-terminating sentinel */,
+       /* slots_in */
+       {{BMO_OP_SLOT_INT,         "x_segments"}, /* number of x segments */
+        {BMO_OP_SLOT_INT,         "y_segments"}, /* number of y segments */
+        {BMO_OP_SLOT_FLT,         "size"},     /* size of the grid */
+        {BMO_OP_SLOT_MAT,         "mat"},      /* matrix to multiply the new geometry with */
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "vertout"}, /* output verts */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "verts.out"}, /* output verts */
+        {0},
        },
        bmo_create_grid_exec,
        0,
@@ -1107,14 +1195,16 @@ static BMOpDefine bmo_create_grid_def = {
  */
 static BMOpDefine bmo_create_uvsphere_def = {
        "create_uvsphere",
-       {{BMO_OP_SLOT_INT,         "segments"}, /* number of u segments */
-        {BMO_OP_SLOT_INT,         "revolutions"}, /* number of v segment */
+       /* slots_in */
+       {{BMO_OP_SLOT_INT,         "u_segments"}, /* number of u segments */
+        {BMO_OP_SLOT_INT,         "v_segments"}, /* number of v segment */
         {BMO_OP_SLOT_FLT,         "diameter"}, /* diameter */
-        {BMO_OP_SLOT_MAT,         "mat"}, /* matrix to multiply the new geometry with-- */
-        {0} /* null-terminating sentinel */,
+        {BMO_OP_SLOT_MAT,         "mat"}, /* matrix to multiply the new geometry with */
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "vertout"}, /* output verts */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "verts.out"}, /* output verts */
+        {0},
        },
        bmo_create_uvsphere_exec,
        0,
@@ -1127,13 +1217,15 @@ static BMOpDefine bmo_create_uvsphere_def = {
  */
 static BMOpDefine bmo_create_icosphere_def = {
        "create_icosphere",
+       /* slots_in */
        {{BMO_OP_SLOT_INT,         "subdivisions"}, /* how many times to recursively subdivide the sphere */
         {BMO_OP_SLOT_FLT,         "diameter"}, /* diameter */
         {BMO_OP_SLOT_MAT,         "mat"}, /* matrix to multiply the new geometry with */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "vertout"}, /* output verts */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "verts.out"}, /* output verts */
+        {0},
        },
        bmo_create_icosphere_exec,
        0,
@@ -1146,11 +1238,13 @@ static BMOpDefine bmo_create_icosphere_def = {
  */
 static BMOpDefine bmo_create_monkey_def = {
        "create_monkey",
-       {{BMO_OP_SLOT_MAT, "mat"}, /* matrix to multiply the new geometry with-- */
-        {0} /* null-terminating sentinel */,
+       /* slots_in */
+       {{BMO_OP_SLOT_MAT, "mat"}, /* matrix to multiply the new geometry with */
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "vertout"}, /* output verts */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "verts.out"}, /* output verts */
+        {0},
        },
        bmo_create_monkey_exec,
        0,
@@ -1163,17 +1257,19 @@ static BMOpDefine bmo_create_monkey_def = {
  */
 static BMOpDefine bmo_create_cone_def = {
        "create_cone",
-       {{BMO_OP_SLOT_BOOL, "cap_ends"}, /* wheter or not to fill in the ends with faces */
-        {BMO_OP_SLOT_BOOL, "cap_tris"}, /* fill ends with triangles instead of ngons */
+       /* slots_in */
+       {{BMO_OP_SLOT_BOOL, "cap_ends"},        /* wheter or not to fill in the ends with faces */
+        {BMO_OP_SLOT_BOOL, "cap_tris"},        /* fill ends with triangles instead of ngons */
         {BMO_OP_SLOT_INT, "segments"},
-        {BMO_OP_SLOT_FLT, "diameter1"}, /* diameter of one end */
-        {BMO_OP_SLOT_FLT, "diameter2"}, /* diameter of the opposite */
-        {BMO_OP_SLOT_FLT, "depth"}, /* distance between ends */
-        {BMO_OP_SLOT_MAT, "mat"}, /* matrix to multiply the new geometry with-- */
-        {0} /* null-terminating sentinel */,
+        {BMO_OP_SLOT_FLT, "diameter1"},        /* diameter of one end */
+        {BMO_OP_SLOT_FLT, "diameter2"},        /* diameter of the opposite */
+        {BMO_OP_SLOT_FLT, "depth"},            /* distance between ends */
+        {BMO_OP_SLOT_MAT, "mat"},              /* matrix to multiply the new geometry with */
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "vertout"}, /* output verts */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "verts.out"}, /* output verts */
+        {0},
        },
        bmo_create_cone_exec,
        0,
@@ -1184,15 +1280,17 @@ static BMOpDefine bmo_create_cone_def = {
  */
 static BMOpDefine bmo_create_circle_def = {
        "create_circle",
-       {{BMO_OP_SLOT_BOOL, "cap_ends"}, /* wheter or not to fill in the ends with faces */
-        {BMO_OP_SLOT_BOOL, "cap_tris"}, /* fill ends with triangles instead of ngons */
+       /* slots_in */
+       {{BMO_OP_SLOT_BOOL, "cap_ends"},        /* wheter or not to fill in the ends with faces */
+        {BMO_OP_SLOT_BOOL, "cap_tris"},        /* fill ends with triangles instead of ngons */
         {BMO_OP_SLOT_INT, "segments"},
-        {BMO_OP_SLOT_FLT, "diameter"}, /* diameter of one end */
-        {BMO_OP_SLOT_MAT, "mat"}, /* matrix to multiply the new geometry with-- */
-        {0} /* null-terminating sentinel */,
+        {BMO_OP_SLOT_FLT, "diameter"},         /* diameter of one end */
+        {BMO_OP_SLOT_MAT, "mat"},              /* matrix to multiply the new geometry with */
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "vertout"}, /* output verts */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "verts.out"}, /* output verts */
+        {0},
        },
        bmo_create_circle_exec,
        0,
@@ -1205,12 +1303,14 @@ static BMOpDefine bmo_create_circle_def = {
  */
 static BMOpDefine bmo_create_cube_def = {
        "create_cube",
-       {{BMO_OP_SLOT_FLT, "size"}, /* size of the cube */
-        {BMO_OP_SLOT_MAT, "mat"}, /* matrix to multiply the new geometry with-- */
-        {0} /* null-terminating sentinel */,
+       /* slots_in */
+       {{BMO_OP_SLOT_FLT, "size"},             /* size of the cube */
+        {BMO_OP_SLOT_MAT, "mat"},              /* matrix to multiply the new geometry with */
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "vertout"}, /* output verts */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "verts.out"}, /* output verts */
+        {0},
        },
        bmo_create_cube_exec,
        0,
@@ -1223,13 +1323,15 @@ static BMOpDefine bmo_create_cube_def = {
  */
 static BMOpDefine bmo_bevel_def = {
        "bevel",
-       {{BMO_OP_SLOT_ELEMENT_BUF, "geom"}, /* input edges and vertices */
-        {BMO_OP_SLOT_FLT, "offset"}, /* amount to offset beveled edge */
-        {BMO_OP_SLOT_INT, "segments"}, /* number of segments in bevel */
-        {0} /* null-terminating sentinel */,
+       /* slots_in */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "geom"},     /* input edges and vertices */
+        {BMO_OP_SLOT_FLT, "offset"},           /* amount to offset beveled edge */
+        {BMO_OP_SLOT_INT, "segments"},         /* number of segments in bevel */
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "faceout"}, /* output faces */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "faces.out"}, /* output faces */
+        {0},
        },
 #if 0  /* old bevel*/
        {{BMO_OP_SLOT_ELEMENT_BUF, "geom"}, /* input edges and vertices */
@@ -1241,7 +1343,7 @@ static BMOpDefine bmo_bevel_def = {
                                          * modifier uses this. We could do this as another float setting */
         {BMO_OP_SLOT_INT, "lengthlayer"}, /* which PROP_FLT layer to us */
         {BMO_OP_SLOT_FLT, "percent"}, /* percentage to expand beveled edge */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
 #endif
        bmo_bevel_exec,
@@ -1255,12 +1357,14 @@ static BMOpDefine bmo_bevel_def = {
  */
 static BMOpDefine bmo_beautify_fill_def = {
        "beautify_fill",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "faces"}, /* input faces */
         {BMO_OP_SLOT_ELEMENT_BUF, "constrain_edges"}, /* edges that can't be flipped */
-        {0} /* null-terminating sentinel */,
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "geomout"}, /* new flipped faces and edges */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "geom.out"}, /* new flipped faces and edges */
+        {0},
        },
        bmo_beautify_fill_exec,
        BMO_OP_FLAG_UNTAN_MULTIRES
@@ -1273,11 +1377,13 @@ static BMOpDefine bmo_beautify_fill_def = {
  */
 static BMOpDefine bmo_triangle_fill_def = {
        "triangle_fill",
-       {{BMO_OP_SLOT_ELEMENT_BUF, "edges"}, /* input edges */
-        {0} /* null-terminating sentinel */,
+       /* slots_in */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "edges"},    /* input edges */
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "geomout"}, /* new faces and edges */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "geom.out"}, /* new faces and edges */
+        {0},
        },
        bmo_triangle_fill_exec,
        BMO_OP_FLAG_UNTAN_MULTIRES
@@ -1290,12 +1396,14 @@ static BMOpDefine bmo_triangle_fill_def = {
  */
 static BMOpDefine bmo_solidify_def = {
        "solidify",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "geom"},
         {BMO_OP_SLOT_FLT, "thickness"},
-        {0} /* null-terminating sentinel */,
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "geomout"},
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "geom.out"},
+        {0},
        },
        bmo_solidify_face_region_exec,
        0
@@ -1308,17 +1416,19 @@ static BMOpDefine bmo_solidify_def = {
  */
 static BMOpDefine bmo_inset_def = {
        "inset",
-       {{BMO_OP_SLOT_ELEMENT_BUF, "faces"},   /* input faces */
+       /* slots_in */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "faces"},    /* input faces */
         {BMO_OP_SLOT_BOOL, "use_boundary"},
         {BMO_OP_SLOT_BOOL, "use_even_offset"},
         {BMO_OP_SLOT_BOOL, "use_relative_offset"},
         {BMO_OP_SLOT_FLT, "thickness"},
         {BMO_OP_SLOT_FLT, "depth"},
         {BMO_OP_SLOT_BOOL, "use_outset"},
-        {0} /* null-terminating sentinel */,
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "faceout"}, /* output faces */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "faces.out"}, /* output faces */
+        {0},
        },
        bmo_inset_exec,
        0
@@ -1331,6 +1441,7 @@ static BMOpDefine bmo_inset_def = {
  */
 static BMOpDefine bmo_wireframe_def = {
        "wireframe",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "faces"},   /* input faces */
         {BMO_OP_SLOT_BOOL, "use_boundary"},
         {BMO_OP_SLOT_BOOL, "use_even_offset"},
@@ -1338,10 +1449,11 @@ static BMOpDefine bmo_wireframe_def = {
         {BMO_OP_SLOT_FLT, "thickness"},
         {BMO_OP_SLOT_BOOL, "use_relative_offset"},
         {BMO_OP_SLOT_FLT, "depth"},
-        {0} /* null-terminating sentinel */,
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "faceout"}, /* output faces */
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "faces.out"}, /* output faces */
+        {0},
        },
        bmo_wireframe_exec,
        0
@@ -1354,13 +1466,15 @@ static BMOpDefine bmo_wireframe_def = {
  */
 static BMOpDefine bmo_slide_vert_def = {
        "slide_vert",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "vert"},
         {BMO_OP_SLOT_ELEMENT_BUF, "edge"},
         {BMO_OP_SLOT_FLT, "distance_t"},
-        {0} /* null-terminating sentinel */,
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "vertout"},
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "verts.out"},
+        {0},
        },
        bmo_slide_vert_exec,
        BMO_OP_FLAG_UNTAN_MULTIRES
@@ -1375,7 +1489,7 @@ static BMOpDefine bmo_slide_vert_def = {
  * If 'use_existing_faces' is true, the hull will not output triangles
  * that are covered by a pre-existing face.
  *
- * All hull vertices, faces, and edges are added to 'geomout'. Any
+ * All hull vertices, faces, and edges are added to 'geom.out'. Any
  * input elements that end up inside the hull (i.e. are not used by an
  * output face) are added to the 'interior_geom' slot. The
  * 'unused_geom' slot will contain all interior geometry that is
@@ -1384,15 +1498,17 @@ static BMOpDefine bmo_slide_vert_def = {
  */
 static BMOpDefine bmo_convex_hull_def = {
        "convex_hull",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "input"},
         {BMO_OP_SLOT_BOOL, "use_existing_faces"},
-        {0} /* null-terminating sentinel */,
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "geomout"},
-        {BMO_OP_SLOT_ELEMENT_BUF, "interior_geom_out"},
-        {BMO_OP_SLOT_ELEMENT_BUF, "unused_geom_out"},
-        {BMO_OP_SLOT_ELEMENT_BUF, "holes_geom_out"},
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "geom.out"},
+        {BMO_OP_SLOT_ELEMENT_BUF, "geom_interior.out"},
+        {BMO_OP_SLOT_ELEMENT_BUF, "geom_unused.out"},
+        {BMO_OP_SLOT_ELEMENT_BUF, "geom_holes.out"},
+        {0},
        },
        bmo_convex_hull_exec,
        0
@@ -1407,16 +1523,18 @@ static BMOpDefine bmo_convex_hull_def = {
  * the "direction" slot. The edges and faces that cross the plane of
  * symmetry are split as needed to enforce symmetry.
  *
- * All new vertices, edges, and faces are added to the "geomout" slot.
+ * All new vertices, edges, and faces are added to the "geom.out" slot.
  */
 static BMOpDefine bmo_symmetrize_def = {
        "symmetrize",
+       /* slots_in */
        {{BMO_OP_SLOT_ELEMENT_BUF, "input"},
         {BMO_OP_SLOT_INT, "direction"},
-        {0} /* null-terminating sentinel */,
+        {0},
        },
-       {{BMO_OP_SLOT_ELEMENT_BUF, "geomout"},
-        {0} /* null-terminating sentinel */,
+       /* slots_out */
+       {{BMO_OP_SLOT_ELEMENT_BUF, "geom.out"},
+        {0},
        },
        bmo_symmetrize_exec,
        0
index 14da93302b9c9526b11ef70c3d79f3dbd6765c8f..b74d97c9bb5d8247bb13791c8beaf3b00feec49e 100644 (file)
@@ -88,11 +88,6 @@ enum {
        OPUVC_AXIS_Y
 };
 
-enum {
-       DIRECTION_CW = 1,
-       DIRECTION_CCW
-};
-
 /* vertex path selection values */
 enum {
        VPATH_SELECT_EDGE_LENGTH = 0,
index f36856cece4a47ec7cfe2f279185f66e6870cba8..126d0f461197af77bde13adc9f1fd971e14850b0 100644 (file)
@@ -56,6 +56,6 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
 
                BM_mesh_bevel(bm, offset, seg);
 
-               BMO_slot_buffer_from_enabled_hflag(bm, op, op->slots_out, "faceout", BM_FACE, BM_ELEM_TAG);
+               BMO_slot_buffer_from_enabled_hflag(bm, op, op->slots_out, "faces.out", BM_FACE, BM_ELEM_TAG);
        }
 }
index 5c6f666620e41623c28f8fa214f3f5fd2f9afc8e..b7bb57bb19dadcd80688656df969fd3a3a670a61 100644 (file)
@@ -117,7 +117,7 @@ void bmo_connect_verts_exec(BMesh *bm, BMOperator *op)
                }
        }
 
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edgeout", BM_EDGE, EDGE_OUT);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edges.out", BM_EDGE, EDGE_OUT);
 
        BLI_array_free(loops_split);
        BLI_array_free(verts_pair);
@@ -523,7 +523,7 @@ void bmo_bridge_loops_exec(BMesh *bm, BMOperator *op)
                }
        }
 
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "faceout", BM_FACE, FACE_OUT);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "faces.out", BM_FACE, FACE_OUT);
 
 cleanup:
        BLI_array_free(ee1);
index 52402ae2f86334294615f13e84b41e948700a599..e9a06631fac01bd4d6859fbe1b7e60e5d8566cb2 100644 (file)
@@ -911,7 +911,7 @@ void bmo_edgenet_fill_exec(BMesh *bm, BMOperator *op)
        vdata = MEM_callocN(sizeof(VertData) * bm->totvert, "VertData");
        
        BMO_slot_buffer_flag_enable(bm, op->slots_in, "edges", BM_EDGE, EDGE_MARK);
-       BMO_slot_buffer_flag_enable(bm, op->slots_in, "excludefaces", BM_FACE, FACE_IGNORE);
+       BMO_slot_buffer_flag_enable(bm, op->slots_in, "exclude_faces", BM_FACE, FACE_IGNORE);
        
        BM_mesh_elem_index_ensure(bm, BM_VERT);
 
@@ -1055,7 +1055,7 @@ void bmo_edgenet_fill_exec(BMesh *bm, BMOperator *op)
                                }
 
                                if (use_restrict) {
-                                       BMO_slot_map_int_insert(op, op->slots_out, "face_groupmap_out", f, path->group);
+                                       BMO_slot_map_int_insert(op, op->slots_out, "face_groupmap.out", f, path->group);
                                }
                        }
                }
@@ -1063,7 +1063,7 @@ void bmo_edgenet_fill_exec(BMesh *bm, BMOperator *op)
                edge_free_path(pathbase, path);
        }
 
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "faceout", BM_FACE, FACE_NEW);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "faces.out", BM_FACE, FACE_NEW);
 
        BLI_array_free(edges);
        BLI_array_free(verts);
@@ -1260,7 +1260,7 @@ void bmo_edgenet_prepare(BMesh *bm, BMOperator *op)
                }
        }
        
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edgeout", BM_EDGE, ELE_NEW);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edges.out", BM_EDGE, ELE_NEW);
 
        BLI_array_free(edges1);
        BLI_array_free(edges2);
@@ -1366,7 +1366,7 @@ void bmo_contextual_create_exec(BMesh *bm, BMOperator *op)
        /* call edgenet prepare op so additional face creation cases wore */
        BMO_op_initf(bm, &op2, op->flag, "edgenet_prepare edges=%fe", ELE_NEW);
        BMO_op_exec(bm, &op2);
-       BMO_slot_buffer_flag_enable(bm, op2.slots_out, "edgeout", BM_EDGE, ELE_NEW);
+       BMO_slot_buffer_flag_enable(bm, op2.slots_out, "edges.out", BM_EDGE, ELE_NEW);
        BMO_op_finish(bm, &op2);
 
        BMO_op_initf(bm, &op2, op->flag,
@@ -1376,9 +1376,9 @@ void bmo_contextual_create_exec(BMesh *bm, BMOperator *op)
        BMO_op_exec(bm, &op2);
 
        /* return if edge net create did something */
-       if (BMO_slot_buffer_count(op2.slots_out, "faceout")) {
-               BMO_slot_copy(&op2, slots_out, "faceout",
-                             op,   slots_out, "faceout");
+       if (BMO_slot_buffer_count(op2.slots_out, "faces.out")) {
+               BMO_slot_copy(&op2, slots_out, "faces.out",
+                             op,   slots_out, "faces.out");
                BMO_op_finish(bm, &op2);
                return;
        }
@@ -1390,9 +1390,9 @@ void bmo_contextual_create_exec(BMesh *bm, BMOperator *op)
        BMO_op_exec(bm, &op2);
        
        /* if we dissolved anything, then return */
-       if (BMO_slot_buffer_count(op2.slots_out, "regionout")) {
-               BMO_slot_copy(&op2, slots_out, "regionout",
-                             op,   slots_out,  "faceout");
+       if (BMO_slot_buffer_count(op2.slots_out, "region.out")) {
+               BMO_slot_copy(&op2, slots_out, "region.out",
+                             op,   slots_out,  "faces.out");
                BMO_op_finish(bm, &op2);
                return;
        }
@@ -1416,7 +1416,7 @@ void bmo_contextual_create_exec(BMesh *bm, BMOperator *op)
                /* create edge */
                e = BM_edge_create(bm, verts[0], verts[1], NULL, TRUE);
                BMO_elem_flag_enable(bm, e, ELE_OUT);
-               BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edgeout", BM_EDGE, ELE_OUT);
+               BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edges.out", BM_EDGE, ELE_OUT);
        }
        else if (0) { /* nice feature but perhaps it should be a different tool? */
 
@@ -1462,7 +1462,7 @@ void bmo_contextual_create_exec(BMesh *bm, BMOperator *op)
                                }
                        }
                }
-               BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edgeout", BM_EDGE, ELE_OUT);
+               BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edges.out", BM_EDGE, ELE_OUT);
                /* done creating edges */
        }
        else if (amount > 2) {
index 649aa8b214b93efa28d790a3cb969e20fb393879..7c3bcd60daa8df997f841f66e3b4558d016e81cb 100644 (file)
@@ -184,7 +184,7 @@ void bmo_dissolve_faces_exec(BMesh *bm, BMOperator *op)
                goto cleanup;
        }
 
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "regionout", BM_FACE, FACE_NEW);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "region.out", BM_FACE, FACE_NEW);
 
 cleanup:
        /* free/cleanup */
@@ -237,7 +237,7 @@ void bmo_dissolve_edgeloop_exec(BMesh *bm, BMOperator *op)
        //BMO_op_initf(bm, &fop, "dissolve_faces faces=%ff", FACE_MARK);
        //BMO_op_exec(bm, &fop);
 
-       //BMO_slot_copy(op, &fop, "regionout", "regionout");
+       //BMO_slot_copy(op, &fop, "region.out", "region.out");
 
        //BMO_op_finish(bm, &fop);
 }
index 5391341214b383565bf4b2f68766ff1bab4236d5..f32ba4430b8bd6fff9d0467a1b5edc32e5fafaec 100644 (file)
@@ -102,7 +102,7 @@ static BMEdge *copy_edge(BMOperator *op, BMesh *source_mesh,
        if (rlen < 2) {
                /* not sure what non-manifold cases of greater then three
                 * radial should do. */
-               BMO_slot_map_ptr_insert(op, op->slots_out, "boundarymap_out",
+               BMO_slot_map_ptr_insert(op, op->slots_out, "boundarymap.out",
                                        source_edge, target_edge);
        }
 
@@ -154,8 +154,8 @@ static BMFace *copy_face(BMOperator *op, BMesh *source_mesh,
        
        /* create new face */
        target_face = BM_face_create(target_mesh, vtar, edar, source_face->len, FALSE);
-       BMO_slot_map_ptr_insert(op, op->slots_out, "facemap_out", source_face, target_face);
-       BMO_slot_map_ptr_insert(op, op->slots_out, "facemap_out", target_face, source_face);
+       BMO_slot_map_ptr_insert(op, op->slots_out, "facemap.out", source_face, target_face);
+       BMO_slot_map_ptr_insert(op, op->slots_out, "facemap.out", target_face, source_face);
 
        BM_elem_attrs_copy(source_mesh, target_mesh, source_face, target_face);
 
@@ -227,7 +227,7 @@ static void bmo_mesh_copy(BMOperator *op, BMesh *source, BMesh *target)
                        }
 
                        if (isolated) {
-                               BMO_slot_map_ptr_insert(op, op->slots_out, "isovertmap_out", v, v2);
+                               BMO_slot_map_ptr_insert(op, op->slots_out, "isovertmap.out", v, v2);
                        }
 
                        BMO_elem_flag_enable(source, v, DUPE_DONE);
@@ -331,10 +331,10 @@ void bmo_duplicate_exec(BMesh *bm, BMOperator *op)
        /* Output */
        /* First copy the input buffers to output buffers - original data */
        BMO_slot_copy(dupeop, slots_in,  "geom",
-                     dupeop, slots_out, "origout");
+                     dupeop, slots_out, "geom_orig.out");
 
        /* Now alloc the new output buffers */
-       BMO_slot_buffer_from_enabled_flag(bm, dupeop, dupeop->slots_out, "newout", BM_ALL, DUPE_NEW);
+       BMO_slot_buffer_from_enabled_flag(bm, dupeop, dupeop->slots_out, "geom.out", BM_ALL, DUPE_NEW);
 }
 
 #if 0 /* UNUSED */
@@ -435,14 +435,14 @@ void bmo_split_exec(BMesh *bm, BMOperator *op)
        BMO_op_exec(bm, &delop);
 
        /* now we make our outputs by copying the dupe output */
-       BMO_slot_copy(&dupeop, slots_out, "newout",
-                     splitop, slots_out, "geomout");
+       BMO_slot_copy(&dupeop, slots_out, "geom.out",
+                     splitop, slots_out, "geom.out");
 
-       BMO_slot_copy(&dupeop, slots_out, "boundarymap_out",
-                     splitop, slots_out, "boundarymap_out");
+       BMO_slot_copy(&dupeop, slots_out, "boundarymap.out",
+                     splitop, slots_out, "boundarymap.out");
 
-       BMO_slot_copy(&dupeop, slots_out, "isovertmap_out",
-                     splitop, slots_out, "isovertmap_out");
+       BMO_slot_copy(&dupeop, slots_out, "isovertmap.out",
+                     splitop, slots_out, "isovertmap.out");
 
 
        /* cleanup */
@@ -487,33 +487,33 @@ void bmo_spin_exec(BMesh *bm, BMOperator *op)
        BMO_slot_vec_get(op->slots_in, "dvec", dvec);
        usedvec = !is_zero_v3(dvec);
        steps    = BMO_slot_int_get(op->slots_in,   "steps");
-       phi      = BMO_slot_float_get(op->slots_in, "ang") * DEG2RADF(1.0f) / steps;
-       do_dupli = BMO_slot_bool_get(op->slots_in,  "do_dupli");
+       phi      = BMO_slot_float_get(op->slots_in, "angle") * DEG2RADF(1.0f) / steps;
+       do_dupli = BMO_slot_bool_get(op->slots_in,  "use_duplicate");
 
        axis_angle_to_mat3(rmat, axis, phi);
 
        BMO_slot_copy(op, slots_in,  "geom",
-                     op, slots_out, "lastout");
+                     op, slots_out, "geom_last.out");
        for (a = 0; a < steps; a++) {
                if (do_dupli) {
-                       BMO_op_initf(bm, &dupop, op->flag, "duplicate geom=%S", op, "lastout");
+                       BMO_op_initf(bm, &dupop, op->flag, "duplicate geom=%S", op, "geom_last.out");
                        BMO_op_exec(bm, &dupop);
                        BMO_op_callf(bm, op->flag,
                                     "rotate cent=%v mat=%m3 verts=%S",
-                                    cent, rmat, &dupop, "newout");
-                       BMO_slot_copy(&dupop, slots_out, "newout",
-                                     op,     slots_out, "lastout");
+                                    cent, rmat, &dupop, "geom.out");
+                       BMO_slot_copy(&dupop, slots_out, "geom.out",
+                                     op,     slots_out, "geom_last.out");
                        BMO_op_finish(bm, &dupop);
                }
                else {
-                       BMO_op_initf(bm, &extop, op->flag, "extrude_face_region edgefacein=%S",
-                                    op, "lastout");
+                       BMO_op_initf(bm, &extop, op->flag, "extrude_face_region geom=%S",
+                                    op, "geom_last.out");
                        BMO_op_exec(bm, &extop);
                        BMO_op_callf(bm, op->flag,
                                     "rotate cent=%v mat=%m3 verts=%S",
-                                    cent, rmat, &extop, "geomout");
-                       BMO_slot_copy(&extop, slots_out, "geomout",
-                                     op,     slots_out, "lastout");
+                                    cent, rmat, &extop, "geom.out");
+                       BMO_slot_copy(&extop, slots_out, "geom.out",
+                                     op,     slots_out, "geom_last.out");
                        BMO_op_finish(bm, &extop);
                }
 
@@ -521,7 +521,7 @@ void bmo_spin_exec(BMesh *bm, BMOperator *op)
                        mul_m3_v3(rmat, dvec);
                        BMO_op_callf(bm, op->flag,
                                     "translate vec=%v verts=%S",
-                                    dvec, op, "lastout");
+                                    dvec, op, "geom_last.out");
                }
        }
 }
index 90b3d0c890b573374b80b40dc8db0a6b94ef2eff..9e9e4b8c962cdf3a13afb02bb074aac1ab002044 100644 (file)
@@ -169,5 +169,5 @@ void bmo_split_edges_exec(BMesh *bm, BMOperator *op)
                }
        }
 
-       BMO_slot_buffer_from_enabled_hflag(bm, op, op->slots_out, "edgeout", BM_EDGE, BM_ELEM_INTERNAL_TAG);
+       BMO_slot_buffer_from_enabled_hflag(bm, op, op->slots_out, "edges.out", BM_EDGE, BM_ELEM_INTERNAL_TAG);
 }
index 65189e679bd8055c4973596e872b92528b144655..9ad0bd2c949848d2a73dff9f1192c6e6bb8e30d9 100644 (file)
@@ -122,7 +122,7 @@ void bmo_extrude_discrete_faces_exec(BMesh *bm, BMOperator *op)
        BMO_op_callf(bm, op->flag,
                     "delete geom=%ff context=%i",
                     EXT_DEL, DEL_ONLYFACES);
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "faceout", BM_FACE, EXT_KEEP);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "faces.out", BM_FACE, EXT_KEEP);
 }
 
 /**
@@ -193,12 +193,12 @@ void bmo_extrude_edge_only_exec(BMesh *bm, BMOperator *op)
        /* disable root flag on all new skin nodes */
        if (CustomData_has_layer(&bm->vdata, CD_MVERT_SKIN)) {
                BMVert *v;
-               BMO_ITER(v, &siter, dupeop.slots_out, "newout", BM_VERT) {
+               BMO_ITER(v, &siter, dupeop.slots_out, "geom.out", BM_VERT) {
                        bm_extrude_disable_skin_root(bm, v);
                }
        }
 
-       for (e = BMO_iter_new(&siter, dupeop.slots_out, "boundarymap_out", 0); e; e = BMO_iter_step(&siter)) {
+       for (e = BMO_iter_new(&siter, dupeop.slots_out, "boundarymap.out", 0); e; e = BMO_iter_step(&siter)) {
                BMVert *f_verts[4];
                e_new = *(BMEdge **)BMO_iter_map_value(&siter);
 
@@ -230,7 +230,7 @@ void bmo_extrude_edge_only_exec(BMesh *bm, BMOperator *op)
 
        BMO_op_finish(bm, &dupeop);
 
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geomout", BM_ALL, EXT_KEEP);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom.out", BM_ALL, EXT_KEEP);
 }
 
 void bmo_extrude_vert_indiv_exec(BMesh *bm, BMOperator *op)
@@ -251,8 +251,8 @@ void bmo_extrude_vert_indiv_exec(BMesh *bm, BMOperator *op)
                BMO_elem_flag_enable(bm, dupev, EXT_KEEP);
        }
 
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "vertout", BM_VERT, EXT_KEEP);
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edgeout", BM_EDGE, EXT_KEEP);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "verts.out", BM_VERT, EXT_KEEP);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edges.out", BM_EDGE, EXT_KEEP);
 }
 
 void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op)
@@ -268,11 +268,11 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op)
        /* initialize our sub-operators */
        BMO_op_init(bm, &dupeop, op->flag, "duplicate");
        
-       BMO_slot_buffer_flag_enable(bm, op->slots_in, "edgefacein", BM_EDGE | BM_FACE, EXT_INPUT);
+       BMO_slot_buffer_flag_enable(bm, op->slots_in, "geom", BM_EDGE | BM_FACE, EXT_INPUT);
        
        /* if one flagged face is bordered by an un-flagged face, then we delete
         * original geometry unless caller explicitly asked to keep it. */
-       if (!BMO_slot_bool_get(op->slots_in, "alwayskeeporig")) {
+       if (!BMO_slot_bool_get(op->slots_in, "use_keep_orig")) {
                BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
 
                        int edge_face_tot;
@@ -339,19 +339,19 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op)
                             EXT_DEL, DEL_ONLYTAGGED);
        }
 
-       BMO_slot_copy(op,      slots_in, "edgefacein",
+       BMO_slot_copy(op,      slots_in, "geom",
                      &dupeop, slots_in, "geom");
        BMO_op_exec(bm, &dupeop);
 
        /* disable root flag on all new skin nodes */
        if (CustomData_has_layer(&bm->vdata, CD_MVERT_SKIN)) {
-               BMO_ITER(v, &siter, dupeop.slots_out, "newout", BM_VERT) {
+               BMO_ITER(v, &siter, dupeop.slots_out, "geom.out", BM_VERT) {
                        bm_extrude_disable_skin_root(bm, v);
                }
        }
 
        if (bm->act_face && BMO_elem_flag_test(bm, bm->act_face, EXT_INPUT))
-               bm->act_face = BMO_slot_map_ptr_get(dupeop.slots_out, "facemap_out", bm->act_face);
+               bm->act_face = BMO_slot_map_ptr_get(dupeop.slots_out, "facemap.out", bm->act_face);
 
        if (delorig) {
                BMO_op_exec(bm, &delop);
@@ -366,14 +366,14 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op)
                }
        }
        
-       BMO_slot_copy(&dupeop, slots_out, "newout",
-                     op,      slots_out, "geomout");
+       BMO_slot_copy(&dupeop, slots_out, "geom.out",
+                     op,      slots_out, "geom.out");
 
-       for (e = BMO_iter_new(&siter, dupeop.slots_out, "boundarymap_out", 0); e; e = BMO_iter_step(&siter)) {
+       for (e = BMO_iter_new(&siter, dupeop.slots_out, "boundarymap.out", 0); e; e = BMO_iter_step(&siter)) {
                BMVert *f_verts[4];
 
                /* this should always be wire, so this is mainly a speedup to avoid map lookup */
-               if (BM_edge_is_wire(e) && BMO_slot_map_contains(op->slots_in, "exclude", e)) {
+               if (BM_edge_is_wire(e) && BMO_slot_map_contains(op->slots_in, "edges_exclude", e)) {
                        BMVert *v1 = e->v1, *v2 = e->v2;
 
                        /* The original edge was excluded,
@@ -423,7 +423,7 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op)
        }
 
        /* link isolated vert */
-       for (v = BMO_iter_new(&siter, dupeop.slots_out, "isovertmap_out", 0); v; v = BMO_iter_step(&siter)) {
+       for (v = BMO_iter_new(&siter, dupeop.slots_out, "isovertmap.out", 0); v; v = BMO_iter_step(&siter)) {
                v2 = *((void **)BMO_iter_map_value(&siter));
                BM_edge_create(bm, v, v2, v->e, TRUE);
        }
@@ -659,18 +659,18 @@ void bmo_solidify_face_region_exec(BMesh *bm, BMOperator *op)
        BMO_op_finish(bm, &reverseop);
 
        /* Extrude the region */
-       BMO_op_initf(bm, &extrudeop, op->flag, "extrude_face_region alwayskeeporig=%b", TRUE);
+       BMO_op_initf(bm, &extrudeop, op->flag, "extrude_face_region use_keep_orig=%b", TRUE);
        BMO_slot_copy(op,         slots_in, "geom",
-                     &extrudeop, slots_in, "edgefacein");
+                     &extrudeop, slots_in, "geom");
        BMO_op_exec(bm, &extrudeop);
 
        /* Push the verts of the extruded faces inward to create thickness */
-       BMO_slot_buffer_flag_enable(bm, extrudeop.slots_out, "geomout", BM_FACE, FACE_MARK);
+       BMO_slot_buffer_flag_enable(bm, extrudeop.slots_out, "geom.out", BM_FACE, FACE_MARK);
        calc_solidify_normals(bm);
        solidify_add_thickness(bm, thickness);
 
-       BMO_slot_copy(&extrudeop, slots_out, "geomout",
-                     op,         slots_out, "geomout");
+       BMO_slot_copy(&extrudeop, slots_out, "geom.out",
+                     op,         slots_out, "geom.out");
 
        BMO_op_finish(bm, &extrudeop);
 }
index 7a8237b05d962573efb9848c98f89095b44bb9c3..117f65ae4eade23ea19b821686c7afc5f2a6ac7b 100644 (file)
@@ -139,17 +139,17 @@ static void hull_output_triangles(BMesh *bm, GHash *hull_triangles)
                                f = BM_face_create_quad_tri_v(bm, t->v, 3, example, TRUE);
                                BM_face_copy_shared(bm, f);
                        }
-                       /* Mark face for 'geomout' slot and select */
+                       /* Mark face for 'geom.out' slot and select */
                        BMO_elem_flag_enable(bm, f, HULL_FLAG_OUTPUT_GEOM);
                        BM_face_select_set(bm, f, TRUE);
 
-                       /* Mark edges for 'geomout' slot */
+                       /* Mark edges for 'geom.out' slot */
                        for (i = 0; i < 3; i++) {
                                BMO_elem_flag_enable(bm, edges[i], HULL_FLAG_OUTPUT_GEOM);
                        }
                }
                else {
-                       /* Mark input edges for 'geomout' slot */
+                       /* Mark input edges for 'geom.out' slot */
                        for (i = 0; i < 3; i++) {
                                const int next = (i == 2 ? 0 : i + 1);
                                BMEdge *e = BM_edge_exists(t->v[i], t->v[next]);
@@ -161,7 +161,7 @@ static void hull_output_triangles(BMesh *bm, GHash *hull_triangles)
                        }
                }
 
-               /* Mark verts for 'geomout' slot */
+               /* Mark verts for 'geom.out' slot */
                for (i = 0; i < 3; i++) {
                        BMO_elem_flag_enable(bm, t->v[i], HULL_FLAG_OUTPUT_GEOM);
                }
@@ -603,22 +603,22 @@ void bmo_convex_hull_exec(BMesh *bm, BMOperator *op)
 
        /* Output slot of input elements that ended up inside the hull
         * rather than part of it */
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "interior_geom_out",
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom_interior.out",
                                          BM_ALL, HULL_FLAG_INTERIOR_ELE);
 
        /* Output slot of input elements that ended up inside the hull and
         * are are unused by other geometry. */
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "unused_geom_out",
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom_unused.out",
                                          BM_ALL, HULL_FLAG_DEL);
 
        /* Output slot of faces and edges that were in the input and on
         * the hull (useful for cases like bridging where you want to
         * delete some input geometry) */
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "holes_geom_out",
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom_holes.out",
                                          BM_ALL, HULL_FLAG_HOLE);
 
        /* Output slot of all hull vertices, faces, and edges */
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geomout",
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom.out",
                                          BM_ALL, HULL_FLAG_OUTPUT_GEOM);
 }
 
index 1da08fc68ee29a15943f882d0187936f086422f6..bcfe8f9d4148f5d37f2f3af287a77c2fab02752f 100644 (file)
@@ -481,7 +481,7 @@ void bmo_inset_exec(BMesh *bm, BMOperator *op)
        }
 
        /* we could flag new edges/verts too, is it useful? */
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "faceout", BM_FACE, ELE_NEW);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "faces.out", BM_FACE, ELE_NEW);
 
        /* cheap feature to add depth to the inset */
        if (depth != 0.0f) {
index af2a7cd996b9183346fff52290208db8eb9a7489..4b897a24c8a670e4ffad2e3098663ab56ef321c9 100644 (file)
@@ -55,7 +55,7 @@ void bmo_mesh_to_bmesh_exec(BMesh *bm, BMOperator *op)
 {
        Object *ob  = BMO_slot_ptr_get(op->slots_in,  "object");
        Mesh *me    = BMO_slot_ptr_get(op->slots_in,  "mesh");
-       int set_key = BMO_slot_bool_get(op->slots_in, "set_shapekey");
+       int set_key = BMO_slot_bool_get(op->slots_in, "use_shapekey");
 
        BM_mesh_bm_from_me(bm, me, set_key, ob->shapenr);
 
@@ -71,7 +71,7 @@ void bmo_object_load_bmesh_exec(BMesh *bm, BMOperator *op)
        Mesh *me = ob->data;
 
        BMO_op_callf(bm, op->flag,
-                    "bmesh_to_mesh mesh=%p object=%p notessellation=%b",
+                    "bmesh_to_mesh mesh=%p object=%p skip_tessface=%b",
                     me, ob, TRUE);
 }
 
@@ -79,7 +79,7 @@ void bmo_bmesh_to_mesh_exec(BMesh *bm, BMOperator *op)
 {
        Mesh *me = BMO_slot_ptr_get(op->slots_in, "mesh");
        /* Object *ob = BMO_slot_ptr_get(op, "object"); */
-       int dotess = !BMO_slot_bool_get(op->slots_in, "notessellation");
+       int dotess = !BMO_slot_bool_get(op->slots_in, "skip_tessface");
 
        BM_mesh_bm_to_me(bm, me, dotess);
 }
index 590e40195d04a4383ab4a62aeb002f8b4e6bcee1..8d3385ddfe6131304bb70fd953e38e9981b50006 100644 (file)
@@ -50,7 +50,7 @@ void bmo_mirror_exec(BMesh *bm, BMOperator *op)
        float mtx[4][4];
        float imtx[4][4];
        float scale[3] = {1.0f, 1.0f, 1.0f};
-       float dist = BMO_slot_float_get(op->slots_in, "mergedist");
+       float dist = BMO_slot_float_get(op->slots_in, "merge_dist");
        int i, ototvert /*, ototedge */;
        int axis = BMO_slot_int_get(op->slots_in, "axis");
        int mirroru = BMO_slot_bool_get(op->slots_in, "mirror_u");
@@ -65,12 +65,12 @@ void bmo_mirror_exec(BMesh *bm, BMOperator *op)
        BMO_op_initf(bm, &dupeop, op->flag, "duplicate geom=%s", op, "geom");
        BMO_op_exec(bm, &dupeop);
        
-       BMO_slot_buffer_flag_enable(bm, dupeop.slots_out, "newout", BM_ALL, ELE_NEW);
+       BMO_slot_buffer_flag_enable(bm, dupeop.slots_out, "geom.out", BM_ALL, ELE_NEW);
 
        /* create old -> new mappin */
        i = 0;
        /* v2 = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL); */ /* UNUSED */
-       BMO_ITER (v, &siter, dupeop.slots_out, "newout", BM_VERT) {
+       BMO_ITER (v, &siter, dupeop.slots_out, "geom.out", BM_VERT) {
                BLI_array_grow_one(vmap);
                vmap[i] = v;
                /* v2 = BM_iter_step(&iter); */ /* UNUSED */
@@ -101,7 +101,7 @@ void bmo_mirror_exec(BMesh *bm, BMOperator *op)
                int totlayer;
                BMIter liter;
 
-               BMO_ITER (f, &siter, dupeop.slots_out, "newout", BM_FACE) {
+               BMO_ITER (f, &siter, dupeop.slots_out, "geom.out", BM_FACE) {
                        BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
                                totlayer = CustomData_number_of_layers(&bm->ldata, CD_MLOOPUV);
                                for (i = 0; i < totlayer; i++) {
@@ -120,7 +120,7 @@ void bmo_mirror_exec(BMesh *bm, BMOperator *op)
        BMO_op_finish(bm, &weldop);
        BMO_op_finish(bm, &dupeop);
 
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "newout", BM_ALL, ELE_NEW);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom.out", BM_ALL, ELE_NEW);
 
        BLI_array_free(vmap);
        BLI_array_free(emap);
index cdc8df19f070770e92a672bf41ae4690b9d91343..71f63bbaf283594e87bc53c523515050c0e861fa 100644 (file)
@@ -227,14 +227,15 @@ static signed char monkeyf[250][4] = {
 
 void bmo_create_grid_exec(BMesh *bm, BMOperator *op)
 {
+       const float dia = BMO_slot_float_get(op->slots_in, "size");
+       const int tot = max_ii(2, BMO_slot_int_get(op->slots_in, "x_segments"));
+       const int seg = max_ii(2, BMO_slot_int_get(op->slots_in, "y_segments"));
+
        BMOperator bmop, prevop;
        BMVert *eve, *preveve;
        BMEdge *e;
-       float vec[3], mat[4][4], phi, phid, dia = BMO_slot_float_get(op->slots_in, "size");
-       int a, tot = BMO_slot_int_get(op->slots_in, "xsegments"), seg = BMO_slot_int_get(op->slots_in, "ysegments");
-
-       if (tot < 2) tot = 2;
-       if (seg < 2) seg = 2;
+       float vec[3], mat[4][4], phi, phid;
+       int a;
 
        BMO_slot_mat4_get(op->slots_in, "mat", mat);
 
@@ -267,37 +268,41 @@ void bmo_create_grid_exec(BMesh *bm, BMOperator *op)
 
        for (a = 0; a < seg - 1; a++) {
                if (a) {
-                       BMO_op_initf(bm, &bmop, op->flag, "extrude_edge_only edges=%S", &prevop, "geomout");
+                       BMO_op_initf(bm, &bmop, op->flag, "extrude_edge_only edges=%S", &prevop, "geom.out");
                        BMO_op_exec(bm, &bmop);
                        BMO_op_finish(bm, &prevop);
 
-                       BMO_slot_buffer_flag_enable(bm, bmop.slots_out, "geomout", BM_VERT, VERT_MARK);
+                       BMO_slot_buffer_flag_enable(bm, bmop.slots_out, "geom.out", BM_VERT, VERT_MARK);
                }
                else {
                        BMO_op_initf(bm, &bmop, op->flag, "extrude_edge_only edges=%fe", EDGE_ORIG);
                        BMO_op_exec(bm, &bmop);
-                       BMO_slot_buffer_flag_enable(bm, bmop.slots_out, "geomout", BM_VERT, VERT_MARK);
+                       BMO_slot_buffer_flag_enable(bm, bmop.slots_out, "geom.out", BM_VERT, VERT_MARK);
                }
 
-               BMO_op_callf(bm, op->flag, "translate vec=%v verts=%S", vec, &bmop, "geomout");
+               BMO_op_callf(bm, op->flag, "translate vec=%v verts=%S", vec, &bmop, "geom.out");
                prevop = bmop;
        }
 
        if (a)
                BMO_op_finish(bm, &bmop);
 
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "vertout", BM_VERT, VERT_MARK);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "verts.out", BM_VERT, VERT_MARK);
 }
 
 void bmo_create_uvsphere_exec(BMesh *bm, BMOperator *op)
 {
+       const float dia = BMO_slot_float_get(op->slots_in, "diameter");
+       const int seg = BMO_slot_int_get(op->slots_in, "u_segments");
+       const int tot = BMO_slot_int_get(op->slots_in, "v_segments");
+
        BMOperator bmop, prevop;
        BMVert *eve, *preveve;
        BMEdge *e;
        BMIter iter;
        float vec[3], mat[4][4], cmat[3][3], phi, q[4];
-       float phid, dia = BMO_slot_float_get(op->slots_in, "diameter");
-       int a, seg = BMO_slot_int_get(op->slots_in, "segments"), tot = BMO_slot_int_get(op->slots_in, "revolutions");
+       float phid;
+       int a;
 
        BMO_slot_mat4_get(op->slots_in, "mat", mat);
 
@@ -333,7 +338,7 @@ void bmo_create_uvsphere_exec(BMesh *bm, BMOperator *op)
 
        for (a = 0; a < seg; a++) {
                if (a) {
-                       BMO_op_initf(bm, &bmop, op->flag, "extrude_edge_only edges=%S", &prevop, "geomout");
+                       BMO_op_initf(bm, &bmop, op->flag, "extrude_edge_only edges=%S", &prevop, "geom.out");
                        BMO_op_exec(bm, &bmop);
                        BMO_op_finish(bm, &prevop);
                }
@@ -342,8 +347,8 @@ void bmo_create_uvsphere_exec(BMesh *bm, BMOperator *op)
                        BMO_op_exec(bm, &bmop);
                }
 
-               BMO_slot_buffer_flag_enable(bm, bmop.slots_out, "geomout", BM_VERT, VERT_MARK);
-               BMO_op_callf(bm, op->flag, "rotate cent=%v mat=%m3 verts=%S", vec, cmat, &bmop, "geomout");
+               BMO_slot_buffer_flag_enable(bm, bmop.slots_out, "geom.out", BM_VERT, VERT_MARK);
+               BMO_op_callf(bm, op->flag, "rotate cent=%v mat=%m3 verts=%S", vec, cmat, &bmop, "geom.out");
                
                prevop = bmop;
        }
@@ -375,30 +380,33 @@ void bmo_create_uvsphere_exec(BMesh *bm, BMOperator *op)
                }
        }
 
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "vertout", BM_VERT, VERT_MARK);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "verts.out", BM_VERT, VERT_MARK);
 }
 
 void bmo_create_icosphere_exec(BMesh *bm, BMOperator *op)
 {
+       const float dia = BMO_slot_float_get(op->slots_in, "diameter");
+       const float dia_div = dia / 200.0f;
+       const int subdiv = BMO_slot_int_get(op->slots_in, "subdivisions");
+
        BMVert *eva[12];
        BMVert *v;
        BMIter liter;
        BMIter viter;
        BMLoop *l;
        float vec[3], mat[4][4] /* , phi, phid */;
-       float dia = BMO_slot_float_get(op->slots_in, "diameter");
-       int a, subdiv = BMO_slot_int_get(op->slots_in, "subdivisions");
+       int a;
 
        BMO_slot_mat4_get(op->slots_in, "mat", mat);
 
        /* phid = 2.0f * (float)M_PI / subdiv; */ /* UNUSED */
        /* phi = 0.25f * (float)M_PI; */         /* UNUSED */
 
-       dia /= 200.0f;
+
        for (a = 0; a < 12; a++) {
-               vec[0] = dia * icovert[a][0];
-               vec[1] = dia * icovert[a][1];
-               vec[2] = dia * icovert[a][2];
+               vec[0] = dia_div * icovert[a][0];
+               vec[1] = dia_div * icovert[a][1];
+               vec[2] = dia_div * icovert[a][2];
                eva[a] = BM_vert_create(bm, vec, NULL);
 
                BMO_elem_flag_enable(bm, eva[a], VERT_MARK);
@@ -421,22 +429,20 @@ void bmo_create_icosphere_exec(BMesh *bm, BMOperator *op)
                BMO_elem_flag_enable(bm, eftemp, FACE_MARK);
        }
 
-       dia *= 200.0f;
-
        if (subdiv > 1) {
                BMOperator bmop;
 
                BMO_op_initf(bm, &bmop, op->flag,
                             "subdivide_edges edges=%fe "
                             "smooth=%f "
-                            "numcuts=%i "
+                            "cuts=%i "
                             "use_gridfill=%b use_sphere=%b",
                             EDGE_MARK, dia, (1 << (subdiv - 1)) - 1,
                             TRUE, TRUE);
 
                BMO_op_exec(bm, &bmop);
-               BMO_slot_buffer_flag_enable(bm, bmop.slots_out, "geomout", BM_VERT, VERT_MARK);
-               BMO_slot_buffer_flag_enable(bm, bmop.slots_out, "geomout", BM_EDGE, EDGE_MARK);
+               BMO_slot_buffer_flag_enable(bm, bmop.slots_out, "geom.out", BM_VERT, VERT_MARK);
+               BMO_slot_buffer_flag_enable(bm, bmop.slots_out, "geom.out", BM_EDGE, EDGE_MARK);
                BMO_op_finish(bm, &bmop);
        }
 
@@ -447,7 +453,7 @@ void bmo_create_icosphere_exec(BMesh *bm, BMOperator *op)
                }
        }
 
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "vertout", BM_VERT, VERT_MARK);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "verts.out", BM_VERT, VERT_MARK);
 }
 
 void bmo_create_monkey_exec(BMesh *bm, BMOperator *op)
@@ -494,18 +500,19 @@ void bmo_create_monkey_exec(BMesh *bm, BMOperator *op)
 
        MEM_freeN(tv);
 
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "vertout", BM_VERT, VERT_MARK);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "verts.out", BM_VERT, VERT_MARK);
 }
 
 
 void bmo_create_circle_exec(BMesh *bm, BMOperator *op)
 {
+       const float dia = BMO_slot_float_get(op->slots_in, "diameter");
+       const int segs = BMO_slot_int_get(op->slots_in, "segments");
+       const int cap_ends = BMO_slot_bool_get(op->slots_in, "cap_ends");
+       const int cap_tris = BMO_slot_bool_get(op->slots_in, "cap_tris");
+
        BMVert *v1, *lastv1 = NULL, *cent1, *firstv1 = NULL;
        float vec[3], mat[4][4], phi, phid;
-       float dia = BMO_slot_float_get(op->slots_in, "diameter");
-       int segs = BMO_slot_int_get(op->slots_in, "segments");
-       int cap_ends = BMO_slot_bool_get(op->slots_in, "cap_ends");
-       int cap_tris = BMO_slot_bool_get(op->slots_in, "cap_tris");
        int a;
        
        if (!segs)
@@ -566,7 +573,7 @@ void bmo_create_circle_exec(BMesh *bm, BMOperator *op)
                BMO_op_callf(bm, op->flag, "dissolve_faces faces=%ff", FACE_NEW);
        }
        
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "vertout", BM_VERT, VERT_MARK);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "verts.out", BM_VERT, VERT_MARK);
 }
 
 void bmo_create_cone_exec(BMesh *bm, BMOperator *op)
@@ -662,7 +669,7 @@ void bmo_create_cone_exec(BMesh *bm, BMOperator *op)
        BM_face_create_quad_tri(bm, v1, v2, firstv2, firstv1, NULL, FALSE);
 
        BMO_op_callf(bm, op->flag, "remove_doubles verts=%fv dist=%f", VERT_MARK, 0.000001);
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "vertout", BM_VERT, VERT_MARK);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "verts.out", BM_VERT, VERT_MARK);
 }
 
 void bmo_create_cube_exec(BMesh *bm, BMOperator *op)
@@ -740,5 +747,5 @@ void bmo_create_cube_exec(BMesh *bm, BMOperator *op)
        BM_face_create_quad_tri(bm, v1, v2, v3, v4, NULL, FALSE);
        BM_face_create_quad_tri(bm, v8, v7, v6, v5, NULL, FALSE);
 
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "vertout", BM_VERT, VERT_MARK);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "verts.out", BM_VERT, VERT_MARK);
 }
index 8187be734e80d4cb3da3f07b1ff7e95ca21629c5..e866abcb6dc2e8327a4dfde0754911ad58d4983b 100644 (file)
@@ -573,7 +573,7 @@ void bmo_remove_doubles_exec(BMesh *bm, BMOperator *op)
 void bmo_find_doubles_exec(BMesh *bm, BMOperator *op)
 {
        bmesh_find_doubles_common(bm, op,
-                                 op, op->slots_out, "targetmapout");
+                                 op, op->slots_out, "targetmap.out");
 }
 
 void bmo_automerge_exec(BMesh *bm, BMOperator *op)
@@ -601,7 +601,7 @@ void bmo_automerge_exec(BMesh *bm, BMOperator *op)
 
        /* weld the vertices */
        BMO_op_init(bm, &weldop, op->flag, "weld_verts");
-       BMO_slot_copy(&findop, slots_out, "targetmapout",
+       BMO_slot_copy(&findop, slots_out, "targetmap.out",
                      &weldop, slots_in,  "targetmap");
        BMO_op_exec(bm, &weldop);
 
index 6193da60511fd5faeb3ae10c24519af919afd61e..548e1adf17d4b78f337c77b3630ecb1cb7364aaa 100644 (file)
@@ -256,7 +256,7 @@ void bmo_similar_faces_exec(BMesh *bm, BMOperator *op)
        MEM_freeN(indices);
 
        /* transfer all marked faces to the output slot */
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "faceout", BM_FACE, FACE_MARK);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "faces.out", BM_FACE, FACE_MARK);
 #undef FACE_MARK
 }
 
@@ -474,7 +474,7 @@ void bmo_similar_edges_exec(BMesh *bm, BMOperator *op)
        MEM_freeN(indices);
 
        /* transfer all marked edges to the output slot */
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edgeout", BM_EDGE, EDGE_MARK);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edges.out", BM_EDGE, EDGE_MARK);
 
 #undef EDGE_MARK
 }
@@ -608,7 +608,7 @@ void bmo_similar_verts_exec(BMesh *bm, BMOperator *op)
        MEM_freeN(indices);
        MEM_freeN(v_ext);
 
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "vertout", BM_VERT, VERT_MARK);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "verts.out", BM_VERT, VERT_MARK);
 
 #undef VERT_MARK
 }
index 1fffaf358c03cba4398d85125ed314963a797bde..9dde2461364fe85b2d5139a56c61a583e5bd27e3 100644 (file)
@@ -108,7 +108,7 @@ void bmo_slide_vert_exec(BMesh *bm, BMOperator *op)
        }
 
        /* Return the new edge. The same previously marked with VERT_MARK */
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "vertout", BM_VERT, VERT_MARK);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "verts.out", BM_VERT, VERT_MARK);
        return;
 }
 
index 04bc2e98c0b9acc66702181c9f59f27941b02279..4137c31961c98ef95c5c8976329245ff37592a55 100644 (file)
@@ -78,7 +78,7 @@ static void delete_laplacian_system(LaplacianSystem *sys);
 static void delete_void_pointer(void *data);
 static void fill_laplacian_matrix(LaplacianSystem *sys);
 static void memset_laplacian_system(LaplacianSystem *sys, int val);
-static void validate_solution(LaplacianSystem *sys, int usex, int usey, int usez, int volumepreservation);
+static void validate_solution(LaplacianSystem *sys, int usex, int usey, int usez, int preserve_volume);
 static void volume_preservation(BMOperator *op, float vini, float vend, int usex, int usey, int usez);
 
 static void delete_void_pointer(void *data)
@@ -478,7 +478,7 @@ static void volume_preservation(BMOperator *op, float vini, float vend, int usex
        }
 }
 
-static void validate_solution(LaplacianSystem *sys, int usex, int usey, int usez, int volumepreservation)
+static void validate_solution(LaplacianSystem *sys, int usex, int usey, int usez, int preserve_volume)
 {
        int m_vertex_id;
        float leni, lene;
@@ -509,7 +509,7 @@ static void validate_solution(LaplacianSystem *sys, int usex, int usey, int usez
                }
        }
 
-       if (volumepreservation) {
+       if (preserve_volume) {
                vini = compute_volume(sys->bm);
        }
        BMO_ITER (v, &siter, sys->op->slots_in, "verts", BM_VERT) {
@@ -526,7 +526,7 @@ static void validate_solution(LaplacianSystem *sys, int usex, int usey, int usez
                        }
                }
        }
-       if (volumepreservation) {
+       if (preserve_volume) {
                vend = compute_volume(sys->bm);
                volume_preservation(sys->op, vini, vend, usex, usey, usez);
        }
@@ -537,7 +537,7 @@ void bmo_smooth_laplacian_vert_exec(BMesh *bm, BMOperator *op)
 {
        int i;
        int m_vertex_id;
-       int usex, usey, usez, volumepreservation;
+       int usex, usey, usez, preserve_volume;
        float lambda, lambda_border;
        float w;
        BMOIter siter;
@@ -558,7 +558,7 @@ void bmo_smooth_laplacian_vert_exec(BMesh *bm, BMOperator *op)
        usex = BMO_slot_bool_get(op->slots_in, "use_x");
        usey = BMO_slot_bool_get(op->slots_in, "use_y");
        usez = BMO_slot_bool_get(op->slots_in, "use_z");
-       volumepreservation = BMO_slot_bool_get(op->slots_in, "volume_preservation");
+       preserve_volume = BMO_slot_bool_get(op->slots_in, "preserve_volume");
 
 
        nlNewContext();
@@ -612,7 +612,7 @@ void bmo_smooth_laplacian_vert_exec(BMesh *bm, BMOperator *op)
        nlEnd(NL_SYSTEM);
 
        if (nlSolveAdvanced(NULL, NL_TRUE) ) {
-               validate_solution(sys, usex, usey, usez, volumepreservation);
+               validate_solution(sys, usex, usey, usez, preserve_volume);
        }
 
        delete_laplacian_system(sys);
index c693851336a5809e389c8677844ad803056271a7..5032545af89c9aa830d89a1d655f1b728591b90e 100644 (file)
@@ -719,12 +719,12 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op)
        
        BMO_slot_buffer_flag_enable(bm, op->slots_in, "edges", BM_EDGE, SUBD_SPLIT);
        
-       numcuts = BMO_slot_int_get(op->slots_in, "numcuts");
+       numcuts = BMO_slot_int_get(op->slots_in, "cuts");
        seed = BMO_slot_int_get(op->slots_in, "seed");
        smooth = BMO_slot_float_get(op->slots_in, "smooth");
        fractal = BMO_slot_float_get(op->slots_in, "fractal");
        along_normal = BMO_slot_float_get(op->slots_in, "along_normal");
-       cornertype = BMO_slot_int_get(op->slots_in, "quadcornertype");
+       cornertype = BMO_slot_int_get(op->slots_in, "quad_corner_type");
 
        use_singleedge = BMO_slot_bool_get(op->slots_in, "use_singleedge");
        use_gridfill   = BMO_slot_bool_get(op->slots_in, "use_gridfill");
@@ -1074,10 +1074,10 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op)
        BLI_array_free(loops_split);
        BLI_array_free(loops);
 
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "innerout", BM_ALL, ELE_INNER);
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "splitout", BM_ALL, ELE_SPLIT);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom_inner.out", BM_ALL, ELE_INNER);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom_split.out", BM_ALL, ELE_SPLIT);
        
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geomout", BM_ALL, ELE_INNER | ELE_SPLIT | SUBD_SPLIT);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom.out", BM_ALL, ELE_INNER | ELE_SPLIT | SUBD_SPLIT);
 }
 
 /* editmesh-emulating function */
@@ -1094,8 +1094,8 @@ void BM_mesh_esubdivide(BMesh *bm, const char edge_hflag,
        BMO_op_initf(bm, &op, BMO_FLAG_DEFAULTS,
                     "subdivide_edges edges=%he "
                     "smooth=%f fractal=%f along_normal=%f "
-                    "numcuts=%i "
-                    "quadcornertype=%i "
+                    "cuts=%i "
+                    "quad_corner_type=%i "
                     "use_singleedge=%b use_gridfill=%b "
                     "seed=%i",
                     edge_hflag,
@@ -1111,7 +1111,7 @@ void BM_mesh_esubdivide(BMesh *bm, const char edge_hflag,
                BMOIter iter;
                BMElem *ele;
 
-               for (ele = BMO_iter_new(&iter, op.slots_out, "innerout", BM_EDGE | BM_VERT); ele; ele = BMO_iter_step(&iter)) {
+               for (ele = BMO_iter_new(&iter, op.slots_out, "geom_inner.out", BM_EDGE | BM_VERT); ele; ele = BMO_iter_step(&iter)) {
                        BM_elem_select_set(bm, ele, TRUE);
                }
        }
@@ -1122,7 +1122,7 @@ void BM_mesh_esubdivide(BMesh *bm, const char edge_hflag,
                /* deselect input */
                BM_mesh_elem_hflag_disable_all(bm, BM_VERT | BM_EDGE | BM_FACE, BM_ELEM_SELECT, FALSE);
 
-               for (ele = BMO_iter_new(&iter, op.slots_out, "innerout", BM_EDGE | BM_VERT); ele; ele = BMO_iter_step(&iter)) {
+               for (ele = BMO_iter_new(&iter, op.slots_out, "geom_inner.out", BM_EDGE | BM_VERT); ele; ele = BMO_iter_step(&iter)) {
                        BM_elem_select_set(bm, ele, TRUE);
 
                        if (ele->head.htype == BM_VERT) {
@@ -1157,7 +1157,7 @@ void bmo_bisect_edges_exec(BMesh *bm, BMOperator *op)
        SubDParams params = {0};
        int skey;
        
-       params.numcuts = BMO_slot_int_get(op->slots_in, "numcuts");
+       params.numcuts = BMO_slot_int_get(op->slots_in, "cuts");
        params.op = op;
        
        BM_data_layer_add(bm, &bm->vdata, CD_SHAPEKEY);
@@ -1170,7 +1170,7 @@ void bmo_bisect_edges_exec(BMesh *bm, BMOperator *op)
                bm_subdivide_multicut(bm, e, &params, e->v1, e->v2);
        }
 
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "splitout", BM_ALL, ELE_SPLIT);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom_split.out", BM_ALL, ELE_SPLIT);
 
        BM_data_layer_free_n(bm, &bm->vdata, CD_SHAPEKEY, skey);
 }
index a2f5d7d2d7ca881c9a68712edd4a7dda6c05f062..8c440cae83ef07297ac2a27b4f7467f646e99864 100644 (file)
@@ -658,6 +658,6 @@ void bmo_symmetrize_exec(BMesh *bm, BMOperator *op)
        BLI_ghash_free(symm.vert_symm_map, NULL, NULL);
        BLI_ghash_free(symm.edge_split_map, NULL, NULL);
 
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geomout",
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom.out",
                                          BM_ALL, SYMM_OUTPUT_GEOM);
 }
index 55cc111b68d6f7d2d0089b26fb075fc3cbfea860..324c95a0ff79ce8812ca03503373c4cb1686df93 100644 (file)
@@ -64,14 +64,14 @@ void bmo_triangulate_exec(BMesh *bm, BMOperator *op)
 
                BM_face_triangulate(bm, face, projectverts, EDGE_NEW, FACE_NEW, newfaces, use_beauty);
 
-               BMO_slot_map_ptr_insert(op, op->slots_out, "facemap_out", face, face);
+               BMO_slot_map_ptr_insert(op, op->slots_out, "facemap.out", face, face);
                for (i = 0; newfaces[i]; i++) {
-                       BMO_slot_map_ptr_insert(op, op->slots_out, "facemap_out", newfaces[i], face);
+                       BMO_slot_map_ptr_insert(op, op->slots_out, "facemap.out", newfaces[i], face);
                }
        }
        
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edgeout", BM_EDGE, EDGE_NEW);
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "faceout", BM_FACE, FACE_NEW);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edges.out", BM_EDGE, EDGE_NEW);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "faces.out", BM_FACE, FACE_NEW);
        
        BLI_array_free(projectverts);
        BLI_array_free(newfaces);
@@ -150,7 +150,7 @@ void bmo_beautify_fill_exec(BMesh *bm, BMOperator *op)
                }
        }
        
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geomout", BM_EDGE | BM_FACE, ELE_NEW);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom.out", BM_EDGE | BM_FACE, ELE_NEW);
 }
 
 void bmo_triangle_fill_exec(BMesh *bm, BMOperator *op)
@@ -212,8 +212,8 @@ void bmo_triangle_fill_exec(BMesh *bm, BMOperator *op)
        /* clean up fill */
        BMO_op_initf(bm, &bmop, op->flag, "beautify_fill faces=%ff constrain_edges=%fe", ELE_NEW, EDGE_MARK);
        BMO_op_exec(bm, &bmop);
-       BMO_slot_buffer_flag_enable(bm, bmop.slots_out, "geomout", BM_FACE | BM_EDGE, ELE_NEW);
+       BMO_slot_buffer_flag_enable(bm, bmop.slots_out, "geom.out", BM_FACE | BM_EDGE, ELE_NEW);
        BMO_op_finish(bm, &bmop);
        
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geomout", BM_EDGE | BM_FACE, ELE_NEW);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom.out", BM_EDGE | BM_FACE, ELE_NEW);
 }
index 31ed841c06f0e1990995e076b1570a0c94dbd586..d56b2ca0d7346b842e3b2186cc7bef80ceabd25e 100644 (file)
@@ -48,7 +48,7 @@ void bmo_create_vert_exec(BMesh *bm, BMOperator *op)
        BMO_slot_vec_get(op->slots_in, "co", vec);
 
        BMO_elem_flag_enable(bm, BM_vert_create(bm, vec, NULL), 1);
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "newvertout", BM_VERT, 1);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "vert.out", BM_VERT, 1);
 }
 
 void bmo_transform_exec(BMesh *UNUSED(bm), BMOperator *op)
@@ -122,8 +122,8 @@ void bmo_rotate_edges_exec(BMesh *bm, BMOperator *op)
 {
        BMOIter siter;
        BMEdge *e, *e2;
-       int ccw = BMO_slot_bool_get(op->slots_in, "ccw");
-       int is_single = BMO_slot_buffer_count(op->slots_in, "edges") == 1;
+       const int use_ccw = BMO_slot_bool_get(op->slots_in, "use_ccw");
+       const int is_single = BMO_slot_buffer_count(op->slots_in, "edges") == 1;
        short check_flag = is_single ?
                    BM_EDGEROT_CHECK_EXISTS :
                    BM_EDGEROT_CHECK_EXISTS | BM_EDGEROT_CHECK_DEGENERATE;
@@ -144,7 +144,7 @@ void bmo_rotate_edges_exec(BMesh *bm, BMOperator *op)
                                    BMO_elem_flag_test(bm, fb, FACE_TAINT) == FALSE)
                                {
 
-                                       if (!(e2 = BM_edge_rotate(bm, e, ccw, check_flag))) {
+                                       if (!(e2 = BM_edge_rotate(bm, e, use_ccw, check_flag))) {
 #if 0
                                                BMO_error_raise(bm, op, BMERR_INVALID_SELECTION, "Could not rotate edge");
                                                return;
@@ -162,7 +162,7 @@ void bmo_rotate_edges_exec(BMesh *bm, BMOperator *op)
                }
        }
 
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edgeout", BM_EDGE, EDGE_OUT);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edges.out", BM_EDGE, EDGE_OUT);
 
 #undef EDGE_OUT
 #undef FACE_TAINT
@@ -266,7 +266,7 @@ static void bmo_region_extend_constrict(BMesh *bm, BMOperator *op, int usefaces)
 void bmo_region_extend_exec(BMesh *bm, BMOperator *op)
 {
        int use_faces = BMO_slot_bool_get(op->slots_in, "use_faces");
-       int constrict = BMO_slot_bool_get(op->slots_in, "constrict");
+       int constrict = BMO_slot_bool_get(op->slots_in, "use_constrict");
 
        BMO_slot_buffer_flag_enable(bm, op->slots_in, "geom", BM_ALL, SEL_ORIG);
 
@@ -275,7 +275,7 @@ void bmo_region_extend_exec(BMesh *bm, BMOperator *op)
        else
                bmo_region_extend_extend(bm, op, use_faces);
 
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geomout", BM_ALL, SEL_FLAG);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom.out", BM_ALL, SEL_FLAG);
 }
 
 /********* righthand faces implementation ****** */
@@ -314,7 +314,7 @@ void bmo_recalc_face_normals_exec(BMesh *bm, BMOperator *op)
        BLI_array_declare(fstack);
        BMLoop *l, *l2;
        float maxx, maxx_test, cent[3];
-       int i, i_max, flagflip = BMO_slot_bool_get(op->slots_in, "do_flip");
+       int i, i_max, flagflip = BMO_slot_bool_get(op->slots_in, "use_flip");
 
        startf = NULL;
        maxx = -1.0e10;
@@ -421,7 +421,7 @@ void bmo_smooth_vert_exec(BMesh *UNUSED(bm), BMOperator *op)
        BMEdge *e;
        BLI_array_declare(cos);
        float (*cos)[3] = NULL;
-       float *co, *co2, clipdist = BMO_slot_float_get(op->slots_in, "clipdist");
+       float *co, *co2, clip_dist = BMO_slot_float_get(op->slots_in, "clip_dist");
        int i, j, clipx, clipy, clipz;
        int xaxis, yaxis, zaxis;
        
@@ -454,11 +454,11 @@ void bmo_smooth_vert_exec(BMesh *UNUSED(bm), BMOperator *op)
                mul_v3_fl(co, 1.0f / (float)j);
                mid_v3_v3v3(co, co, v->co);
 
-               if (clipx && fabsf(v->co[0]) <= clipdist)
+               if (clipx && fabsf(v->co[0]) <= clip_dist)
                        co[0] = 0.0f;
-               if (clipy && fabsf(v->co[1]) <= clipdist)
+               if (clipy && fabsf(v->co[1]) <= clip_dist)
                        co[1] = 0.0f;
-               if (clipz && fabsf(v->co[2]) <= clipdist)
+               if (clipz && fabsf(v->co[2]) <= clip_dist)
                        co[2] = 0.0f;
 
                i++;
@@ -489,11 +489,11 @@ void bmo_rotate_uvs_exec(BMesh *bm, BMOperator *op)
        BMFace *fs;       /* current face */
        BMIter l_iter;    /* iteration loop */
 
-       int dir = BMO_slot_int_get(op->slots_in, "dir");
+       const int use_ccw = BMO_slot_bool_get(op->slots_in, "use_ccw");
 
        BMO_ITER (fs, &fs_iter, op->slots_in, "faces", BM_FACE) {
                if (CustomData_has_layer(&(bm->ldata), CD_MLOOPUV)) {
-                       if (dir == DIRECTION_CW) { /* same loops direction */
+                       if (use_ccw == FALSE) {  /* same loops direction */
                                BMLoop *lf;     /* current face loops */
                                MLoopUV *f_luv; /* first face loop uv */
                                float p_uv[2];  /* previous uvs */
@@ -517,7 +517,7 @@ void bmo_rotate_uvs_exec(BMesh *bm, BMOperator *op)
 
                                copy_v2_v2(f_luv->uv, p_uv);
                        }
-                       else if (dir == DIRECTION_CCW) { /* counter loop direction */
+                       else { /* counter loop direction */
                                BMLoop *lf;     /* current face loops */
                                MLoopUV *p_luv; /* previous loop uv */
                                MLoopUV *luv;
@@ -594,11 +594,11 @@ void bmo_rotate_colors_exec(BMesh *bm, BMOperator *op)
        BMFace *fs;       /* current face */
        BMIter l_iter;    /* iteration loop */
 
-       int dir = BMO_slot_int_get(op->slots_in, "dir");
+       const int use_ccw = BMO_slot_bool_get(op->slots_in, "use_ccw");
 
        BMO_ITER (fs, &fs_iter, op->slots_in, "faces", BM_FACE) {
                if (CustomData_has_layer(&(bm->ldata), CD_MLOOPCOL)) {
-                       if (dir == DIRECTION_CW) { /* same loops direction */
+                       if (use_ccw == FALSE) {  /* same loops direction */
                                BMLoop *lf;     /* current face loops */
                                MLoopCol *f_lcol; /* first face loop color */
                                MLoopCol p_col; /* previous color */
@@ -622,7 +622,7 @@ void bmo_rotate_colors_exec(BMesh *bm, BMOperator *op)
 
                                *f_lcol = p_col;
                        }
-                       else if (dir == DIRECTION_CCW) { /* counter loop direction */
+                       else  /* counter loop direction */
                                BMLoop *lf;     /* current face loops */
                                MLoopCol *p_lcol; /* previous loop color */
                                MLoopCol *lcol;
@@ -796,5 +796,5 @@ void bmo_shortest_path_exec(BMesh *bm, BMOperator *op)
        BLI_heap_free(h, NULL);
        MEM_freeN(vert_list);
 
-       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "vertout", BM_VERT, VERT_MARK);
+       BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "verts.out", BM_VERT, VERT_MARK);
 }
index b34d9edc43088073e8f485d059f2435cd925da29..532145ab1298231ff3f50f753bf51e0eb2276325 100644 (file)
@@ -423,5 +423,5 @@ void bmo_wireframe_exec(BMesh *bm, BMOperator *op)
        MEM_freeN(verts_pos);
        MEM_freeN(verts_loop);
 
-       BMO_slot_buffer_from_enabled_hflag(bm, op, op->slots_out, "faceout", BM_FACE, BM_ELEM_TAG);
+       BMO_slot_buffer_from_enabled_hflag(bm, op, op->slots_out, "faces.out", BM_FACE, BM_ELEM_TAG);
 }
index 48da23d5e8d83b35a8e2ef23381e10990615f38f..e801d3689e53f3868e75894b717adc551c2ce337 100644 (file)
@@ -3569,16 +3569,16 @@ static int armature_subdivide_exec(bContext *C, wmOperator *op)
        Object *obedit = CTX_data_edit_object(C);
        bArmature *arm = obedit->data;
        EditBone *newbone, *tbone;
-       int numcuts, i;
+       int cuts, i;
        
        /* there may not be a number_cuts property defined (for 'simple' subdivide) */
-       numcuts = RNA_int_get(op->ptr, "number_cuts");
+       cuts = RNA_int_get(op->ptr, "number_cuts");
        
        /* loop over all editable bones */
        // XXX the old code did this in reverse order though!
        CTX_DATA_BEGIN(C, EditBone *, ebone, selected_editable_bones)
        {
-               for (i = numcuts + 1; i > 1; i--) {
+               for (i = cuts + 1; i > 1; i--) {
                        /* compute cut ratio first */
                        float cutratio = 1.0f / (float)i;
                        float cutratioI = 1.0f - cutratio;
index b8736d4f1d032463fad883c122c89b876f5b4fab..ee96ba71cddafaf186ac488603085f90d3299445 100644 (file)
@@ -108,7 +108,7 @@ static int add_primitive_plane_exec(bContext *C, wmOperator *op)
        obedit = make_prim_init(C, "Plane", &dia, mat, &state, loc, rot, layer);
        em = BMEdit_FromObject(obedit);
 
-       if (!EDBM_op_call_and_selectf(em, op, "vertout",
+       if (!EDBM_op_call_and_selectf(em, op, "verts.out",
                                      "create_grid xsegments=%i ysegments=%i size=%f mat=%m4", 1, 1, dia, mat))
        {
                return OPERATOR_CANCELLED;
@@ -149,7 +149,7 @@ static int add_primitive_cube_exec(bContext *C, wmOperator *op)
        obedit = make_prim_init(C, "Cube", &dia, mat, &state, loc, rot, layer);
        em = BMEdit_FromObject(obedit);
 
-       if (!EDBM_op_call_and_selectf(em, op, "vertout", "create_cube mat=%m4 size=%f", mat, dia * 2.0f)) {
+       if (!EDBM_op_call_and_selectf(em, op, "verts.out", "create_cube mat=%m4 size=%f", mat, dia * 2.0f)) {
                return OPERATOR_CANCELLED;
        }
 
@@ -198,7 +198,7 @@ static int add_primitive_circle_exec(bContext *C, wmOperator *op)
        obedit = make_prim_init(C, "Circle", &dia, mat, &state, loc, rot, layer);
        em = BMEdit_FromObject(obedit);
 
-       if (!EDBM_op_call_and_selectf(em, op, "vertout",
+       if (!EDBM_op_call_and_selectf(em, op, "verts.out",
                                      "create_circle segments=%i diameter=%f cap_ends=%b cap_tris=%b mat=%m4",
                                      RNA_int_get(op->ptr, "vertices"), RNA_float_get(op->ptr, "radius") * dia,
                                      cap_end, cap_tri, mat))
@@ -253,7 +253,7 @@ static int add_primitive_cylinder_exec(bContext *C, wmOperator *op)
        em = BMEdit_FromObject(obedit);
 
        if (!EDBM_op_call_and_selectf(
-               em, op, "vertout",
+               em, op, "verts.out",
                "create_cone segments=%i diameter1=%f diameter2=%f cap_ends=%b cap_tris=%b depth=%f mat=%m4",
                RNA_int_get(op->ptr, "vertices"),
                RNA_float_get(op->ptr, "radius") * dia,
@@ -313,7 +313,7 @@ static int add_primitive_cone_exec(bContext *C, wmOperator *op)
        em = BMEdit_FromObject(obedit);
 
        if (!EDBM_op_call_and_selectf(
-               em, op, "vertout",
+               em, op, "verts.out",
                "create_cone segments=%i diameter1=%f diameter2=%f cap_ends=%b cap_tris=%b depth=%f mat=%m4",
                RNA_int_get(op->ptr, "vertices"), RNA_float_get(op->ptr, "radius1") * dia,
                RNA_float_get(op->ptr, "radius2") * dia, cap_end, cap_tri, RNA_float_get(op->ptr, "depth") * dia, mat))
@@ -368,8 +368,8 @@ static int add_primitive_grid_exec(bContext *C, wmOperator *op)
        obedit = make_prim_init(C, "Grid", &dia, mat, &state, loc, rot, layer);
        em = BMEdit_FromObject(obedit);
 
-       if (!EDBM_op_call_and_selectf(em, op, "vertout",
-                                     "create_grid xsegments=%i ysegments=%i size=%f mat=%m4",
+       if (!EDBM_op_call_and_selectf(em, op, "verts.out",
+                                     "create_grid x_segments=%i y_segments=%i size=%f mat=%m4",
                                      RNA_int_get(op->ptr, "x_subdivisions"),
                                      RNA_int_get(op->ptr, "y_subdivisions"),
                                      RNA_float_get(op->ptr, "size") * dia, mat))
@@ -427,7 +427,7 @@ static int add_primitive_monkey_exec(bContext *C, wmOperator *op)
 
        em = BMEdit_FromObject(obedit);
 
-       if (!EDBM_op_call_and_selectf(em, op, "vertout", "create_monkey mat=%m4", mat)) {
+       if (!EDBM_op_call_and_selectf(em, op, "verts.out", "create_monkey mat=%m4", mat)) {
                return OPERATOR_CANCELLED;
        }
 
@@ -466,8 +466,8 @@ static int add_primitive_uvsphere_exec(bContext *C, wmOperator *op)
        obedit = make_prim_init(C, "Sphere", &dia, mat, &state, loc, rot, layer);
        em = BMEdit_FromObject(obedit);
 
-       if (!EDBM_op_call_and_selectf(em, op, "vertout",
-                                     "create_uvsphere segments=%i revolutions=%i diameter=%f mat=%m4",
+       if (!EDBM_op_call_and_selectf(em, op, "verts.out",
+                                     "create_uvsphere u_segments=%i v_segments=%i diameter=%f mat=%m4",
                                      RNA_int_get(op->ptr, "segments"), RNA_int_get(op->ptr, "ring_count"),
                                      RNA_float_get(op->ptr, "size") * dia, mat))
        {
@@ -518,7 +518,7 @@ static int add_primitive_icosphere_exec(bContext *C, wmOperator *op)
        em = BMEdit_FromObject(obedit);
 
        if (!EDBM_op_call_and_selectf(
-               em, op, "vertout",
+               em, op, "verts.out",
                "create_icosphere subdivisions=%i diameter=%f mat=%m4",
                RNA_int_get(op->ptr, "subdivisions"),
                RNA_float_get(op->ptr, "size") * dia, mat))
index 5ba85115b2fcce74b16584c3167d3647572335ba..aed16be5b73083adb2afafe49f235c60a27ab339 100644 (file)
@@ -1823,7 +1823,7 @@ static void remerge_faces(KnifeTool_OpData *kcd)
        BMO_op_initf(bm, &bmop, "beautify_fill faces=%ff constrain_edges=%fe", FACE_NEW, BOUNDARY);
 
        BMO_op_exec(bm, &bmop);
-       BMO_slot_buffer_flag_enable(bm, &bmop, "geomout", BM_FACE, FACE_NEW);
+       BMO_slot_buffer_flag_enable(bm, &bmop, "geom.out", BM_FACE, FACE_NEW);
 
        BMO_op_finish(bm, &bmop);
 
index a98983159b39207a2b55d5c86e228afa467be0bb..8e13dcf25805d1b7ad4513323c10be48995d7bdb 100644 (file)
@@ -732,7 +732,7 @@ static int similar_face_select_exec(bContext *C, wmOperator *op)
        EDBM_flag_disable_all(em, BM_ELEM_SELECT);
 
        /* select the output */
-       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faceout", BM_ALL, BM_ELEM_SELECT, TRUE);
+       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faces.out", BM_ALL, BM_ELEM_SELECT, TRUE);
 
        /* finish the operator */
        if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
@@ -773,7 +773,7 @@ static int similar_edge_select_exec(bContext *C, wmOperator *op)
        EDBM_flag_disable_all(em, BM_ELEM_SELECT);
 
        /* select the output */
-       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "edgeout", BM_ALL, BM_ELEM_SELECT, TRUE);
+       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "edges.out", BM_ALL, BM_ELEM_SELECT, TRUE);
        EDBM_selectmode_flush(em);
 
        /* finish the operator */
@@ -817,7 +817,7 @@ static int similar_vert_select_exec(bContext *C, wmOperator *op)
        EDBM_flag_disable_all(em, BM_ELEM_SELECT);
 
        /* select the output */
-       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "vertout", BM_ALL, BM_ELEM_SELECT, TRUE);
+       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "verts.out", BM_ALL, BM_ELEM_SELECT, TRUE);
 
        /* finish the operator */
        if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
index 9b2e231394511ca0ea33447c12977a523fb8bb53..c32033054e0bfc874035d7c0446ff4d9f5a0f91e 100644 (file)
@@ -741,7 +741,7 @@ static int edbm_vertex_slide_exec_ex(bContext *C, wmOperator *op, const int do_u
        BMO_slot_buffer_hflag_disable(bm, bmop.slots_in, "edge", BM_ALL, BM_ELEM_SELECT, TRUE);
 
        /* Select the output vert */
-       BMO_slot_buffer_hflag_enable(bm, bmop.slots_out, "vertout", BM_ALL, BM_ELEM_SELECT, TRUE);
+       BMO_slot_buffer_hflag_enable(bm, bmop.slots_out, "verts.out", BM_ALL, BM_ELEM_SELECT, TRUE);
 
        /* Flush the select buffers */
        EDBM_selectmode_flush(em);
index 3e979878b41d3800d68557baf15fb0e11105030c..4a739f0aede346646a9f669a0b0f10818282e70d 100644 (file)
@@ -242,7 +242,7 @@ static short edbm_extrude_discrete_faces(BMEditMesh *em, wmOperator *op, const c
 
        BMO_op_exec(em->bm, &bmop);
        
-       BMO_ITER (f, &siter, bmop.slots_out, "faceout", BM_FACE) {
+       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 */
@@ -269,7 +269,7 @@ static short edbm_extrude_edges_indiv(BMEditMesh *em, wmOperator *op, const char
        EDBM_flag_disable_all(em, BM_ELEM_SELECT);
 
        BMO_op_exec(em->bm, &bmop);
-       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "geomout", BM_VERT | BM_EDGE, BM_ELEM_SELECT, TRUE);
+       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;
@@ -289,7 +289,7 @@ static short edbm_extrude_verts_indiv(BMEditMesh *em, wmOperator *op, const char
        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, "vertout", BM_VERT, BM_ELEM_SELECT, TRUE);
+       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;
@@ -310,7 +310,7 @@ static short edbm_extrude_edge(Object *obedit, BMEditMesh *em, const char hflag,
        BMElem *ele;
        
        BMO_op_init(bm, &extop, BMO_FLAG_DEFAULTS, "extrude_face_region");
-       BMO_slot_buffer_from_enabled_hflag(bm, &extop, extop.slots_in, "edgefacein", BM_VERT | BM_EDGE | BM_FACE, hflag);
+       BMO_slot_buffer_from_enabled_hflag(bm, &extop, extop.slots_in, "geom", BM_VERT | BM_EDGE | BM_FACE, hflag);
 
        /* 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.
@@ -350,21 +350,21 @@ static short edbm_extrude_edge(Object *obedit, BMEditMesh *em, const char hflag,
                                                        if ((fabsf(co1[0]) < mmd->tolerance) &&
                                                            (fabsf(co2[0]) < mmd->tolerance))
                                                        {
-                                                               BMO_slot_map_ptr_insert(&extop, extop.slots_in, "exclude", edge, NULL);
+                                                               BMO_slot_map_ptr_insert(&extop, extop.slots_in, "edges_exclude", edge, NULL);
                                                        }
                                                }
                                                if (mmd->flag & MOD_MIR_AXIS_Y) {
                                                        if ((fabsf(co1[1]) < mmd->tolerance) &&
                                                            (fabsf(co2[1]) < mmd->tolerance))
                                                        {
-                                                               BMO_slot_map_ptr_insert(&extop, extop.slots_in, "exclude", edge, NULL);
+                                                               BMO_slot_map_ptr_insert(&extop, extop.slots_in, "edges_exclude", edge, NULL);
                                                        }
                                                }
                                                if (mmd->flag & MOD_MIR_AXIS_Z) {
                                                        if ((fabsf(co1[2]) < mmd->tolerance) &&
                                                            (fabsf(co2[2]) < mmd->tolerance))
                                                        {
-                                                               BMO_slot_map_ptr_insert(&extop, extop.slots_in, "exclude", edge, NULL);
+                                                               BMO_slot_map_ptr_insert(&extop, extop.slots_in, "edges_exclude", edge, NULL);
                                                        }
                                                }
                                        }
@@ -379,7 +379,7 @@ static short edbm_extrude_edge(Object *obedit, BMEditMesh *em, const char hflag,
 
        zero_v3(nor);
        
-       BMO_ITER (ele, &siter, extop.slots_out, "geomout", BM_ALL) {
+       BMO_ITER (ele, &siter, extop.slots_out, "geom.out", BM_ALL) {
                BM_elem_select_set(bm, ele, TRUE);
 
                if (ele->head.htype == BM_FACE) {
@@ -449,7 +449,7 @@ static int edbm_extrude_repeat_exec(bContext *C, wmOperator *op)
 
        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 edgefacein=%hef", BM_ELEM_SELECT);
+               //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);
@@ -915,7 +915,7 @@ static int edbm_dupli_extrude_cursor_invoke(bContext *C, wmOperator *op, wmEvent
                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, "newvertout", BM_VERT) {
+               BMO_ITER (v1, &oiter, bmop.slots_out, "vert.out", BM_VERT) {
                        BM_vert_select_set(vc.em->bm, v1, TRUE);
                }
 
@@ -1110,8 +1110,8 @@ static int edbm_add_edge_face_exec(bContext *C, wmOperator *op)
        }
        
        BMO_op_exec(em->bm, &bmop);
-       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faceout", BM_FACE, BM_ELEM_SELECT, TRUE);
-       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "edgeout", BM_EDGE, BM_ELEM_SELECT, TRUE);
+       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faces.out", BM_FACE, BM_ELEM_SELECT, TRUE);
+       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "edges.out", BM_EDGE, BM_ELEM_SELECT, TRUE);
 
        if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
                return OPERATOR_CANCELLED;
@@ -1261,7 +1261,7 @@ static int edbm_vert_connect(bContext *C, wmOperator *op)
                return OPERATOR_CANCELLED;
        }
        BMO_op_exec(bm, &bmop);
-       len = BMO_slot_get(bmop.slots_out, "edgeout")->len;
+       len = BMO_slot_get(bmop.slots_out, "edges.out")->len;
        if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
                return OPERATOR_CANCELLED;
        }
@@ -1301,7 +1301,7 @@ static int edbm_edge_split_exec(bContext *C, wmOperator *op)
                return OPERATOR_CANCELLED;
        }
        BMO_op_exec(bm, &bmop);
-       len = BMO_slot_get(bmop.slots_out, "edgeout")->len;
+       len = BMO_slot_get(bmop.slots_out, "edges.out")->len;
        if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
                return OPERATOR_CANCELLED;
        }
@@ -1339,7 +1339,7 @@ static int edbm_duplicate_exec(bContext *C, wmOperator *op)
        BMO_op_exec(em->bm, &bmop);
        EDBM_flag_disable_all(em, BM_ELEM_SELECT);
 
-       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "newout", BM_ALL, BM_ELEM_SELECT, TRUE);
+       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "geom.out", BM_ALL, BM_ELEM_SELECT, TRUE);
 
        if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
                return OPERATOR_CANCELLED;
@@ -1405,8 +1405,8 @@ void MESH_OT_flip_normals(wmOperatorType *ot)
 }
 
 static const EnumPropertyItem direction_items[] = {
-       {DIRECTION_CW, "CW", 0, "Clockwise", ""},
-       {DIRECTION_CCW, "CCW", 0, "Counter Clockwise", ""},
+       {FALSE, "CW", 0, "Clockwise", ""},
+       {TRUE, "CCW", 0, "Counter Clockwise", ""},
        {0, NULL, 0, NULL, NULL}
 };
 
@@ -1418,7 +1418,7 @@ static int edbm_edge_rotate_selected_exec(bContext *C, wmOperator *op)
        BMOperator bmop;
        BMEdge *eed;
        BMIter iter;
-       const int do_ccw = RNA_enum_get(op->ptr, "direction") == 1;
+       const int use_ccw = RNA_boolean_get(op->ptr, "use_ccw");
        int tot = 0;
 
        if (em->bm->totedgesel == 0) {
@@ -1448,8 +1448,8 @@ static int edbm_edge_rotate_selected_exec(bContext *C, wmOperator *op)
                BKE_report(op->reports, RPT_ERROR, "Could not find any selected edges that can be rotated");
                return OPERATOR_CANCELLED;
        }
-       
-       EDBM_op_init(em, &bmop, op, "rotate_edges edges=%he ccw=%b", BM_ELEM_TAG, do_ccw);
+
+       EDBM_op_init(em, &bmop, op, "rotate_edges edges=%he use_ccw=%b", BM_ELEM_TAG, use_ccw);
 
        /* avoids leaving old verts selected which can be a problem running multiple times,
         * since this means the edges become selected around the face which then attempt to rotate */
@@ -1457,8 +1457,8 @@ static int edbm_edge_rotate_selected_exec(bContext *C, wmOperator *op)
 
        BMO_op_exec(em->bm, &bmop);
        /* edges may rotate into hidden vertices, if this does _not_ run we get an ilogical state */
-       BMO_slot_buffer_hflag_disable(em->bm, bmop.slots_out, "edgeout", BM_EDGE, BM_ELEM_HIDDEN, TRUE);
-       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "edgeout", BM_EDGE, BM_ELEM_SELECT, TRUE);
+       BMO_slot_buffer_hflag_disable(em->bm, bmop.slots_out, "edges.out", BM_EDGE, BM_ELEM_HIDDEN, TRUE);
+       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "edges.out", BM_EDGE, BM_ELEM_SELECT, TRUE);
        EDBM_selectmode_flush(em);
 
        if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
@@ -1485,7 +1485,7 @@ void MESH_OT_edge_rotate(wmOperatorType *ot)
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 
        /* props */
-       RNA_def_enum(ot->srna, "direction", direction_items, DIRECTION_CW, "Direction", "Direction to rotate edge around");
+       RNA_def_boolean(ot->srna, "use_ccw", FALSE, "Counter Clockwise", "");
 }
 
 
@@ -1553,7 +1553,7 @@ static int edbm_normals_make_consistent_exec(bContext *C, wmOperator *op)
        
        /* doflip has to do with bmesh_rationalize_normals, it's an internal
         * thing */
-       if (!EDBM_op_callf(em, op, "recalc_face_normals faces=%hf do_flip=%b", BM_ELEM_SELECT, TRUE))
+       if (!EDBM_op_callf(em, op, "recalc_face_normals faces=%hf use_flip=%b", BM_ELEM_SELECT, TRUE))
                return OPERATOR_CANCELLED;
 
        if (RNA_boolean_get(op->ptr, "inside"))
@@ -1590,7 +1590,7 @@ static int edbm_do_smooth_vertex_exec(bContext *C, wmOperator *op)
        ModifierData *md;
        int mirrx = FALSE, mirry = FALSE, mirrz = FALSE;
        int i, repeat;
-       float clipdist = 0.0f;
+       float clip_dist = 0.0f;
 
        int xaxis = RNA_boolean_get(op->ptr, "xaxis");
        int yaxis = RNA_boolean_get(op->ptr, "yaxis");
@@ -1616,7 +1616,7 @@ static int edbm_do_smooth_vertex_exec(bContext *C, wmOperator *op)
                                if (mmd->flag & MOD_MIR_AXIS_Z)
                                        mirrz = TRUE;
 
-                               clipdist = mmd->tolerance;
+                               clip_dist = mmd->tolerance;
                        }
                }
        }
@@ -1627,9 +1627,9 @@ static int edbm_do_smooth_vertex_exec(bContext *C, wmOperator *op)
        
        for (i = 0; i < repeat; i++) {
                if (!EDBM_op_callf(em, op,
-                                  "smooth_vert verts=%hv mirror_clip_x=%b mirror_clip_y=%b mirror_clip_z=%b clipdist=%f "
+                                  "smooth_vert verts=%hv mirror_clip_x=%b mirror_clip_y=%b mirror_clip_z=%b clip_dist=%f "
                                   "use_axis_x=%b use_axis_y=%b use_axis_z=%b",
-                                  BM_ELEM_SELECT, mirrx, mirry, mirrz, clipdist, xaxis, yaxis, zaxis))
+                                  BM_ELEM_SELECT, mirrx, mirry, mirrz, clip_dist, xaxis, yaxis, zaxis))
                {
                        return OPERATOR_CANCELLED;
                }
@@ -1670,7 +1670,7 @@ static int edbm_do_smooth_laplacian_vertex_exec(bContext *C, wmOperator *op)
 {
        Object *obedit = CTX_data_edit_object(C);
        BMEditMesh *em = BMEdit_FromObject(obedit);
-       int usex = TRUE, usey = TRUE, usez = TRUE, volume_preservation = TRUE;
+       int usex = TRUE, usey = TRUE, usez = TRUE, preserve_volume = TRUE;
        int i, repeat;
        float lambda;
        float lambda_border;
@@ -1698,14 +1698,14 @@ static int edbm_do_smooth_laplacian_vertex_exec(bContext *C, wmOperator *op)
        usex = RNA_boolean_get(op->ptr, "use_x");
        usey = RNA_boolean_get(op->ptr, "use_y");
        usez = RNA_boolean_get(op->ptr, "use_z");
-       volume_preservation = RNA_boolean_get(op->ptr, "volume_preservation");
+       preserve_volume = RNA_boolean_get(op->ptr, "preserve_volume");
        if (!repeat)
                repeat = 1;
        
        for (i = 0; i < repeat; i++) {
                if (!EDBM_op_callf(em, op,
-                                  "smooth_laplacian_vert verts=%hv lambda=%f lambda_border=%f use_x=%b use_y=%b use_z=%b volume_preservation=%b",
-                                  BM_ELEM_SELECT, lambda, lambda_border, usex, usey, usez, volume_preservation))
+                                  "smooth_laplacian_vert verts=%hv lambda=%f lambda_border=%f use_x=%b use_y=%b use_z=%b preserve_volume=%b",
+                                  BM_ELEM_SELECT, lambda, lambda_border, usex, usey, usez, preserve_volume))
                {
                        return OPERATOR_CANCELLED;
                }
@@ -1745,7 +1745,7 @@ void MESH_OT_vertices_smooth_laplacian(wmOperatorType *ot)
        RNA_def_boolean(ot->srna, "use_x", 1, "Smooth X Axis", "Smooth object along     X axis");
        RNA_def_boolean(ot->srna, "use_y", 1, "Smooth Y Axis", "Smooth object along     Y axis");
        RNA_def_boolean(ot->srna, "use_z", 1, "Smooth Z Axis", "Smooth object along     Z axis");
-       RNA_def_boolean(ot->srna, "volume_preservation", 1, "Preserve Volume", "Apply volume preservation after smooth");
+       RNA_def_boolean(ot->srna, "preserve_volume", 1, "Preserve Volume", "Apply volume preservation after smooth");
 }
 
 /********************** Smooth/Solid Operators *************************/
@@ -1828,10 +1828,10 @@ static int edbm_rotate_uvs_exec(bContext *C, wmOperator *op)
        BMOperator bmop;
 
        /* get the direction from RNA */
-       int dir = RNA_enum_get(op->ptr, "direction");
+       const int use_ccw = RNA_boolean_get(op->ptr, "use_ccw");
 
        /* initialize the bmop using EDBM api, which does various ui error reporting and other stuff */
-       EDBM_op_init(em, &bmop, op, "rotate_uvs faces=%hf dir=%i", BM_ELEM_SELECT, dir);
+       EDBM_op_init(em, &bmop, op, "rotate_uvs faces=%hf use_ccw=%b", BM_ELEM_SELECT, use_ccw);
 
        /* execute the operator */
        BMO_op_exec(em->bm, &bmop);
@@ -1877,10 +1877,10 @@ static int edbm_rotate_colors_exec(bContext *C, wmOperator *op)
        BMOperator bmop;
 
        /* get the direction from RNA */
-       int dir = RNA_enum_get(op->ptr, "direction");
+       const int use_ccw = RNA_boolean_get(op->ptr, "use_ccw");
 
        /* initialize the bmop using EDBM api, which does various ui error reporting and other stuff */
-       EDBM_op_init(em, &bmop, op, "rotate_colors faces=%hf dir=%i", BM_ELEM_SELECT, dir);
+       EDBM_op_init(em, &bmop, op, "rotate_colors faces=%hf use_ccw=%b", BM_ELEM_SELECT, use_ccw);
 
        /* execute the operator */
        BMO_op_exec(em->bm, &bmop);
@@ -1936,7 +1936,7 @@ void MESH_OT_uvs_rotate(wmOperatorType *ot)
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 
        /* props */
-       RNA_def_enum(ot->srna, "direction", direction_items, DIRECTION_CW, "Direction", "Direction to rotate UVs around");
+       RNA_def_boolean(ot->srna, "use_ccw", FALSE, "Counter Clockwise", "");
 }
 
 //void MESH_OT_uvs_mirror(wmOperatorType *ot)
@@ -1973,7 +1973,7 @@ void MESH_OT_colors_rotate(wmOperatorType *ot)
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 
        /* props */
-       RNA_def_enum(ot->srna, "direction", direction_items, DIRECTION_CCW, "Direction", "Direction to rotate edge around");
+       RNA_def_boolean(ot->srna, "use_ccw", FALSE, "Counter Clockwise", "");
 }
 
 void MESH_OT_colors_reverse(wmOperatorType *ot)
@@ -2204,7 +2204,7 @@ static int edbm_remove_doubles_exec(bContext *C, wmOperator *op)
                             BM_ELEM_SELECT, threshold);
                BMO_op_exec(em->bm, &bmop);
 
-               if (!EDBM_op_callf(em, op, "weld_verts targetmap=%S", &bmop, "targetmapout")) {
+               if (!EDBM_op_callf(em, op, "weld_verts targetmap=%S", &bmop, "targetmap.out")) {
                        BMO_op_finish(em->bm, &bmop);
                        return OPERATOR_CANCELLED;
                }
@@ -2313,7 +2313,7 @@ static int edbm_select_vertex_path_exec(bContext *C, wmOperator *op)
        /* EDBM_flag_disable_all(em, BM_ELEM_SELECT); */
 
        /* select the output */
-       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "vertout", BM_ALL, BM_ELEM_SELECT, TRUE);
+       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "verts.out", BM_ALL, BM_ELEM_SELECT, TRUE);
 
        /* finish the operator */
        if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
@@ -2636,7 +2636,7 @@ static int edbm_solidify_exec(bContext *C, wmOperator *op)
        BMO_op_exec(bm, &bmop);
 
        /* select the newly generated faces */
-       BMO_slot_buffer_hflag_enable(bm, bmop.slots_out, "geomout", BM_FACE, BM_ELEM_SELECT, TRUE);
+       BMO_slot_buffer_hflag_enable(bm, bmop.slots_out, "geom.out", BM_FACE, BM_ELEM_SELECT, TRUE);
 
        if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
                return OPERATOR_CANCELLED;
@@ -2954,9 +2954,9 @@ static int edbm_knife_cut_exec(bContext *C, wmOperator *op)
        BMO_slot_buffer_from_enabled_flag(bm, &bmop, bmop.slots_in, "edges", BM_EDGE, ELE_EDGE_CUT);
 
        if (mode == KNIFE_MIDPOINT) numcuts = 1;
-       BMO_slot_int_set(bmop.slots_in, "numcuts", numcuts);
+       BMO_slot_int_set(bmop.slots_in, "cuts", numcuts);
 
-       BMO_slot_int_set(bmop.slots_in, "quadcornertype", SUBD_STRAIGHT_CUT);
+       BMO_slot_int_set(bmop.slots_in, "quad_corner_type", SUBD_STRAIGHT_CUT);
        BMO_slot_bool_set(bmop.slots_in, "use_singleedge", FALSE);
        BMO_slot_bool_set(bmop.slots_in, "use_gridfill", FALSE);
 
@@ -3303,7 +3303,7 @@ static int edbm_fill_exec(bContext *C, wmOperator *op)
        BMO_op_exec(em->bm, &bmop);
        
        /* select new geometry */
-       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "geomout", BM_FACE | BM_EDGE, BM_ELEM_SELECT, TRUE);
+       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "geom.out", BM_FACE | BM_EDGE, BM_ELEM_SELECT, TRUE);
        
        if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
                return OPERATOR_CANCELLED;
@@ -3575,7 +3575,7 @@ static int edbm_split_exec(bContext *C, wmOperator *op)
        EDBM_op_init(em, &bmop, op, "split geom=%hvef use_only_faces=%b", BM_ELEM_SELECT, FALSE);
        BMO_op_exec(em->bm, &bmop);
        BM_mesh_elem_hflag_disable_all(em->bm, BM_VERT | BM_EDGE | BM_FACE, BM_ELEM_SELECT, FALSE);
-       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "geomout", BM_ALL, BM_ELEM_SELECT, TRUE);
+       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "geom.out", BM_ALL, BM_ELEM_SELECT, TRUE);
        if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
                return OPERATOR_CANCELLED;
        }
@@ -3630,14 +3630,14 @@ static int edbm_spin_exec(bContext *C, wmOperator *op)
        mul_m3_v3(imat, axis);
 
        if (!EDBM_op_init(em, &spinop, op,
-                         "spin geom=%hvef cent=%v axis=%v dvec=%v steps=%i ang=%f do_dupli=%b",
+                         "spin geom=%hvef cent=%v axis=%v dvec=%v steps=%i angle=%f use_duplicate=%b",
                          BM_ELEM_SELECT, cent, axis, d, steps, degr, 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, "lastout", BM_ALL, BM_ELEM_SELECT, TRUE);
+       BMO_slot_buffer_hflag_enable(bm, spinop.slots_out, "geom_last.out", BM_ALL, BM_ELEM_SELECT, TRUE);
        if (!EDBM_op_finish(em, &spinop, op, TRUE)) {
                return OPERATOR_CANCELLED;
        }
@@ -3754,14 +3754,14 @@ static int edbm_screw_exec(bContext *C, wmOperator *op)
                negate_v3(dvec);
 
        if (!EDBM_op_init(em, &spinop, op,
-                         "spin geom=%hvef cent=%v axis=%v dvec=%v steps=%i ang=%f do_dupli=%b",
+                         "spin geom=%hvef cent=%v axis=%v dvec=%v steps=%i angle=%f use_duplicate=%b",
                          BM_ELEM_SELECT, cent, axis, dvec, turns * steps, 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, "lastout", BM_ALL, BM_ELEM_SELECT, TRUE);
+       BMO_slot_buffer_hflag_enable(bm, spinop.slots_out, "geom_last.out", BM_ALL, BM_ELEM_SELECT, TRUE);
        if (!EDBM_op_finish(em, &spinop, op, TRUE)) {
                return OPERATOR_CANCELLED;
        }
@@ -4771,7 +4771,7 @@ static int edbm_bevel_calc(bContext *C, wmOperator *op)
                /* 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, "faceout", BM_FACE, BM_ELEM_SELECT, TRUE);
+               BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faces.out", BM_FACE, BM_ELEM_SELECT, TRUE);
        }
 
 #else
@@ -5105,7 +5105,7 @@ static int edbm_bridge_edge_loops_exec(bContext *C, wmOperator *op)
        /* when merge is used the edges are joined and remain selected */
        if (use_merge == FALSE) {
                EDBM_flag_disable_all(em, BM_ELEM_SELECT);
-               BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faceout", BM_FACE, BM_ELEM_SELECT, TRUE);
+               BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faces.out", BM_FACE, BM_ELEM_SELECT, TRUE);
        }
 
        if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
@@ -5278,11 +5278,11 @@ static int edbm_inset_calc(bContext *C, wmOperator *op)
        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, "faceout", BM_FACE, BM_ELEM_SELECT, TRUE);
+               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, "faceout", BM_FACE, 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);
        }
@@ -5547,7 +5547,7 @@ static int edbm_wireframe_exec(bContext *C, wmOperator *op)
        }
 
        BM_mesh_elem_hflag_disable_all(em->bm, BM_VERT | BM_EDGE | BM_FACE, BM_ELEM_SELECT, FALSE);
-       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faceout", BM_FACE, BM_ELEM_SELECT, TRUE);
+       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faces.out", BM_FACE, BM_ELEM_SELECT, TRUE);
 
        if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
                return OPERATOR_CANCELLED;
@@ -5611,7 +5611,7 @@ static int edbm_convex_hull_exec(bContext *C, wmOperator *op)
        /* Delete unused vertices, edges, and faces */
        if (RNA_boolean_get(op->ptr, "delete_unused")) {
                if (!EDBM_op_callf(em, op, "delete geom=%S context=%i",
-                                  &bmop, "unused_geom_out", DEL_ONLYTAGGED))
+                                  &bmop, "geom_unused.out", DEL_ONLYTAGGED))
                {
                        EDBM_op_finish(em, &bmop, op, TRUE);
                        return OPERATOR_CANCELLED;
@@ -5621,7 +5621,7 @@ static int edbm_convex_hull_exec(bContext *C, wmOperator *op)
        /* Delete hole edges/faces */
        if (RNA_boolean_get(op->ptr, "make_holes")) {
                if (!EDBM_op_callf(em, op, "delete geom=%S context=%i",
-                                  &bmop, "holes_geom_out", DEL_ONLYTAGGED))
+                                  &bmop, "geom_holes.out", DEL_ONLYTAGGED))
                {
                        EDBM_op_finish(em, &bmop, op, TRUE);
                        return OPERATOR_CANCELLED;
@@ -5631,7 +5631,7 @@ static int edbm_convex_hull_exec(bContext *C, wmOperator *op)
        /* Merge adjacent triangles */
        if (RNA_boolean_get(op->ptr, "join_triangles")) {
                if (!EDBM_op_callf(em, op, "join_triangles faces=%S limit=%f",
-                                  &bmop, "geomout",
+                                  &bmop, "geom.out",
                                   RNA_float_get(op->ptr, "limit")))
                {
                        EDBM_op_finish(em, &bmop, op, TRUE);
index e5f645ada213a2bab8e283b0d5046a7aa118a2d8..22c71d5d3ca418ddb7636fc96f5937b59b223e8c 100644 (file)
@@ -494,11 +494,11 @@ void EDBM_select_more(BMEditMesh *em)
        int use_faces = em->selectmode == SCE_SELECT_FACE;
 
        BMO_op_initf(em->bm, &bmop, BMO_FLAG_DEFAULTS,
-                    "region_extend geom=%hvef constrict=%b use_faces=%b",
+                    "region_extend geom=%hvef use_constrict=%b use_faces=%b",
                     BM_ELEM_SELECT, FALSE, use_faces);
        BMO_op_exec(em->bm, &bmop);
        /* don't flush selection in edge/vertex mode  */
-       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "geomout", BM_ALL, BM_ELEM_SELECT, use_faces ? TRUE : FALSE);
+       BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "geom.out", BM_ALL, BM_ELEM_SELECT, use_faces ? TRUE : FALSE);
        BMO_op_finish(em->bm, &bmop);
 
        EDBM_select_flush(em);
@@ -510,11 +510,11 @@ void EDBM_select_less(BMEditMesh *em)
        int use_faces = em->selectmode == SCE_SELECT_FACE;
 
        BMO_op_initf(em->bm, &bmop, BMO_FLAG_DEFAULTS,
-                    "region_extend geom=%hvef constrict=%b use_faces=%b",
+                    "region_extend geom=%hvef use_constrict=%b use_faces=%b",
                     BM_ELEM_SELECT, TRUE, use_faces);
        BMO_op_exec(em->bm, &bmop);
        /* don't flush selection in edge/vertex mode  */
-       BMO_slot_buffer_hflag_disable(em->bm, bmop.slots_out, "geomout", BM_ALL, BM_ELEM_SELECT, use_faces ? TRUE : FALSE);
+       BMO_slot_buffer_hflag_disable(em->bm, bmop.slots_out, "geom.out", BM_ALL, BM_ELEM_SELECT, use_faces ? TRUE : FALSE);
        BMO_op_finish(em->bm, &bmop);
 
        EDBM_selectmode_flush(em);
index 7078ee0d51c0c991862b2d0afe513d068801e821..3875a0d5799b79135705aee3b5216e04fd491b63 100644 (file)
@@ -1131,7 +1131,7 @@ enum {
 #define MOD_LAPLACIANSMOOTH_X (1<<1)
 #define MOD_LAPLACIANSMOOTH_Y (1<<2)
 #define MOD_LAPLACIANSMOOTH_Z (1<<3)
-#define MOD_LAPLACIANSMOOTH_VOLUME_PRESERVATION (1<<4)
+#define MOD_LAPLACIANSMOOTH_PRESERVE_VOLUME (1 << 4)
 
 typedef struct LaplacianSmoothModifierData {
        ModifierData modifier;
index a9a1d81077bded3239a7bd860ace82b77b23228c..06df6c5afbcb3fe7c767e416af1743d80cf583bf 100644 (file)
@@ -1817,7 +1817,7 @@ static void rna_def_modifier_laplaciansmooth(BlenderRNA *brna)
        RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
        prop = RNA_def_property(srna, "use_volume_preserve", PROP_BOOLEAN, PROP_NONE);
-       RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_LAPLACIANSMOOTH_VOLUME_PRESERVATION);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_LAPLACIANSMOOTH_PRESERVE_VOLUME);
        RNA_def_property_ui_text(prop, "Preserve Volume", "Apply volume preservation after smooth");
        RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
index d9526199d1641f942fdfca9c19155645bd078e4b..4921c5e358588e79c4e805f311f18630b2f8af88 100644 (file)
@@ -185,7 +185,7 @@ static int *find_doubles_index_map(BMesh *bm, BMOperator *dupe_op,
                i++;
        }
 
-       BMO_ITER (ele, &oiter, dupe_op->slots_out, "newout", BM_ALL) {
+       BMO_ITER (ele, &oiter, dupe_op->slots_out, "geom.out", BM_ALL) {
                BM_elem_index_set(ele, i); /* set_dirty */
                i++;
        }
@@ -197,7 +197,7 @@ static int *find_doubles_index_map(BMesh *bm, BMOperator *dupe_op,
        index_map = MEM_callocN(sizeof(int) * (*index_map_length), "index_map");
 
        /*element type argument doesn't do anything here*/
-       BMO_ITER (v, &oiter, find_op.slots_out, "targetmapout", 0) {
+       BMO_ITER (v, &oiter, find_op.slots_out, "targetmap.out", 0) {
                v2 = BMO_iter_map_value_p(&oiter);
 
                index_map[BM_elem_index_get(v)] = BM_elem_index_get(v2) + 1;
@@ -267,7 +267,7 @@ static void bm_merge_dm_transform(BMesh *bm, DerivedMesh *dm, float mat[4][4],
                BMO_op_exec(bm, &find_op);
 
                /* add new merge targets to weld operator */
-               BMO_ITER (v, &oiter, find_op.slots_out, "targetmapout", 0) {
+               BMO_ITER (v, &oiter, find_op.slots_out, "targetmap.out", 0) {
                        v2 = BMO_iter_map_value_p(&oiter);
                        /* check in case the target vertex (v2) is already marked
                         * for merging */
@@ -307,12 +307,12 @@ static void merge_first_last(BMesh *bm,
 
        /* append the last dupe's geom to the findop input verts */
        BMO_slot_buffer_append(&find_op,  slots_in,  "verts",
-                              dupe_last, slots_out, "newout");
+                              dupe_last, slots_out, "geom.out");
 
        BMO_op_exec(bm, &find_op);
 
        /* add new merge targets to weld operator */
-       BMO_ITER (v, &oiter, find_op.slots_out, "targetmapout", 0) {
+       BMO_ITER (v, &oiter, find_op.slots_out, "targetmap.out", 0) {
                v2 = BMO_iter_map_value_p(&oiter);
                BMO_slot_map_ptr_insert(weld_op, weld_op->slots_in, "targetmap", v, v2);
        }
@@ -437,18 +437,18 @@ static DerivedMesh *arrayModifier_doArray(ArrayModifierData *amd,
        for (j = 0; j < count - 1; j++) {
                BMVert *v, *v2, *v3;
                BMOpSlot *geom_slot;
-               BMOpSlot *newout_slot;
+               BMOpSlot *geom_out_slot;
                BMOIter oiter;
 
                if (j != 0) {
                        BMO_op_initf(bm, &dupe_op,
                                     (BMO_FLAG_DEFAULTS & ~BMO_FLAG_RESPECT_HIDE),
-                                    "duplicate geom=%S", &old_dupe_op, "newout");
+                                    "duplicate geom=%S", &old_dupe_op, "geom.out");
                }
                BMO_op_exec(bm, &dupe_op);
 
                geom_slot   = BMO_slot_get(dupe_op.slots_in,  "geom");
-               newout_slot = BMO_slot_get(dupe_op.slots_out, "newout");
+               geom_out_slot = BMO_slot_get(dupe_op.slots_out, "geom.out");
 
                if ((amd->flags & MOD_ARR_MERGEFINAL) && j == 0) {
                        int first_geom_bytes = sizeof(BMVert *) * geom_slot->len;
@@ -460,7 +460,7 @@ static DerivedMesh *arrayModifier_doArray(ArrayModifierData *amd,
                }
 
                /* apply transformation matrix */
-               BMO_ITER (v, &oiter, dupe_op.slots_out, "newout", BM_VERT) {
+               BMO_ITER (v, &oiter, dupe_op.slots_out, "geom.out", BM_VERT) {
                        mul_m4_v3(offset, v->co);
                }
 
@@ -479,8 +479,8 @@ static DerivedMesh *arrayModifier_doArray(ArrayModifierData *amd,
                        for (i = 0; i < index_len; i++) {
                                if (!indexMap[i]) continue;
 
-                               /* merge v (from 'newout') into v2 (from old 'geom') */
-                               v = _E(newout_slot, i - geom_slot->len);
+                               /* merge v (from 'geom.out') into v2 (from old 'geom') */
+                               v = _E(geom_out_slot, i - geom_slot->len);
                                v2 = _E(geom_slot, indexMap[i] - 1);
 
                                /* check in case the target vertex (v2) is already marked
@@ -533,7 +533,7 @@ static DerivedMesh *arrayModifier_doArray(ArrayModifierData *amd,
                        mult_m4_m4m4(endoffset, offset, final_offset);
                        bm_merge_dm_transform(bm, end_cap, endoffset, amd,
                                              &dupe_op, (count == 1) ? dupe_op.slots_in : dupe_op.slots_out,
-                                             (count == 1) ? "geom" : "newout", &weld_op);
+                                             (count == 1) ? "geom" : "geom.out", &weld_op);
                }
        }
        /* done capping */
index 6f6589d4d14c31ee743aae56d90fbc36576a26ad..266226040a3046b4da61c5524e66146418388443 100644 (file)
@@ -199,7 +199,7 @@ static void init_data(ModifierData *md)
        smd->lambda = 0.00001f;
        smd->lambda_border = 0.00005f;
        smd->repeat = 1;
-       smd->flag = MOD_LAPLACIANSMOOTH_X | MOD_LAPLACIANSMOOTH_Y | MOD_LAPLACIANSMOOTH_Z | MOD_LAPLACIANSMOOTH_VOLUME_PRESERVATION;
+       smd->flag = MOD_LAPLACIANSMOOTH_X | MOD_LAPLACIANSMOOTH_Y | MOD_LAPLACIANSMOOTH_Z | MOD_LAPLACIANSMOOTH_PRESERVE_VOLUME;
        smd->defgrp_name[0] = '\0';
 }
 
@@ -511,7 +511,7 @@ static void validate_solution(LaplacianSystem *sys, short flag)
        float leni, lene;
        float vini, vend;
        float *vi1, *vi2, ve1[3], ve2[3];
-       if (flag & MOD_LAPLACIANSMOOTH_VOLUME_PRESERVATION) {
+       if (flag & MOD_LAPLACIANSMOOTH_PRESERVE_VOLUME) {
                vini = compute_volume(sys->vertexCos, sys->mfaces, sys->numFaces);
        }
        for (i = 0; i < sys->numEdges; i++) {
@@ -545,7 +545,7 @@ static void validate_solution(LaplacianSystem *sys, short flag)
                        }
                }
        }
-       if (flag & MOD_LAPLACIANSMOOTH_VOLUME_PRESERVATION) {
+       if (flag & MOD_LAPLACIANSMOOTH_PRESERVE_VOLUME) {
                vend = compute_volume(sys->vertexCos, sys->mfaces, sys->numFaces);
                volume_preservation(sys, vini, vend, flag);
        }
index cc2405ed186e37998b3b24e528394c804dd76a09..5e6c178762a685c5fc43ffd3abe2a4aedbe7dee0 100644 (file)
@@ -249,14 +249,14 @@ static int build_hull(SkinOutput *so, Frame **frames, int totframe)
        }
 
        /* Apply face attributes to hull output */
-       BMO_ITER (f, &oiter, op.slots_out, "geomout", BM_FACE) {
+       BMO_ITER (f, &oiter, op.slots_out, "geom.out", BM_FACE) {
                if (so->smd->flag & MOD_SKIN_SMOOTH_SHADING)
                        BM_elem_flag_enable(f, BM_ELEM_SMOOTH);
                f->mat_nr = so->mat_nr;
        }
 
        /* Mark interior frames */
-       BMO_ITER (v, &oiter, op.slots_out, "interior_geom_out", BM_VERT) {
+       BMO_ITER (v, &oiter, op.slots_out, "geom_interior.out", BM_VERT) {
                for (i = 0; i < totframe; i++) {
                        Frame *frame = frames[i];
                        
@@ -309,7 +309,7 @@ static int build_hull(SkinOutput *so, Frame **frames, int totframe)
 
        /* Check if removing triangles above will create wire triangles,
         * mark them too */
-       BMO_ITER (e, &oiter, op.slots_out, "geomout", BM_EDGE) {
+       BMO_ITER (e, &oiter, op.slots_out, "geom.out", BM_EDGE) {
                int is_wire = TRUE;
                BM_ITER_ELEM (f, &iter, e, BM_FACES_OF_EDGE) {
                        if (!BM_elem_flag_test(f, BM_ELEM_TAG)) {
@@ -1229,7 +1229,7 @@ static void skin_fix_hole_no_good_verts(BMesh *bm, Frame *frame, BMFace *split_f
        /* Update split face (should only be one new face created
         * during extrusion) */
        split_face = NULL;
-       BMO_ITER (f, &oiter, op.slots_out, "faceout", BM_FACE) {
+       BMO_ITER (f, &oiter, op.slots_out, "faces.out", BM_FACE) {
                BLI_assert(!split_face);
                split_face = f;
        }
@@ -1247,7 +1247,7 @@ static void skin_fix_hole_no_good_verts(BMesh *bm, Frame *frame, BMFace *split_f
                BM_elem_flag_enable(longest_edge, BM_ELEM_TAG);
 
                BMO_op_callf(bm, BMO_FLAG_DEFAULTS,
-                            "subdivide_edges edges=%he numcuts=%i quadcornertype=%i",
+                            "subdivide_edges edges=%he cuts=%i quad_corner_type=%i",
                             BM_ELEM_TAG, 1, SUBD_STRAIGHT_CUT);
        }
        else if (split_face->len > 4) {