bmesh operator naming - use clearer names for args eg: (mat -> matrix, use_singleedge...
authorCampbell Barton <ideasman42@gmail.com>
Wed, 28 Nov 2012 00:16:06 +0000 (00:16 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Wed, 28 Nov 2012 00:16:06 +0000 (00:16 +0000)
also remove duplicate docs for operator arg formatting.

17 files changed:
source/blender/bmesh/intern/bmesh_opdefines.c
source/blender/bmesh/intern/bmesh_operator_api.h
source/blender/bmesh/intern/bmesh_operators.c
source/blender/bmesh/intern/bmesh_operators.h
source/blender/bmesh/operators/bmo_dupe.c
source/blender/bmesh/operators/bmo_extrude.c
source/blender/bmesh/operators/bmo_hull.c
source/blender/bmesh/operators/bmo_mirror.c
source/blender/bmesh/operators/bmo_primitive.c
source/blender/bmesh/operators/bmo_subdivide.c
source/blender/bmesh/operators/bmo_subdivide.h
source/blender/bmesh/operators/bmo_symmetrize.c
source/blender/bmesh/operators/bmo_triangulate.c
source/blender/bmesh/operators/bmo_utils.c
source/blender/editors/mesh/editmesh_add.c
source/blender/editors/mesh/editmesh_loopcut.c
source/blender/editors/mesh/editmesh_tools.c

index 8e2a2b22508358fba1b25b189e7c6e9d815eadfb..502dafeb5c3f1f221b710e37a66ee19627c40fc8 100644 (file)
@@ -254,11 +254,11 @@ static BMOpDefine bmo_mirror_def = {
        "mirror",
        /* slots_in */
        {{"geom", BMO_OP_SLOT_ELEMENT_BUF, {BM_VERT | BM_EDGE | BM_FACE}},     /* input geometry */
-        {"mat",         BMO_OP_SLOT_MAT},      /* matrix defining the mirror transformation */
-        {"merge_dist", BMO_OP_SLOT_FLT},       /* maximum distance for merging.  does no merging if 0. */
-        {"axis",         BMO_OP_SLOT_INT},     /* the axis to use, 0, 1, or 2 for x, y, z */
-        {"mirror_u",        BMO_OP_SLOT_BOOL}, /* mirror UVs across the u axis */
-        {"mirror_v",        BMO_OP_SLOT_BOOL}, /* mirror UVs across the v axis */
+        {"matrix",          BMO_OP_SLOT_MAT},   /* matrix defining the mirror transformation */
+        {"merge_dist",      BMO_OP_SLOT_FLT},   /* maximum distance for merging.  does no merging if 0. */
+        {"axis",            BMO_OP_SLOT_INT},   /* the axis to use, 0, 1, or 2 for x, y, z */
+        {"mirror_u",        BMO_OP_SLOT_BOOL},  /* mirror UVs across the u axis */
+        {"mirror_v",        BMO_OP_SLOT_BOOL},  /* mirror UVs across the v axis */
         {{'\0'}},
        },
        /* slots_out */
@@ -587,9 +587,9 @@ static BMOpDefine bmo_edgenet_prepare_def = {
 static BMOpDefine bmo_rotate_def = {
        "rotate",
        /* slots_in */
-       {{"cent", BMO_OP_SLOT_VEC},  /* center of rotation */
-        {"mat", BMO_OP_SLOT_MAT},   /* matrix defining rotation */
-        {"verts", BMO_OP_SLOT_ELEMENT_BUF, {BM_VERT}},  /* input vertices */
+       {{"cent",            BMO_OP_SLOT_VEC},  /* center of rotation */
+        {"matrix",          BMO_OP_SLOT_MAT},  /* matrix defining rotation */
+        {"verts",           BMO_OP_SLOT_ELEMENT_BUF, {BM_VERT}},  /* input vertices */
         {{'\0'}},
        },
        {{{'\0'}}},  /* no output */
@@ -642,8 +642,8 @@ static BMOpDefine bmo_scale_def = {
 static BMOpDefine bmo_transform_def = {
        "transform",
        /* slots_in */
-       {{"mat", BMO_OP_SLOT_MAT},  /* transform matrix */
-        {"verts", BMO_OP_SLOT_ELEMENT_BUF, {BM_VERT}},  /* input vertices */
+       {{"matrix",          BMO_OP_SLOT_MAT},  /* transform matrix */
+        {"verts",           BMO_OP_SLOT_ELEMENT_BUF, {BM_VERT}},  /* input vertices */
         {{'\0'}},
        },
        {{{'\0'}}},  /* no output */
@@ -911,7 +911,7 @@ static BMOpDefine bmo_triangulate_def = {
        /* slots_out */
        {{"edges.out", BMO_OP_SLOT_ELEMENT_BUF, {BM_EDGE}},
         {"faces.out", BMO_OP_SLOT_ELEMENT_BUF, {BM_FACE}},
-        {"facemap.out", BMO_OP_SLOT_MAPPING, {BMO_OP_SLOT_SUBTYPE_MAP_ELEM}},
+        {"face_map.out", BMO_OP_SLOT_MAPPING, {BMO_OP_SLOT_SUBTYPE_MAP_ELEM}},
         {{'\0'}},
        },
        bmo_triangulate_exec,
@@ -950,13 +950,13 @@ static BMOpDefine bmo_subdivide_edges_def = {
         {"along_normal", BMO_OP_SLOT_FLT},
         {"cuts", BMO_OP_SLOT_INT},
         {"seed", BMO_OP_SLOT_INT},
-        {"custompatterns", BMO_OP_SLOT_MAPPING, {BMO_OP_SLOT_SUBTYPE_MAP_INTERNAL}},  /* uses custom pointers */
-        {"edgepercents", BMO_OP_SLOT_MAPPING, {BMO_OP_SLOT_SUBTYPE_MAP_FLOAT}},
+        {"custom_patterns", BMO_OP_SLOT_MAPPING, {BMO_OP_SLOT_SUBTYPE_MAP_INTERNAL}},  /* uses custom pointers */
+        {"edge_percents", BMO_OP_SLOT_MAPPING, {BMO_OP_SLOT_SUBTYPE_MAP_FLOAT}},
 
         {"quad_corner_type",  BMO_OP_SLOT_INT}, /* quad corner type, see bmesh_operators.h */
-        {"use_gridfill", BMO_OP_SLOT_BOOL},   /* fill in fully-selected faces with a grid */
-        {"use_singleedge", BMO_OP_SLOT_BOOL}, /* tessellate the case of one edge selected in a quad or triangle */
-        {"use_onlyquads", BMO_OP_SLOT_BOOL},  /* only subdivide quads (for loopcut) */
+        {"use_grid_fill", BMO_OP_SLOT_BOOL},   /* fill in fully-selected faces with a grid */
+        {"use_single_edge", BMO_OP_SLOT_BOOL}, /* tessellate the case of one edge selected in a quad or triangle */
+        {"use_only_quads", BMO_OP_SLOT_BOOL},  /* only subdivide quads (for loopcut) */
         {"use_sphere", BMO_OP_SLOT_BOOL},     /* for making new primitives only */
         {{'\0'}},
        },
@@ -980,7 +980,7 @@ static BMOpDefine bmo_delete_def = {
        "delete",
        /* slots_in */
        {{"geom", BMO_OP_SLOT_ELEMENT_BUF, {BM_VERT | BM_EDGE | BM_FACE}},
-        {"context", BMO_OP_SLOT_INT},
+        {"context", BMO_OP_SLOT_INT},  /* enum DEL_VERTS ... */
         {{'\0'}},
        },
        {{{'\0'}}},  /* no output */
@@ -1007,9 +1007,9 @@ static BMOpDefine bmo_duplicate_def = {
         {"geom.out", BMO_OP_SLOT_ELEMENT_BUF, {BM_VERT | BM_EDGE | BM_FACE}},
        /* facemap maps from source faces to dupe
         * faces, and from dupe faces to source faces */
-        {"facemap.out", BMO_OP_SLOT_MAPPING, {BMO_OP_SLOT_SUBTYPE_MAP_ELEM}},
-        {"boundarymap.out", BMO_OP_SLOT_MAPPING, {BMO_OP_SLOT_SUBTYPE_MAP_ELEM}},
-        {"isovertmap.out", BMO_OP_SLOT_MAPPING, {BMO_OP_SLOT_SUBTYPE_MAP_ELEM}},
+        {"face_map.out", BMO_OP_SLOT_MAPPING, {BMO_OP_SLOT_SUBTYPE_MAP_ELEM}},
+        {"boundary_map.out", BMO_OP_SLOT_MAPPING, {BMO_OP_SLOT_SUBTYPE_MAP_ELEM}},
+        {"isovert_map.out", BMO_OP_SLOT_MAPPING, {BMO_OP_SLOT_SUBTYPE_MAP_ELEM}},
        {{'\0'}},
        },
        bmo_duplicate_exec,
@@ -1033,8 +1033,8 @@ static BMOpDefine bmo_split_def = {
        },
        /* slots_out */
        {{"geom.out", BMO_OP_SLOT_ELEMENT_BUF, {BM_VERT | BM_EDGE | BM_FACE}},
-        {"boundarymap.out", BMO_OP_SLOT_MAPPING, {BMO_OP_SLOT_SUBTYPE_MAP_ELEM}},
-        {"isovertmap.out", BMO_OP_SLOT_MAPPING, {BMO_OP_SLOT_SUBTYPE_MAP_ELEM}},
+        {"boundary_map.out", BMO_OP_SLOT_MAPPING, {BMO_OP_SLOT_SUBTYPE_MAP_ELEM}},
+        {"isovert_map.out", BMO_OP_SLOT_MAPPING, {BMO_OP_SLOT_SUBTYPE_MAP_ELEM}},
         {{'\0'}},
        },
        bmo_split_exec,
@@ -1252,10 +1252,10 @@ static BMOpDefine bmo_split_edges_def = {
 static BMOpDefine bmo_create_grid_def = {
        "create_grid",
        /* slots_in */
-       {{"x_segments",         BMO_OP_SLOT_INT}, /* number of x segments */
-        {"y_segments",         BMO_OP_SLOT_INT}, /* number of y segments */
-        {"size",         BMO_OP_SLOT_FLT},     /* size of the grid */
-        {"mat",         BMO_OP_SLOT_MAT},      /* matrix to multiply the new geometry with */
+       {{"x_segments",      BMO_OP_SLOT_INT},  /* number of x segments */
+        {"y_segments",      BMO_OP_SLOT_INT},  /* number of y segments */
+        {"size",            BMO_OP_SLOT_FLT},  /* size of the grid */
+        {"matrix",          BMO_OP_SLOT_MAT},  /* matrix to multiply the new geometry with */
         {{'\0'}},
        },
        /* slots_out */
@@ -1274,10 +1274,10 @@ static BMOpDefine bmo_create_grid_def = {
 static BMOpDefine bmo_create_uvsphere_def = {
        "create_uvsphere",
        /* slots_in */
-       {{"u_segments",         BMO_OP_SLOT_INT}, /* number of u segments */
-        {"v_segments",         BMO_OP_SLOT_INT}, /* number of v segment */
-        {"diameter",         BMO_OP_SLOT_FLT}, /* diameter */
-        {"mat",         BMO_OP_SLOT_MAT}, /* matrix to multiply the new geometry with */
+       {{"u_segments",      BMO_OP_SLOT_INT}, /* number of u segments */
+        {"v_segments",      BMO_OP_SLOT_INT}, /* number of v segment */
+        {"diameter",        BMO_OP_SLOT_FLT}, /* diameter */
+        {"matrix",          BMO_OP_SLOT_MAT}, /* matrix to multiply the new geometry with */
         {{'\0'}},
        },
        /* slots_out */
@@ -1296,9 +1296,9 @@ static BMOpDefine bmo_create_uvsphere_def = {
 static BMOpDefine bmo_create_icosphere_def = {
        "create_icosphere",
        /* slots_in */
-       {{"subdivisions",         BMO_OP_SLOT_INT}, /* how many times to recursively subdivide the sphere */
-        {"diameter",         BMO_OP_SLOT_FLT}, /* diameter */
-        {"mat",         BMO_OP_SLOT_MAT}, /* matrix to multiply the new geometry with */
+       {{"subdivisions",    BMO_OP_SLOT_INT}, /* how many times to recursively subdivide the sphere */
+        {"diameter",        BMO_OP_SLOT_FLT}, /* diameter */
+        {"matrix",          BMO_OP_SLOT_MAT}, /* matrix to multiply the new geometry with */
         {{'\0'}},
        },
        /* slots_out */
@@ -1317,7 +1317,7 @@ static BMOpDefine bmo_create_icosphere_def = {
 static BMOpDefine bmo_create_monkey_def = {
        "create_monkey",
        /* slots_in */
-       {{"mat", BMO_OP_SLOT_MAT}, /* matrix to multiply the new geometry with */
+       {{"matrix", BMO_OP_SLOT_MAT}, /* matrix to multiply the new geometry with */
         {{'\0'}},
        },
        /* slots_out */
@@ -1336,13 +1336,13 @@ static BMOpDefine bmo_create_monkey_def = {
 static BMOpDefine bmo_create_cone_def = {
        "create_cone",
        /* slots_in */
-       {{"cap_ends", BMO_OP_SLOT_BOOL},        /* whether or not to fill in the ends with faces */
-        {"cap_tris", BMO_OP_SLOT_BOOL},        /* fill ends with triangles instead of ngons */
-        {"segments", BMO_OP_SLOT_INT},
-        {"diameter1", BMO_OP_SLOT_FLT},        /* diameter of one end */
-        {"diameter2", BMO_OP_SLOT_FLT},        /* diameter of the opposite */
-        {"depth", BMO_OP_SLOT_FLT},            /* distance between ends */
-        {"mat", BMO_OP_SLOT_MAT},              /* matrix to multiply the new geometry with */
+       {{"cap_ends",        BMO_OP_SLOT_BOOL},  /* whether or not to fill in the ends with faces */
+        {"cap_tris",        BMO_OP_SLOT_BOOL},  /* fill ends with triangles instead of ngons */
+        {"segments",        BMO_OP_SLOT_INT},
+        {"diameter1",       BMO_OP_SLOT_FLT},  /* diameter of one end */
+        {"diameter2",       BMO_OP_SLOT_FLT},  /* diameter of the opposite */
+        {"depth",           BMO_OP_SLOT_FLT},  /* distance between ends */
+        {"matrix",          BMO_OP_SLOT_MAT},  /* matrix to multiply the new geometry with */
         {{'\0'}},
        },
        /* slots_out */
@@ -1359,11 +1359,11 @@ static BMOpDefine bmo_create_cone_def = {
 static BMOpDefine bmo_create_circle_def = {
        "create_circle",
        /* slots_in */
-       {{"cap_ends", BMO_OP_SLOT_BOOL},        /* whether or not to fill in the ends with faces */
-        {"cap_tris", BMO_OP_SLOT_BOOL},        /* fill ends with triangles instead of ngons */
-        {"segments", BMO_OP_SLOT_INT},
-        {"diameter", BMO_OP_SLOT_FLT},         /* diameter of one end */
-        {"mat", BMO_OP_SLOT_MAT},              /* matrix to multiply the new geometry with */
+       {{"cap_ends",        BMO_OP_SLOT_BOOL},  /* whether or not to fill in the ends with faces */
+        {"cap_tris",        BMO_OP_SLOT_BOOL},  /* fill ends with triangles instead of ngons */
+        {"segments",        BMO_OP_SLOT_INT},
+        {"diameter",        BMO_OP_SLOT_FLT},  /* diameter of one end */
+        {"matrix",          BMO_OP_SLOT_MAT},  /* matrix to multiply the new geometry with */
         {{'\0'}},
        },
        /* slots_out */
@@ -1382,8 +1382,8 @@ static BMOpDefine bmo_create_circle_def = {
 static BMOpDefine bmo_create_cube_def = {
        "create_cube",
        /* slots_in */
-       {{"size", BMO_OP_SLOT_FLT},             /* size of the cube */
-        {"mat", BMO_OP_SLOT_MAT},              /* matrix to multiply the new geometry with */
+       {{"size",            BMO_OP_SLOT_FLT},  /* size of the cube */
+        {"matrix",          BMO_OP_SLOT_MAT},  /* matrix to multiply the new geometry with */
         {{'\0'}},
        },
        /* slots_out */
index bebd3215d93a7b4af82bc274730f2defe3799406..df67f459a34cc8f4e34a8e8d53accb8fa92a1b16 100644 (file)
@@ -240,43 +240,6 @@ int BMO_mesh_enabled_flag_count(BMesh *bm, const char htype, const short oflag);
 int BMO_mesh_disabled_flag_count(BMesh *bm, const char htype, const short oflag);
 
 /*---------formatted operator initialization/execution-----------*/
-/*
- * this system is used to execute or initialize an operator,
- * using a formatted-string system.
- *
- * for example, BMO_op_callf(bm, BMO_FLAG_DEFAULTS, "delete geom=%hf context=%i", BM_ELEM_SELECT, DEL_FACES);
- * . . .will execute the delete operator, feeding in selected faces, deleting them.
- *
- * the basic format for the format string is:
- *   [operatorname] [slot_name]=%[code] [slot_name]=%[code]
- *
- * as in printf, you pass in one additional argument to the function
- * for every code.
- *
- * the formatting codes are:
- *    %d - put int in slot
- *    %f - put float in slot
- *    %p - put pointer in slot
- *    %h[f/e/v] - put elements with a header flag in slot.
- *                 the letters after %h define which element types to use,
- *             so e.g. %hf will do faces, %hfe will do faces and edges,
- *             %hv will do verts, etc.  must pass in at least one
- *             element type letter.
- *    %H[f/e/v] - same as %h, but tests if the flag is disabled
- *    %f[f/e/v] - same as %h, except it deals with tool flags instead of
- *                 header flags.
- *    %F[f/e/v] - same as %f, but tests if the flag is disabled
- *    %a[f/e/v] - pass all elements (of types specified by f/e/v) to the
- *                 slot.
- *    %e        - pass in a single element.
- *    %v - pointer to a float vector of length 3.
- *    %m[3/4] - matrix, 3/4 refers to the matrix size, 3 or 4.  the
- *              corresponding argument must be a pointer to
- *          a float matrix.
- *    %s - copy a slot from another op, instead of mapping to one
- *         argument, it maps to two, a pointer to an operator and
- *     a slot name.
- */
 void BMO_push(BMesh *bm, BMOperator *op);
 void BMO_pop(BMesh *bm);
 
@@ -443,15 +406,18 @@ void *BMO_slot_buffer_alloc(BMOperator *op, BMOpSlot slot_args[BMO_OP_MAX_SLOTS]
 void BMO_slot_buffer_from_all(BMesh *bm, BMOperator *op, BMOpSlot slot_args[BMO_OP_MAX_SLOTS],
                               const char *slot_name, const char htype);
 
-/* this part of the API is used to iterate over element buffer or
+/**
+ * This part of the API is used to iterate over element buffer or
  * mapping slots.
  *
  * for example, iterating over the faces in a slot is:
  *
+ * \code{.c}
+ *
  *    BMOIter oiter;
  *    BMFace *f;
  *
- *    f = BMO_iter_new(&oiter, bm, some_operator, "slot_name", BM_FACE);
+ *    f = BMO_iter_new(&oiter, some_operator, "slot_name", BM_FACE);
  *    for (; f; f = BMO_iter_step(&oiter)) {
  *        /do something with the face
  *    }
@@ -472,6 +438,7 @@ void BMO_slot_buffer_from_all(BMesh *bm, BMOperator *op, BMOpSlot slot_args[BMO_
  *        //  *((void**)BMO_iter_map_value(&oiter));
  *        //or something like that.
  *    }
+ * \endcode
  */
 
 /* contents of this structure are private,
index 18caefc13c3d93260b09f213987d15e7b2810d02..ba38f230f0b5d5ae0c286aa70445a20230bc0273 100644 (file)
@@ -1485,6 +1485,12 @@ static int bmo_opname_to_opcode(const char *opname)
 /**
  * \brief Format Strings for #BMOperator Initialization.
  *
+ * This system is used to execute or initialize an operator,
+ * using a formatted-string system.
+ *
+ * The basic format for the format string is:
+ * `[operatorname] [slot_name]=%[code] [slot_name]=%[code]`
+ *
  * Example:
  *
  * \code{.c}
index 9a89e2bc996d08ffc8e1ca7c6acadb1248c0879b..d02b0dce728d35479c827ad1df3c1eb9bf3f8e90 100644 (file)
@@ -97,8 +97,8 @@ void BM_mesh_esubdivide(BMesh *bm, const char edge_hflag,
                         float smooth, float fractal, float along_normal,
                         int numcuts,
                         int seltype, int cornertype,
-                        const short use_singleedge, const short use_gridfill,
-                        const short use_onlyquads,
+                        const short use_single_edge, const short use_grid_fill,
+                        const short use_only_quads,
                         int seed);
 
 #include "intern/bmesh_operator_api_inline.h"
index f278d3f8896912df3b9fb6c36f171da9bd27c385..76a9d571b204370996292376c0b618e9491652ab 100644 (file)
@@ -199,9 +199,9 @@ static void bmo_mesh_copy(BMOperator *op, BMesh *bm_src, BMesh *bm_dst)
        BMIter viter, eiter, fiter;
        GHash *vhash, *ehash;
 
-       BMOpSlot *slot_boundarymap_out = BMO_slot_get(op->slots_out, "boundarymap.out");
-       BMOpSlot *slot_facemap_out     = BMO_slot_get(op->slots_out, "facemap.out");
-       BMOpSlot *slot_isovertmap_out  = BMO_slot_get(op->slots_out, "isovertmap.out");
+       BMOpSlot *slot_boundary_map_out = BMO_slot_get(op->slots_out, "boundary_map.out");
+       BMOpSlot *slot_face_map_out     = BMO_slot_get(op->slots_out, "face_map.out");
+       BMOpSlot *slot_isovert_map_out  = BMO_slot_get(op->slots_out, "isovert_map.out");
 
        /* initialize pointer hashes */
        vhash = BLI_ghash_ptr_new("bmesh dupeops v");
@@ -234,7 +234,7 @@ static void bmo_mesh_copy(BMOperator *op, BMesh *bm_src, BMesh *bm_dst)
                        }
 
                        if (isolated) {
-                               BMO_slot_map_elem_insert(op, slot_isovertmap_out, v, v2);
+                               BMO_slot_map_elem_insert(op, slot_isovert_map_out, v, v2);
                        }
 
                        BMO_elem_flag_enable(bm_src, v, DUPE_DONE);
@@ -256,7 +256,7 @@ static void bmo_mesh_copy(BMOperator *op, BMesh *bm_src, BMesh *bm_dst)
                                BMO_elem_flag_enable(bm_src, e->v2, DUPE_DONE);
                        }
                        /* now copy the actual edge */
-                       copy_edge(op, slot_boundarymap_out, bm_src, e, bm_dst, vhash, ehash);
+                       copy_edge(op, slot_boundary_map_out, bm_src, e, bm_dst, vhash, ehash);
                        BMO_elem_flag_enable(bm_src, e, DUPE_DONE);
                }
        }
@@ -275,7 +275,7 @@ static void bmo_mesh_copy(BMOperator *op, BMesh *bm_src, BMesh *bm_dst)
                        /* edge pass */
                        BM_ITER_ELEM (e, &eiter, f, BM_EDGES_OF_FACE) {
                                if (!BMO_elem_flag_test(bm_src, e, DUPE_DONE)) {
-                                       copy_edge(op, slot_boundarymap_out, bm_src, e, bm_dst, vhash, ehash);
+                                       copy_edge(op, slot_boundary_map_out, bm_src, e, bm_dst, vhash, ehash);
                                        BMO_elem_flag_enable(bm_src, e, DUPE_DONE);
                                }
                        }
@@ -287,7 +287,7 @@ static void bmo_mesh_copy(BMOperator *op, BMesh *bm_src, BMesh *bm_dst)
                        BLI_array_grow_items(vtar, f->len);
                        BLI_array_grow_items(edar, f->len);
 
-                       copy_face(op, slot_facemap_out, bm_src, f, bm_dst, vtar, edar, vhash, ehash);
+                       copy_face(op, slot_face_map_out, bm_src, f, bm_dst, vtar, edar, vhash, ehash);
                        BMO_elem_flag_enable(bm_src, f, DUPE_DONE);
                }
        }
@@ -445,11 +445,11 @@ void bmo_split_exec(BMesh *bm, BMOperator *op)
        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, "boundary_map.out",
+                     splitop, slots_out, "boundary_map.out");
 
-       BMO_slot_copy(&dupeop, slots_out, "isovertmap.out",
-                     splitop, slots_out, "isovertmap.out");
+       BMO_slot_copy(&dupeop, slots_out, "isovert_map.out",
+                     splitop, slots_out, "isovert_map.out");
 
 
        /* cleanup */
@@ -506,7 +506,7 @@ void bmo_spin_exec(BMesh *bm, BMOperator *op)
                        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",
+                                    "rotate cent=%v matrix=%m3 verts=%S",
                                     cent, rmat, &dupop, "geom.out");
                        BMO_slot_copy(&dupop, slots_out, "geom.out",
                                      op,     slots_out, "geom_last.out");
@@ -517,7 +517,7 @@ void bmo_spin_exec(BMesh *bm, BMOperator *op)
                                     op, "geom_last.out");
                        BMO_op_exec(bm, &extop);
                        BMO_op_callf(bm, op->flag,
-                                    "rotate cent=%v mat=%m3 verts=%S",
+                                    "rotate cent=%v matrix=%m3 verts=%S",
                                     cent, rmat, &extop, "geom.out");
                        BMO_slot_copy(&extop, slots_out, "geom.out",
                                      op,     slots_out, "geom_last.out");
index aece270b09c06b19364bbd43f37b363d5f141f1a..1ab640ba6a5aeb7a0d6f8e4ca737753108792983 100644 (file)
@@ -198,7 +198,7 @@ void bmo_extrude_edge_only_exec(BMesh *bm, BMOperator *op)
                }
        }
 
-       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, "boundary_map.out", 0); e; e = BMO_iter_step(&siter)) {
                BMVert *f_verts[4];
                e_new = *(BMEdge **)BMO_iter_map_value(&siter);
 
@@ -352,7 +352,7 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op)
                }
        }
 
-       slot_facemap_out = BMO_slot_get(dupeop.slots_out, "facemap.out");
+       slot_facemap_out = BMO_slot_get(dupeop.slots_out, "face_map.out");
        if (bm->act_face && BMO_elem_flag_test(bm, bm->act_face, EXT_INPUT)) {
                bm->act_face = BMO_slot_map_elem_get(slot_facemap_out, bm->act_face);
        }
@@ -374,7 +374,7 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op)
                      op,      slots_out, "geom.out");
 
        slot_edges_exclude = BMO_slot_get(op->slots_in, "edges_exclude");
-       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, "boundary_map.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 */
@@ -428,7 +428,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, "isovert_map.out", 0); v; v = BMO_iter_step(&siter)) {
                v2 = *((void **)BMO_iter_map_value(&siter));
                BM_edge_create(bm, v, v2, v->e, TRUE);
        }
index 117f65ae4eade23ea19b821686c7afc5f2a6ac7b..08fc97ea262341eb234a84388978e90604dc4d9c 100644 (file)
@@ -604,22 +604,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, "geom_interior.out",
-                                         BM_ALL, HULL_FLAG_INTERIOR_ELE);
+                                         BM_ALL_NOLOOP, 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, "geom_unused.out",
-                                         BM_ALL, HULL_FLAG_DEL);
+                                         BM_ALL_NOLOOP, 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, "geom_holes.out",
-                                         BM_ALL, HULL_FLAG_HOLE);
+                                         BM_ALL_NOLOOP, HULL_FLAG_HOLE);
 
        /* Output slot of all hull vertices, faces, and edges */
        BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom.out",
-                                         BM_ALL, HULL_FLAG_OUTPUT_GEOM);
+                                         BM_ALL_NOLOOP, HULL_FLAG_OUTPUT_GEOM);
 }
 
 #endif  /* WITH_BULLET */
index 41cfae579ff822b8c9940f62d5b7f8990b9f4888..61b061dd21ff9b06e9dcaa4c63e76ce8442a0f92 100644 (file)
@@ -60,7 +60,7 @@ void bmo_mirror_exec(BMesh *bm, BMOperator *op)
        ototvert = bm->totvert;
        /* ototedge = bm->totedge; */ /* UNUSED */
        
-       BMO_slot_mat4_get(op->slots_in, "mat", mtx);
+       BMO_slot_mat4_get(op->slots_in, "matrix", mtx);
        invert_m4_m4(imtx, mtx);
        
        BMO_op_initf(bm, &dupeop, op->flag, "duplicate geom=%s", op, "geom");
@@ -81,9 +81,9 @@ void bmo_mirror_exec(BMesh *bm, BMOperator *op)
 
        /* feed old data to transform bmo */
        scale[axis] = -1.0f;
-       BMO_op_callf(bm, op->flag, "transform verts=%fv mat=%m4", ELE_NEW, mtx);
+       BMO_op_callf(bm, op->flag, "transform verts=%fv matrix=%m4", ELE_NEW, mtx);
        BMO_op_callf(bm, op->flag, "scale verts=%fv vec=%v", ELE_NEW, scale);
-       BMO_op_callf(bm, op->flag, "transform verts=%fv mat=%m4", ELE_NEW, imtx);
+       BMO_op_callf(bm, op->flag, "transform verts=%fv matrix=%m4", ELE_NEW, imtx);
        
        BMO_op_init(bm, &weldop, op->flag, "weld_verts");
 
index 71f63bbaf283594e87bc53c523515050c0e861fa..38096b4ca6f82e156ab91e6872baac0373f2cd4e 100644 (file)
@@ -237,7 +237,7 @@ void bmo_create_grid_exec(BMesh *bm, BMOperator *op)
        float vec[3], mat[4][4], phi, phid;
        int a;
 
-       BMO_slot_mat4_get(op->slots_in, "mat", mat);
+       BMO_slot_mat4_get(op->slots_in, "matrix", mat);
 
        /* one segment first: the X axis */
        phi = 1.0f;
@@ -304,7 +304,7 @@ void bmo_create_uvsphere_exec(BMesh *bm, BMOperator *op)
        float phid;
        int a;
 
-       BMO_slot_mat4_get(op->slots_in, "mat", mat);
+       BMO_slot_mat4_get(op->slots_in, "matrix", mat);
 
        phid = 2.0f * (float)M_PI / tot;
        /* phi = 0.25f * (float)M_PI; */ /* UNUSED */
@@ -348,7 +348,7 @@ void bmo_create_uvsphere_exec(BMesh *bm, BMOperator *op)
                }
 
                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");
+               BMO_op_callf(bm, op->flag, "rotate cent=%v matrix=%m3 verts=%S", vec, cmat, &bmop, "geom.out");
                
                prevop = bmop;
        }
@@ -397,7 +397,7 @@ void bmo_create_icosphere_exec(BMesh *bm, BMOperator *op)
        float vec[3], mat[4][4] /* , phi, phid */;
        int a;
 
-       BMO_slot_mat4_get(op->slots_in, "mat", mat);
+       BMO_slot_mat4_get(op->slots_in, "matrix", mat);
 
        /* phid = 2.0f * (float)M_PI / subdiv; */ /* UNUSED */
        /* phi = 0.25f * (float)M_PI; */         /* UNUSED */
@@ -436,7 +436,7 @@ void bmo_create_icosphere_exec(BMesh *bm, BMOperator *op)
                             "subdivide_edges edges=%fe "
                             "smooth=%f "
                             "cuts=%i "
-                            "use_gridfill=%b use_sphere=%b",
+                            "use_grid_fill=%b use_sphere=%b",
                             EDGE_MARK, dia, (1 << (subdiv - 1)) - 1,
                             TRUE, TRUE);
 
@@ -463,7 +463,7 @@ void bmo_create_monkey_exec(BMesh *bm, BMOperator *op)
        float mat[4][4];
        int i;
 
-       BMO_slot_mat4_get(op->slots_in, "mat", mat);
+       BMO_slot_mat4_get(op->slots_in, "matrix", mat);
 
        for (i = 0; i < monkeynv; i++) {
                float v[3];
@@ -518,7 +518,7 @@ void bmo_create_circle_exec(BMesh *bm, BMOperator *op)
        if (!segs)
                return;
        
-       BMO_slot_mat4_get(op->slots_in, "mat", mat);
+       BMO_slot_mat4_get(op->slots_in, "matrix", mat);
 
        phid = 2.0f * (float)M_PI / segs;
        phi = 0;
@@ -591,7 +591,7 @@ void bmo_create_cone_exec(BMesh *bm, BMOperator *op)
        if (!segs)
                return;
        
-       BMO_slot_mat4_get(op->slots_in, "mat", mat);
+       BMO_slot_mat4_get(op->slots_in, "matrix", mat);
 
        phid = 2.0f * (float)M_PI / segs;
        phi = 0;
@@ -677,7 +677,7 @@ void bmo_create_cube_exec(BMesh *bm, BMOperator *op)
        BMVert *v1, *v2, *v3, *v4, *v5, *v6, *v7, *v8;
        float vec[3], mat[4][4], off = BMO_slot_float_get(op->slots_in, "size") / 2.0f;
 
-       BMO_slot_mat4_get(op->slots_in, "mat", mat);
+       BMO_slot_mat4_get(op->slots_in, "matrix", mat);
 
        if (!off) off = 0.5f;
 
index 8da1f5ebfe5d0e15238b18a6de040678ca17ad29..7407eb4423acccdf6ad87b071a25287381201979 100644 (file)
@@ -226,7 +226,7 @@ static BMVert *subdivideedgenum(BMesh *bm, BMEdge *edge, BMEdge *oedge,
        float percent, percent2 = 0.0f;
 
        if (BMO_elem_flag_test(bm, edge, EDGE_PERCENT) && totpoint == 1) {
-               percent = BMO_slot_map_float_get(params->slot_edgepercents, edge);
+               percent = BMO_slot_map_float_get(params->slot_edge_percents, edge);
        }
        else {
                percent = 1.0f / (float)(totpoint + 1 - curpoint);
@@ -715,7 +715,7 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op)
        BMFace *face;
        BLI_array_declare(verts);
        float smooth, fractal, along_normal;
-       int use_sphere, cornertype, use_singleedge, use_gridfill, use_onlyquads;
+       int use_sphere, cornertype, use_single_edge, use_grid_fill, use_only_quads;
        int skey, seed, i, j, matched, a, b, numcuts, totesel;
        
        BMO_slot_buffer_flag_enable(bm, op->slots_in, "edges", BM_EDGE, SUBD_SPLIT);
@@ -727,10 +727,10 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op)
        along_normal = BMO_slot_float_get(op->slots_in, "along_normal");
        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");
-       use_onlyquads  = BMO_slot_bool_get(op->slots_in, "use_onlyquads");
-       use_sphere     = BMO_slot_bool_get(op->slots_in, "use_sphere");
+       use_single_edge = BMO_slot_bool_get(op->slots_in, "use_single_edge");
+       use_grid_fill = BMO_slot_bool_get(op->slots_in, "use_grid_fill");
+       use_only_quads = BMO_slot_bool_get(op->slots_in, "use_only_quads");
+       use_sphere = BMO_slot_bool_get(op->slots_in, "use_sphere");
        
        BLI_srandom(seed);
        
@@ -748,7 +748,7 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op)
                        break;
        }
        
-       if (use_singleedge) {
+       if (use_single_edge) {
                patterns[0] = &quad_1edge;
                patterns[2] = &tri_1edge;
        }
@@ -757,7 +757,7 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op)
                patterns[2] = NULL;
        }
 
-       if (use_gridfill) {
+       if (use_grid_fill) {
                patterns[3] = &quad_4edge;
                patterns[5] = &tri_3edge;
        }
@@ -780,8 +780,8 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op)
 
        params.numcuts = numcuts;
        params.op = op;
-       params.slot_edgepercents   = BMO_slot_get(op->slots_in, "edgepercents");
-       params.slot_custompatterns = BMO_slot_get(op->slots_in, "custompatterns");
+       params.slot_edge_percents   = BMO_slot_get(op->slots_in, "edge_percents");
+       params.slot_custom_patterns = BMO_slot_get(op->slots_in, "custom_patterns");
        params.smooth = smooth;
        params.seed = seed;
        params.fractal = fractal;
@@ -794,10 +794,10 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op)
        params.off[1] = (float)BLI_drand() * 200.0f;
        params.off[2] = (float)BLI_drand() * 200.0f;
        
-       BMO_slot_map_to_flag(bm, op->slots_in, "custompatterns",
+       BMO_slot_map_to_flag(bm, op->slots_in, "custom_patterns",
                             BM_FACE, FACE_CUSTOMFILL);
 
-       BMO_slot_map_to_flag(bm, op->slots_in, "edgepercents",
+       BMO_slot_map_to_flag(bm, op->slots_in, "edge_percents",
                             BM_EDGE, EDGE_PERCENT);
 
 
@@ -806,7 +806,7 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op)
                float vec1[3], vec2[3];
 
                /* skip non-quads if requested */
-               if (use_onlyquads && face->len != 4)
+               if (use_only_quads && face->len != 4)
                        continue;
 
                /* figure out which pattern to use */
@@ -845,7 +845,7 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op)
                }
 
                if (BMO_elem_flag_test(bm, face, FACE_CUSTOMFILL)) {
-                       pat = BMO_slot_map_data_get(params.slot_custompatterns, face);
+                       pat = BMO_slot_map_data_get(params.slot_custom_patterns, face);
                        for (i = 0; i < pat->len; i++) {
                                matched = 1;
                                for (j = 0; j < pat->len; j++) {
@@ -1093,8 +1093,8 @@ void BM_mesh_esubdivide(BMesh *bm, const char edge_hflag,
                         float smooth, float fractal, float along_normal,
                         int numcuts,
                         int seltype, int cornertype,
-                        const short use_singleedge, const short use_gridfill,
-                        const short use_onlyquads,
+                        const short use_single_edge, const short use_grid_fill,
+                        const short use_only_quads,
                         int seed)
 {
        BMOperator op;
@@ -1105,15 +1105,15 @@ void BM_mesh_esubdivide(BMesh *bm, const char edge_hflag,
                     "smooth=%f fractal=%f along_normal=%f "
                     "cuts=%i "
                     "quad_corner_type=%i "
-                    "use_singleedge=%b use_gridfill=%b "
-                                "use_onlyquads=%b "
+                    "use_single_edge=%b use_grid_fill=%b "
+                    "use_only_quads=%b "
                     "seed=%i",
                     edge_hflag,
                     smooth, fractal, along_normal,
                     numcuts,
                     cornertype,
-                    use_singleedge, use_gridfill,
-                                use_onlyquads,
+                    use_single_edge, use_grid_fill,
+                    use_only_quads,
                     seed);
        
        BMO_op_exec(bm, &op);
@@ -1170,7 +1170,7 @@ void bmo_bisect_edges_exec(BMesh *bm, BMOperator *op)
        
        params.numcuts = BMO_slot_int_get(op->slots_in, "cuts");
        params.op = op;
-       params.slot_edgepercents = BMO_slot_get(op->slots_in, "edgepercents");
+       params.slot_edge_percents = BMO_slot_get(op->slots_in, "edge_percents");
        
        BM_data_layer_add(bm, &bm->vdata, CD_SHAPEKEY);
        skey = CustomData_number_of_layers(&bm->vdata, CD_SHAPEKEY) - 1;
index d0676508917e84332bb1841883080d19a7d95f7a..529075aab02fe713b008718e96af73c5ed815c09 100644 (file)
@@ -39,8 +39,8 @@ typedef struct SubDParams {
        int seed;
        int origkey; /* shapekey holding displaced vertex coordinates for current geometry */
        BMOperator *op;
-       BMOpSlot *slot_edgepercents;  /* BMO_slot_get(params->op->slots_in, "edgepercents"); */
-       BMOpSlot *slot_custompatterns;  /* BMO_slot_get(params->op->slots_in, "custompatterns"); */
+       BMOpSlot *slot_edge_percents;  /* BMO_slot_get(params->op->slots_in, "edge_percents"); */
+       BMOpSlot *slot_custom_patterns;  /* BMO_slot_get(params->op->slots_in, "custom_patterns"); */
        float off[3];
 } SubDParams;
 
index 8c440cae83ef07297ac2a27b4f7467f646e99864..71d9e3295c6b3c97e147e782e0ecb2738cc046a1 100644 (file)
@@ -659,5 +659,5 @@ void bmo_symmetrize_exec(BMesh *bm, BMOperator *op)
        BLI_ghash_free(symm.edge_split_map, NULL, NULL);
 
        BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom.out",
-                                         BM_ALL, SYMM_OUTPUT_GEOM);
+                                         BM_ALL_NOLOOP, SYMM_OUTPUT_GEOM);
 }
index 2f375710959e5d95ce37448cc6b01837b9d65ac9..d20d01af1142fc21c3b5bc5ac8f198a50b53fb2f 100644 (file)
@@ -53,7 +53,7 @@ void bmo_triangulate_exec(BMesh *bm, BMOperator *op)
        BLI_array_declare(projectverts);
        int i;
        const int use_beauty = BMO_slot_bool_get(op->slots_in, "use_beauty");
-       BMOpSlot *slot_facemap_out = BMO_slot_get(op->slots_out, "facemap.out");
+       BMOpSlot *slot_facemap_out = BMO_slot_get(op->slots_out, "face_map.out");
 
        for (face = BMO_iter_new(&siter, op->slots_in, "faces", BM_FACE); face; face = BMO_iter_step(&siter)) {
 
index dde3c526c1327868dfcaa5926e84146be4955185..b88bc51f58696c526be9a5a24443f2c1a9709dd0 100644 (file)
@@ -57,7 +57,7 @@ void bmo_transform_exec(BMesh *UNUSED(bm), BMOperator *op)
        BMVert *v;
        float mat[4][4];
 
-       BMO_slot_mat4_get(op->slots_in, "mat", mat);
+       BMO_slot_mat4_get(op->slots_in, "matrix", mat);
 
        BMO_ITER (v, &iter, op->slots_in, "verts", BM_VERT) {
                mul_m4_v3(mat, v->co);
@@ -73,7 +73,7 @@ void bmo_translate_exec(BMesh *bm, BMOperator *op)
        unit_m4(mat);
        copy_v3_v3(mat[3], vec);
 
-       BMO_op_callf(bm, op->flag, "transform mat=%m4 verts=%s", mat, op, "verts");
+       BMO_op_callf(bm, op->flag, "transform matrix=%m4 verts=%s", mat, op, "verts");
 }
 
 void bmo_scale_exec(BMesh *bm, BMOperator *op)
@@ -87,7 +87,7 @@ void bmo_scale_exec(BMesh *bm, BMOperator *op)
        mat[1][1] = vec[1];
        mat[2][2] = vec[2];
 
-       BMO_op_callf(bm, op->flag, "transform mat=%m3 verts=%s", mat, op, "verts");
+       BMO_op_callf(bm, op->flag, "transform matrix=%m3 verts=%s", mat, op, "verts");
 }
 
 void bmo_rotate_exec(BMesh *bm, BMOperator *op)
@@ -102,7 +102,7 @@ void bmo_rotate_exec(BMesh *bm, BMOperator *op)
        mul_v3_fl(vec, -1.0f);
        BMO_op_callf(bm, op->flag, "translate verts=%s vec=%v", op, "verts", vec);
 
-       BMO_op_callf(bm, op->flag, "transform mat=%s verts=%s", op, "mat", op, "verts");
+       BMO_op_callf(bm, op->flag, "transform matrix=%s verts=%s", op, "matrix", op, "verts");
 
        mul_v3_fl(vec, -1.0f);
        BMO_op_callf(bm, op->flag, "translate verts=%s vec=%v", op, "verts", vec);
index 65d70e231a4257093f39b39e0e79d9a6c8e3446f..23f7c3073562ee718a1ef38d0f890e28677083fa 100644 (file)
@@ -109,7 +109,7 @@ static int add_primitive_plane_exec(bContext *C, wmOperator *op)
        em = BMEdit_FromObject(obedit);
 
        if (!EDBM_op_call_and_selectf(em, op, "verts.out",
-                                     "create_grid x_segments=%i y_segments=%i size=%f mat=%m4", 1, 1, dia, mat))
+                                     "create_grid x_segments=%i y_segments=%i size=%f matrix=%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, "verts.out", "create_cube mat=%m4 size=%f", mat, dia * 2.0f)) {
+       if (!EDBM_op_call_and_selectf(em, op, "verts.out", "create_cube matrix=%m4 size=%f", mat, dia * 2.0f)) {
                return OPERATOR_CANCELLED;
        }
 
@@ -199,7 +199,7 @@ static int add_primitive_circle_exec(bContext *C, wmOperator *op)
        em = BMEdit_FromObject(obedit);
 
        if (!EDBM_op_call_and_selectf(em, op, "verts.out",
-                                     "create_circle segments=%i diameter=%f cap_ends=%b cap_tris=%b mat=%m4",
+                                     "create_circle segments=%i diameter=%f cap_ends=%b cap_tris=%b matrix=%m4",
                                      RNA_int_get(op->ptr, "vertices"), RNA_float_get(op->ptr, "radius") * dia,
                                      cap_end, cap_tri, mat))
        {
@@ -254,7 +254,7 @@ static int add_primitive_cylinder_exec(bContext *C, wmOperator *op)
 
        if (!EDBM_op_call_and_selectf(
                em, op, "verts.out",
-               "create_cone segments=%i diameter1=%f diameter2=%f cap_ends=%b cap_tris=%b depth=%f mat=%m4",
+               "create_cone segments=%i diameter1=%f diameter2=%f cap_ends=%b cap_tris=%b depth=%f matrix=%m4",
                RNA_int_get(op->ptr, "vertices"),
                RNA_float_get(op->ptr, "radius") * dia,
                RNA_float_get(op->ptr, "radius") * dia,
@@ -314,7 +314,7 @@ static int add_primitive_cone_exec(bContext *C, wmOperator *op)
 
        if (!EDBM_op_call_and_selectf(
                em, op, "verts.out",
-               "create_cone segments=%i diameter1=%f diameter2=%f cap_ends=%b cap_tris=%b depth=%f mat=%m4",
+               "create_cone segments=%i diameter1=%f diameter2=%f cap_ends=%b cap_tris=%b depth=%f matrix=%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))
        {
@@ -369,7 +369,7 @@ static int add_primitive_grid_exec(bContext *C, wmOperator *op)
        em = BMEdit_FromObject(obedit);
 
        if (!EDBM_op_call_and_selectf(em, op, "verts.out",
-                                     "create_grid x_segments=%i y_segments=%i size=%f mat=%m4",
+                                     "create_grid x_segments=%i y_segments=%i size=%f matrix=%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, "verts.out", "create_monkey mat=%m4", mat)) {
+       if (!EDBM_op_call_and_selectf(em, op, "verts.out", "create_monkey matrix=%m4", mat)) {
                return OPERATOR_CANCELLED;
        }
 
@@ -467,7 +467,7 @@ static int add_primitive_uvsphere_exec(bContext *C, wmOperator *op)
        em = BMEdit_FromObject(obedit);
 
        if (!EDBM_op_call_and_selectf(em, op, "verts.out",
-                                     "create_uvsphere u_segments=%i v_segments=%i diameter=%f mat=%m4",
+                                     "create_uvsphere u_segments=%i v_segments=%i diameter=%f matrix=%m4",
                                      RNA_int_get(op->ptr, "segments"), RNA_int_get(op->ptr, "ring_count"),
                                      RNA_float_get(op->ptr, "size") * dia, mat))
        {
@@ -519,7 +519,7 @@ static int add_primitive_icosphere_exec(bContext *C, wmOperator *op)
 
        if (!EDBM_op_call_and_selectf(
                em, op, "verts.out",
-               "create_icosphere subdivisions=%i diameter=%f mat=%m4",
+               "create_icosphere subdivisions=%i diameter=%f matrix=%m4",
                RNA_int_get(op->ptr, "subdivisions"),
                RNA_float_get(op->ptr, "size") * dia, mat))
        {
index 3920d684243fb07d00c7b3ffbcdd6842dfcb3a93..62eabd98aee748d782430d182a39b8e6c23a555f 100644 (file)
@@ -314,9 +314,9 @@ static void ringsel_finish(bContext *C, wmOperator *op)
        const int cuts = RNA_int_get(op->ptr, "number_cuts");
        const float smoothness = 0.292f * RNA_float_get(op->ptr, "smoothness");
 #ifdef BMW_EDGERING_NGON
-       const int use_onlyquads = FALSE;
+       const int use_only_quads = FALSE;
 #else
-       const int use_onlyquads = TRUE;
+       const int use_only_quads = TRUE;
 #endif
 
        if (lcd->eed) {
@@ -332,7 +332,7 @@ static void ringsel_finish(bContext *C, wmOperator *op)
                                           smoothness, 0.0f, 0.0f,
                                           cuts,
                                           SUBDIV_SELECT_LOOPCUT, SUBD_PATH, 0, TRUE,
-                                                          use_onlyquads, 0);
+                                                          use_only_quads, 0);
 
                        /* force edge slide to edge select mode in in face select mode */
                        if (em->selectmode & SCE_SELECT_FACE) {
index b3093e0be123ebab9941494b6a1e3ff42145d70c..609470955ad1d5c830acf107840dcbe7e65d16a4 100644 (file)
@@ -891,7 +891,7 @@ static int edbm_dupli_extrude_cursor_invoke(bContext *C, wmOperator *op, wmEvent
                }
                
                if (rot_src) {
-                       EDBM_op_callf(vc.em, op, "rotate verts=%hv cent=%v mat=%m3",
+                       EDBM_op_callf(vc.em, op, "rotate verts=%hv cent=%v matrix=%m3",
                                      BM_ELEM_SELECT, cent, mat);
 
                        /* also project the source, for retopo workflow */
@@ -900,7 +900,7 @@ static int edbm_dupli_extrude_cursor_invoke(bContext *C, wmOperator *op, wmEvent
                }
 
                edbm_extrude_edge(vc.obedit, vc.em, BM_ELEM_SELECT, nor);
-               EDBM_op_callf(vc.em, op, "rotate verts=%hv cent=%v mat=%m3",
+               EDBM_op_callf(vc.em, op, "rotate verts=%hv cent=%v matrix=%m3",
                              BM_ELEM_SELECT, cent, mat);
                EDBM_op_callf(vc.em, op, "translate verts=%hv vec=%v",
                              BM_ELEM_SELECT, min);
@@ -2891,7 +2891,7 @@ static int edbm_knife_cut_exec(bContext *C, wmOperator *op)
        float isect = 0.0f;
        int len = 0, isected, i;
        short numcuts = 1, mode = RNA_int_get(op->ptr, "type");
-       BMOpSlot *slot_edgepercents;
+       BMOpSlot *slot_edge_percents;
 
        /* allocd vars */
        float (*screen_vert_coords)[2], (*sco)[2], (*mouse_path)[2];
@@ -2946,7 +2946,7 @@ static int edbm_knife_cut_exec(bContext *C, wmOperator *op)
        }
 
        /* store percentage of edge cut for KNIFE_EXACT here.*/
-       slot_edgepercents = BMO_slot_get(bmop.slots_in, "edgepercents");
+       slot_edge_percents = BMO_slot_get(bmop.slots_in, "edge_percents");
        for (be = BM_iter_new(&iter, bm, BM_EDGES_OF_MESH, NULL); be; be = BM_iter_step(&iter)) {
                int is_cut = FALSE;
                if (BM_elem_flag_test(be, BM_ELEM_SELECT)) {
@@ -2959,7 +2959,7 @@ static int edbm_knife_cut_exec(bContext *C, wmOperator *op)
 
                                if (isect != 0.0f) {
                                        if (mode != KNIFE_MULTICUT && mode != KNIFE_MIDPOINT) {
-                                               BMO_slot_map_float_insert(&bmop, slot_edgepercents, be, isect);
+                                               BMO_slot_map_float_insert(&bmop, slot_edge_percents, be, isect);
                                        }
                                }
                        }
@@ -2980,8 +2980,8 @@ static int edbm_knife_cut_exec(bContext *C, wmOperator *op)
        BMO_slot_int_set(bmop.slots_in, "cuts", numcuts);
 
        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);
+       BMO_slot_bool_set(bmop.slots_in, "use_single_edge", FALSE);
+       BMO_slot_bool_set(bmop.slots_in, "use_grid_fill", FALSE);
 
        BMO_slot_float_set(bmop.slots_in, "radius", 0);