griefith/test2
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

bmesh api:

Browse Source 
* name bmesh operator func's BMO_slot_buffer_* rather then BMO_slot_* since it wasnt obvious some only dealt with buffer, some both.
* more typechecks and asserts of BMO_ functions (I lost some time calling a map with a buffer function that failed silently).
* small speedup for extrude check - test if the edge is wire _before_ doign a hash lookup.
This commit is contained in:
Campbell Barton
2012-03-01 17:38:04 +00:00
parent 1f473a78b8
commit 522b73a635
15 changed files with 116 additions and 118 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
source/blender/bmesh/bmesh_operator_api.h
View File

@@ -291,8 +291,8 @@ void BMO_mesh_flag_disable_all(BMesh *bm, BMOperator *op, const char htype, cons
/* puts every element of type type (which is a bitmask) with tool flag flag,
* into a slot. */
void BMO_slot_from_flag(BMesh *bm, BMOperator *op, const char *slotname,
const short oflag, const char htype);
void BMO_slot_buffer_from_flag(BMesh *bm, BMOperator *op, const char *slotname,
const short oflag, const char htype);
/* tool-flags all elements inside an element slot array with flag flag. */
void BMO_slot_buffer_flag_enable(BMesh *bm, BMOperator *op, const char *slotname,
@@ -311,11 +311,11 @@ void BMO_slot_buffer_hflag_disable(BMesh *bm, BMOperator *op, const char *slotna
/* puts every element of type type (which is a bitmask) with header flag
* flag, into a slot. note: ignores hidden elements (e.g. elements with
* header flag BM_ELEM_HIDDEN set).*/
void BMO_slot_from_hflag(BMesh *bm, BMOperator *op, const char *slotname,
const char hflag, const char htype);
void BMO_slot_buffer_from_hflag(BMesh *bm, BMOperator *op, const char *slotname,
const char hflag, const char htype);
/* counts number of elements inside a slot array. */
int BMO_slot_buf_count(BMesh *bm, BMOperator *op, const char *slotname);
int BMO_slot_buffer_count(BMesh *bm, BMOperator *op, const char *slotname);
int BMO_slot_map_count(BMesh *bm, BMOperator *op, const char *slotname);
void BMO_slot_map_insert(BMesh *UNUSED(bm), BMOperator *op, const char *slotname,
@@ -371,7 +371,7 @@ typedef struct BMOIter {
char restrictmask; /* bitwise '&' with BMHeader.htype */
} BMOIter;
void *BMO_slot_elem_first(BMOperator *op, const char *slotname);
void *BMO_slot_buffer_elem_first(BMOperator *op, const char *slotname);
/* restrictmask restricts the iteration to certain element types
* (e.g. combination of BM_VERT, BM_EDGE, BM_FACE), if iterating

125
source/blender/bmesh/intern/bmesh_operators.c
View File

@@ -248,46 +248,46 @@ void BMO_slot_copy(BMOperator *source_op, BMOperator *dest_op, const char *src,
if (source_slot == dest_slot)
return;
if (source_slot->slottype != dest_slot->slottype)
if (source_slot->slottype != dest_slot->slottype) {
/* possibly assert here? */
return;
if (dest_slot->slottype > BMO_OP_SLOT_VEC) {
if (dest_slot->slottype != BMO_OP_SLOT_MAPPING) {
/* do buffer copy */
dest_slot->data.buf = NULL;
dest_slot->len = source_slot->len;
if (dest_slot->len) {
const int slot_alloc_size = BMO_OPSLOT_TYPEINFO[dest_slot->slottype] * dest_slot->len;
dest_slot->data.buf = BLI_memarena_alloc(dest_op->arena, slot_alloc_size);
memcpy(dest_slot->data.buf, source_slot->data.buf, slot_alloc_size);
}
}
if (dest_slot->slottype == BMO_OP_SLOT_ELEMENT_BUF) {
/* do buffer copy */
dest_slot->data.buf = NULL;
dest_slot->len = source_slot->len;
if (dest_slot->len) {
const int slot_alloc_size = BMO_OPSLOT_TYPEINFO[dest_slot->slottype] * dest_slot->len;
dest_slot->data.buf = BLI_memarena_alloc(dest_op->arena, slot_alloc_size);
memcpy(dest_slot->data.buf, source_slot->data.buf, slot_alloc_size);
}
else {
GHashIterator it;
BMOElemMapping *srcmap, *dstmap;
}
else if (dest_slot->slottype == BMO_OP_SLOT_MAPPING) {
GHashIterator it;
BMOElemMapping *srcmap, *dstmap;
/* sanity check */
if (!source_slot->data.ghash) {
return;
}
if (!dest_slot->data.ghash) {
dest_slot->data.ghash = BLI_ghash_new(BLI_ghashutil_ptrhash,
BLI_ghashutil_ptrcmp, "bmesh operator 2");
}
/* sanity check */
if (!source_slot->data.ghash) {
return;
}
BLI_ghashIterator_init(&it, source_slot->data.ghash);
for ( ; (srcmap = BLI_ghashIterator_getValue(&it));
BLI_ghashIterator_step(&it))
{
dstmap = BLI_memarena_alloc(dest_op->arena, sizeof(*dstmap) + srcmap->len);
if (!dest_slot->data.ghash) {
dest_slot->data.ghash = BLI_ghash_new(BLI_ghashutil_ptrhash,
BLI_ghashutil_ptrcmp, "bmesh operator 2");
}
dstmap->element = srcmap->element;
dstmap->len = srcmap->len;
memcpy(dstmap + 1, srcmap + 1, srcmap->len);
BLI_ghashIterator_init(&it, source_slot->data.ghash);
for ( ; (srcmap = BLI_ghashIterator_getValue(&it));
BLI_ghashIterator_step(&it))
{
dstmap = BLI_memarena_alloc(dest_op->arena, sizeof(*dstmap) + srcmap->len);
BLI_ghash_insert(dest_slot->data.ghash, dstmap->element, dstmap);
}
dstmap->element = srcmap->element;
dstmap->len = srcmap->len;
memcpy(dstmap + 1, srcmap + 1, srcmap->len);
BLI_ghash_insert(dest_slot->data.ghash, dstmap->element, dstmap);
}
}
else {
@@ -504,13 +504,13 @@ void BMO_mesh_flag_disable_all(BMesh *bm, BMOperator *UNUSED(op), const char hty
}
}
int BMO_slot_buf_count(BMesh *UNUSED(bm), BMOperator *op, const char *slotname)
int BMO_slot_buffer_count(BMesh *UNUSED(bm), BMOperator *op, const char *slotname)
{
BMOpSlot *slot = BMO_slot_get(op, slotname);
BLI_assert(slot->slottype > BMO_OP_SLOT_VEC);
BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF);
/* check if its actually a buffer */
if (!(slot->slottype > BMO_OP_SLOT_VEC))
if (slot->slottype != BMO_OP_SLOT_ELEMENT_BUF)
return 0;
return slot->len;
@@ -553,14 +553,16 @@ void BMO_slot_map_insert(BMesh *UNUSED(bm), BMOperator *op, const char *slotname
}
#if 0
void *BMO_Grow_Array(BMesh *bm, BMOperator *op, int slotcode, int totadd)
void *bmo_slot_buffer_grow(BMesh *bm, BMOperator *op, int slotcode, int totadd)
{
BMOpSlot *slot = &op->slots[slotcode];
void *tmp;
ssize_t allocsize;
BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF);
/* check if its actually a buffer */
if (!(slot->slottype > BMO_OP_SLOT_VEC))
if (slot->slottype != BMO_OP_SLOT_ELEMENT_BUF)
return NULL;
if (slot->flag & BMOS_DYNAMIC_ARRAY) {
@@ -616,11 +618,10 @@ void BMO_slot_map_to_flag(BMesh *bm, BMOperator *op, const char *slotname,
static void *bmo_slot_buffer_alloc(BMOperator *op, const char *slotname, int len)
{
BMOpSlot *slot = BMO_slot_get(op, slotname);
BLI_assert(slot->slottype > BMO_OP_SLOT_VEC);
BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF);
/* check if its actually a buffer */
if (!(slot->slottype > BMO_OP_SLOT_VEC))
if (slot->slottype != BMO_OP_SLOT_ELEMENT_BUF)
return NULL;
slot->len = len;
@@ -634,7 +635,7 @@ static void *bmo_slot_buffer_alloc(BMOperator *op, const char *slotname, int len
*
* Copies all elements of a certain type into an operator slot.
*/
static void BMO_slot_from_all(BMesh *bm, BMOperator *op, const char *slotname, const char htype)
static void BMO_slot_buffer_from_all(BMesh *bm, BMOperator *op, const char *slotname, const char htype)
{
BMIter elements;
BMHeader *e;
@@ -677,7 +678,7 @@ static void BMO_slot_from_all(BMesh *bm, BMOperator *op, const char *slotname, c
* Copies elements of a certain type, which have a certain header flag set
* into a slot for an operator.
*/
void BMO_slot_from_hflag(BMesh *bm, BMOperator *op, const char *slotname,
void BMO_slot_buffer_from_hflag(BMesh *bm, BMOperator *op, const char *slotname,
const char hflag, const char htype)
{
BMIter elements;
@@ -685,7 +686,7 @@ void BMO_slot_from_hflag(BMesh *bm, BMOperator *op, const char *slotname,
BMOpSlot *output = BMO_slot_get(op, slotname);
int totelement = 0, i = 0;
totelement = BM_mesh_count_flag(bm, htype, hflag, 1);
totelement = BM_mesh_count_flag(bm, htype, hflag, TRUE);
if (totelement) {
bmo_slot_buffer_alloc(op, slotname, totelement);
@@ -728,23 +729,27 @@ void BMO_slot_from_hflag(BMesh *bm, BMOperator *op, const char *slotname,
* Copies elements of a certain type, which have a certain flag set
* into an output slot for an operator.
*/
void BMO_slot_from_flag(BMesh *bm, BMOperator *op, const char *slotname,
const short oflag, const char htype)
void BMO_slot_buffer_from_flag(BMesh *bm, BMOperator *op, const char *slotname,
const short oflag, const char htype)
{
BMIter elements;
BMHeader *ele;
BMOpSlot *output = BMO_slot_get(op, slotname);
BMOpSlot *slot = BMO_slot_get(op, slotname);
int totelement = BMO_mesh_flag_count(bm, oflag, htype), i = 0;
BLI_assert(output->slottype > BMO_OP_SLOT_VEC);
BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF);
if (totelement) {
BMHeader *ele;
BMHeader **ele_array;
bmo_slot_buffer_alloc(op, slotname, totelement);
ele_array = (BMHeader **)slot->data.p;
if (htype & BM_VERT) {
for (ele = BM_iter_new(&elements, bm, BM_VERTS_OF_MESH, bm); ele; ele = BM_iter_step(&elements)) {
if (BMO_elem_flag_test(bm, (BMElemF *)ele, oflag)) {
((BMHeader **)output->data.p)[i] = ele;
ele_array[i] = ele;
i++;
}
}
@@ -753,7 +758,7 @@ void BMO_slot_from_flag(BMesh *bm, BMOperator *op, const char *slotname,
if (htype & BM_EDGE) {
for (ele = BM_iter_new(&elements, bm, BM_EDGES_OF_MESH, bm); ele; ele = BM_iter_step(&elements)) {
if (BMO_elem_flag_test(bm, (BMElemF *)ele, oflag)) {
((BMHeader **)output->data.p)[i] = ele;
ele_array[i] = ele;
i++;
}
}
@@ -762,14 +767,14 @@ void BMO_slot_from_flag(BMesh *bm, BMOperator *op, const char *slotname,
if (htype & BM_FACE) {
for (ele = BM_iter_new(&elements, bm, BM_FACES_OF_MESH, bm); ele; ele = BM_iter_step(&elements)) {
if (BMO_elem_flag_test(bm, (BMElemF *)ele, oflag)) {
((BMHeader **)output->data.p)[i] = ele;
ele_array[i] = ele;
i++;
}
}
}
}
else {
output->len = 0;
slot->len = 0;
}
}
@@ -786,7 +791,7 @@ void BMO_slot_buffer_hflag_enable(BMesh *bm, BMOperator *op, const char *slotnam
BMElem **data = slot->data.p;
int i;
BLI_assert(slot->slottype > BMO_OP_SLOT_VEC);
BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF);
if (!(hflag & BM_ELEM_SELECT)) {
do_flush_select = FALSE;
@@ -816,7 +821,7 @@ void BMO_slot_buffer_hflag_disable(BMesh *bm, BMOperator *op, const char *slotna
BMElem **data = slot->data.p;
int i;
BLI_assert(slot->slottype > BMO_OP_SLOT_VEC);
BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF);
if (!(hflag & BM_ELEM_SELECT)) {
do_flush_select = FALSE;
@@ -1027,7 +1032,7 @@ static void bmo_flag_layer_clear(BMesh *bm)
bm->elem_index_dirty &= ~(BM_VERT|BM_EDGE|BM_FACE);
}
void *BMO_slot_elem_first(BMOperator *op, const char *slotname)
void *BMO_slot_buffer_elem_first(BMOperator *op, const char *slotname)
{
BMOpSlot *slot = BMO_slot_get(op, slotname);
@@ -1372,13 +1377,13 @@ int BMO_op_vinitf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist)
}
if (type == 'h') {
BMO_slot_from_hflag(bm, op, slotname, va_arg(vlist, int), ret);
BMO_slot_buffer_from_hflag(bm, op, slotname, va_arg(vlist, int), ret);
}
else if (type == 'a') {
BMO_slot_from_all(bm, op, slotname, ret);
BMO_slot_buffer_from_all(bm, op, slotname, ret);
}
else {
BMO_slot_from_flag(bm, op, slotname, va_arg(vlist, int), ret);
BMO_slot_buffer_from_flag(bm, op, slotname, va_arg(vlist, int), ret);
}
}

4
source/blender/bmesh/operators/bmo_bevel.c
View File

@@ -876,6 +876,6 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
BLI_array_free(edges);
BLI_array_free(faces);
BMO_slot_from_flag(bm, op, "face_spans", FACE_SPAN, BM_FACE);
BMO_slot_from_flag(bm, op, "face_holes", FACE_HOLE, BM_FACE);
BMO_slot_buffer_from_flag(bm, op, "face_spans", FACE_SPAN, BM_FACE);
BMO_slot_buffer_from_flag(bm, op, "face_holes", FACE_HOLE, BM_FACE);
}

2
source/blender/bmesh/operators/bmo_connect.c
View File

@@ -116,7 +116,7 @@ void bmo_connectverts_exec(BMesh *bm, BMOperator *op)
}
}
BMO_slot_from_flag(bm, op, "edgeout", EDGE_OUT, BM_EDGE);
BMO_slot_buffer_from_flag(bm, op, "edgeout", EDGE_OUT, BM_EDGE);
BLI_array_free(loops);
BLI_array_free(verts);

8
source/blender/bmesh/operators/bmo_create.c
View File

@@ -1035,7 +1035,7 @@ void bmo_edgenet_fill_exec(BMesh *bm, BMOperator *op)
edge_free_path(pathbase, path);
}
BMO_slot_from_flag(bm, op, "faceout", FACE_NEW, BM_FACE);
BMO_slot_buffer_from_flag(bm, op, "faceout", FACE_NEW, BM_FACE);
BLI_array_free(edges);
BLI_array_free(verts);
@@ -1232,7 +1232,7 @@ void bmo_edgenet_prepare(BMesh *bm, BMOperator *op)
}
}
BMO_slot_from_flag(bm, op, "edgeout", ELE_NEW, BM_EDGE);
BMO_slot_buffer_from_flag(bm, op, "edgeout", ELE_NEW, BM_EDGE);
BLI_array_free(edges1);
BLI_array_free(edges2);
@@ -1340,7 +1340,7 @@ void bmo_contextual_create_exec(BMesh *bm, BMOperator *op)
BMO_op_exec(bm, &op2);
/* return if edge net create did somethin */
if (BMO_slot_buf_count(bm, &op2, "faceout")) {
if (BMO_slot_buffer_count(bm, &op2, "faceout")) {
BMO_slot_copy(&op2, op, "faceout", "faceout");
BMO_op_finish(bm, &op2);
return;
@@ -1353,7 +1353,7 @@ void bmo_contextual_create_exec(BMesh *bm, BMOperator *op)
BMO_op_exec(bm, &op2);
/* if we dissolved anything, then return */
if (BMO_slot_buf_count(bm, &op2, "regionout")) {
if (BMO_slot_buffer_count(bm, &op2, "regionout")) {
BMO_slot_copy(&op2, op, "regionout", "faceout");
BMO_op_finish(bm, &op2);
return;

2
source/blender/bmesh/operators/bmo_dissolve.c
View File

@@ -176,7 +176,7 @@ void bmo_dissolve_faces_exec(BMesh *bm, BMOperator *op)
if (BMO_error_occurred(bm)) goto cleanup;
BMO_slot_from_flag(bm, op, "regionout", FACE_NEW, BM_FACE);
BMO_slot_buffer_from_flag(bm, op, "regionout", FACE_NEW, BM_FACE);
cleanup:
/* free/cleanu */

6
source/blender/bmesh/operators/bmo_dupe.c
View File

@@ -335,7 +335,7 @@ void bmo_dupe_exec(BMesh *bm, BMOperator *op)
BMO_slot_copy(dupeop, dupeop, "geom", "origout");
/* Now alloc the new output buffer */
BMO_slot_from_flag(bm, dupeop, "newout", DUPE_NEW, BM_ALL);
BMO_slot_buffer_from_flag(bm, dupeop, "newout", DUPE_NEW, BM_ALL);
}
#if 0 /* UNUSED */
@@ -348,7 +348,7 @@ void BMO_dupe_from_flag(BMesh *bm, int etypeflag, const char hflag)
BMOperator dupeop;
BMO_op_init(bm, &dupeop, "dupe");
BMO_slot_from_hflag(bm, &dupeop, "geom", hflag, etypeflag);
BMO_slot_buffer_from_hflag(bm, &dupeop, "geom", hflag, etypeflag);
BMO_op_exec(bm, &dupeop);
BMO_op_finish(bm, &dupeop);
@@ -429,7 +429,7 @@ void bmo_split_exec(BMesh *bm, BMOperator *op)
/* connect outputs of dupe to delete, exluding keep geometr */
BMO_slot_int_set(&delop, "context", DEL_FACES);
BMO_slot_from_flag(bm, &delop, "geom", SPLIT_INPUT, BM_ALL);
BMO_slot_buffer_from_flag(bm, &delop, "geom", SPLIT_INPUT, BM_ALL);
BMO_op_exec(bm, &delop);

4
source/blender/bmesh/operators/bmo_edgesplit.c
View File

@@ -414,8 +414,8 @@ void bmo_edgesplit_exec(BMesh *bm, BMOperator *op)
#endif
tag_out_edges(bm, etags, op);
BMO_slot_from_flag(bm, op, "edgeout1", EDGE_RET1, BM_EDGE);
BMO_slot_from_flag(bm, op, "edgeout2", EDGE_RET2, BM_EDGE);
BMO_slot_buffer_from_flag(bm, op, "edgeout1", EDGE_RET1, BM_EDGE);
BMO_slot_buffer_from_flag(bm, op, "edgeout2", EDGE_RET2, BM_EDGE);
BLI_array_free(verts);
BLI_array_free(edges_tmp);

14
source/blender/bmesh/operators/bmo_extrude.c
View File

@@ -110,7 +110,7 @@ void bmo_extrude_face_indiv_exec(BMesh *bm, BMOperator *op)
BLI_array_free(edges);
BMO_op_callf(bm, "del geom=%ff context=%i", EXT_DEL, DEL_ONLYFACES);
BMO_slot_from_flag(bm, op, "faceout", EXT_KEEP, BM_FACE);
BMO_slot_buffer_from_flag(bm, op, "faceout", EXT_KEEP, BM_FACE);
}
void bmo_extrude_edge_only_exec(BMesh *bm, BMOperator *op)
@@ -162,7 +162,7 @@ void bmo_extrude_edge_only_exec(BMesh *bm, BMOperator *op)
BMO_op_finish(bm, &dupeop);
BMO_slot_from_flag(bm, op, "geomout", EXT_KEEP, BM_ALL);
BMO_slot_buffer_from_flag(bm, op, "geomout", EXT_KEEP, BM_ALL);
}
void bmo_extrude_vert_indiv_exec(BMesh *bm, BMOperator *op)
@@ -181,8 +181,8 @@ void bmo_extrude_vert_indiv_exec(BMesh *bm, BMOperator *op)
BMO_elem_flag_enable(bm, dupev, EXT_KEEP);
}
BMO_slot_from_flag(bm, op, "vertout", EXT_KEEP, BM_VERT);
BMO_slot_from_flag(bm, op, "edgeout", EXT_KEEP, BM_EDGE);
BMO_slot_buffer_from_flag(bm, op, "vertout", EXT_KEEP, BM_VERT);
BMO_slot_buffer_from_flag(bm, op, "edgeout", EXT_KEEP, BM_EDGE);
}
void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op)
@@ -291,11 +291,9 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op)
BMO_slot_copy(&dupeop, op, "newout", "geomout");
e = BMO_iter_new(&siter, bm, &dupeop, "boundarymap", 0);
for ( ; e; e = BMO_iter_step(&siter)) {
if (BMO_slot_map_contains(bm, op, "exclude", e)) {
/* this should always be wire,
* assert if not since we dont want to kill off any faces (next) */
BLI_assert(BM_edge_is_wire(bm, e) == TRUE);
/* this should always be wire, so this is mainly a speedup to avoid map lookup */
if (BM_edge_is_wire(bm, e) && BMO_slot_map_contains(bm, op, "exclude", e)) {
/* The original edge was excluded,
* this would result in a standalone wire edge - see [#30399] */
BM_edge_kill(bm, e);

2
source/blender/bmesh/operators/bmo_mirror.c
View File

@@ -119,7 +119,7 @@ void bmo_mirror_exec(BMesh *bm, BMOperator *op)
BMO_op_finish(bm, &weldop);
BMO_op_finish(bm, &dupeop);
BMO_slot_from_flag(bm, op, "newout", ELE_NEW, BM_ALL);
BMO_slot_buffer_from_flag(bm, op, "newout", ELE_NEW, BM_ALL);
BLI_array_free(vmap);
BLI_array_free(emap);

14
source/blender/bmesh/operators/bmo_primitive.c
View File

@@ -283,7 +283,7 @@ void bmo_create_grid_exec(BMesh *bm, BMOperator *op)
if (a)
BMO_op_finish(bm, &bmop);
BMO_slot_from_flag(bm, op, "vertout", VERT_MARK, BM_VERT);
BMO_slot_buffer_from_flag(bm, op, "vertout", VERT_MARK, BM_VERT);
}
void bmo_create_uvsphere_exec(BMesh *bm, BMOperator *op)
@@ -372,7 +372,7 @@ void bmo_create_uvsphere_exec(BMesh *bm, BMOperator *op)
}
}
BMO_slot_from_flag(bm, op, "vertout", VERT_MARK, BM_VERT);
BMO_slot_buffer_from_flag(bm, op, "vertout", VERT_MARK, BM_VERT);
}
void bmo_create_icosphere_exec(BMesh *bm, BMOperator *op)
@@ -439,7 +439,7 @@ void bmo_create_icosphere_exec(BMesh *bm, BMOperator *op)
}
}
BMO_slot_from_flag(bm, op, "vertout", VERT_MARK, BM_VERT);
BMO_slot_buffer_from_flag(bm, op, "vertout", VERT_MARK, BM_VERT);
}
void bmo_create_monkey_exec(BMesh *bm, BMOperator *op)
@@ -486,7 +486,7 @@ void bmo_create_monkey_exec(BMesh *bm, BMOperator *op)
MEM_freeN(tv);
BMO_slot_from_flag(bm, op, "vertout", VERT_MARK, BM_VERT);
BMO_slot_buffer_from_flag(bm, op, "vertout", VERT_MARK, BM_VERT);
}
@@ -558,7 +558,7 @@ void bmo_create_circle_exec(BMesh *bm, BMOperator *op)
BMO_op_callf(bm, "dissolve_faces faces=%ff", FACE_NEW);
}
BMO_slot_from_flag(bm, op, "vertout", VERT_MARK, BM_VERT);
BMO_slot_buffer_from_flag(bm, op, "vertout", VERT_MARK, BM_VERT);
}
void bmo_create_cone_exec(BMesh *bm, BMOperator *op)
@@ -654,7 +654,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, "removedoubles verts=%fv dist=%f", VERT_MARK, 0.000001);
BMO_slot_from_flag(bm, op, "vertout", VERT_MARK, BM_VERT);
BMO_slot_buffer_from_flag(bm, op, "vertout", VERT_MARK, BM_VERT);
}
void bmo_create_cube_exec(BMesh *bm, BMOperator *op)
@@ -732,5 +732,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_from_flag(bm, op, "vertout", VERT_MARK, BM_VERT);
BMO_slot_buffer_from_flag(bm, op, "vertout", VERT_MARK, BM_VERT);
}

14
source/blender/bmesh/operators/bmo_subdivide.c
View File

@@ -740,8 +740,7 @@ void bmo_esubd_exec(BMesh *bmesh, BMOperator *op)
}
/* first go through and tag edge */
BMO_slot_from_flag(bmesh, op, "edges",
SUBD_SPLIT, BM_EDGE);
BMO_slot_buffer_from_flag(bmesh, op, "edges", SUBD_SPLIT, BM_EDGE);
params.numcuts = numcuts;
params.op = op;
@@ -1006,13 +1005,10 @@ void bmo_esubd_exec(BMesh *bmesh, BMOperator *op)
BLI_array_free(splits);
BLI_array_free(loops);
BMO_slot_from_flag(bmesh, op, "outinner",
ELE_INNER, BM_ALL);
BMO_slot_from_flag(bmesh, op, "outsplit",
ELE_SPLIT, BM_ALL);
BMO_slot_buffer_from_flag(bmesh, op, "outinner", ELE_INNER, BM_ALL);
BMO_slot_buffer_from_flag(bmesh, op, "outsplit", ELE_SPLIT, BM_ALL);
BMO_slot_from_flag(bmesh, op, "geomout",
ELE_INNER|ELE_SPLIT|SUBD_SPLIT, BM_ALL);
BMO_slot_buffer_from_flag(bmesh, op, "geomout", ELE_INNER|ELE_SPLIT|SUBD_SPLIT, BM_ALL);
}
/* editmesh-emulating functio */
@@ -1100,7 +1096,7 @@ void bmo_edgebisect_exec(BMesh *bm, BMOperator *op)
bm_subdivide_multicut(bm, e, &params, e->v1, e->v2);
}
BMO_slot_from_flag(bm, op, "outsplit", ELE_SPLIT, BM_ALL);
BMO_slot_buffer_from_flag(bm, op, "outsplit", ELE_SPLIT, BM_ALL);
BM_data_layer_free_n(bm, &bm->vdata, CD_SHAPEKEY, skey);
}

8
source/blender/bmesh/operators/bmo_triangulate.c
View File

@@ -71,8 +71,8 @@ void bmo_triangulate_exec(BMesh *bm, BMOperator *op)
}
}
BMO_slot_from_flag(bm, op, "edgeout", EDGE_NEW, BM_EDGE);
BMO_slot_from_flag(bm, op, "faceout", FACE_NEW, BM_FACE);
BMO_slot_buffer_from_flag(bm, op, "edgeout", EDGE_NEW, BM_EDGE);
BMO_slot_buffer_from_flag(bm, op, "faceout", FACE_NEW, BM_FACE);
BLI_array_free(projectverts);
BLI_array_free(newfaces);
@@ -151,7 +151,7 @@ void bmo_beautify_fill_exec(BMesh *bm, BMOperator *op)
}
}
BMO_slot_from_flag(bm, op, "geomout", ELE_NEW, BM_EDGE|BM_FACE);
BMO_slot_buffer_from_flag(bm, op, "geomout", ELE_NEW, BM_EDGE|BM_FACE);
}
void bmo_triangle_fill_exec(BMesh *bm, BMOperator *op)
@@ -215,5 +215,5 @@ void bmo_triangle_fill_exec(BMesh *bm, BMOperator *op)
BMO_slot_buffer_flag_enable(bm, &bmop, "geomout", ELE_NEW, BM_FACE|BM_EDGE);
BMO_op_finish(bm, &bmop);
BMO_slot_from_flag(bm, op, "geomout", ELE_NEW, BM_EDGE|BM_FACE);
BMO_slot_buffer_from_flag(bm, op, "geomout", ELE_NEW, BM_EDGE|BM_FACE);
}

14
source/blender/bmesh/operators/bmo_utils.c
View File

@@ -49,7 +49,7 @@ void bmo_makevert_exec(BMesh *bm, BMOperator *op)
BMO_slot_vec_get(op, "co", vec);
BMO_elem_flag_enable(bm, BM_vert_create(bm, vec, NULL), 1);
BMO_slot_from_flag(bm, op, "newvertout", 1, BM_VERT);
BMO_slot_buffer_from_flag(bm, op, "newvertout", 1, BM_VERT);
}
void bmo_transform_exec(BMesh *bm, BMOperator *op)
@@ -134,7 +134,7 @@ void bmo_edgerotate_exec(BMesh *bm, BMOperator *op)
BMO_elem_flag_enable(bm, e2, 1);
}
BMO_slot_from_flag(bm, op, "edgeout", 1, BM_EDGE);
BMO_slot_buffer_from_flag(bm, op, "edgeout", 1, BM_EDGE);
}
#define SEL_FLAG 1
@@ -233,7 +233,7 @@ void bmo_regionextend_exec(BMesh *bm, BMOperator *op)
else
bmo_regionextend_extend(bm, op, use_faces);
BMO_slot_from_flag(bm, op, "geomout", SEL_FLAG, BM_ALL);
BMO_slot_buffer_from_flag(bm, op, "geomout", SEL_FLAG, BM_ALL);
}
/********* righthand faces implementation ****** */
@@ -653,7 +653,7 @@ void bmo_similarfaces_exec(BMesh *bm, BMOperator *op)
MEM_freeN(indices);
/* transfer all marked faces to the output slot */
BMO_slot_from_flag(bm, op, "faceout", FACE_MARK, BM_FACE);
BMO_slot_buffer_from_flag(bm, op, "faceout", FACE_MARK, BM_FACE);
}
/******************************************************************************
@@ -850,7 +850,7 @@ void bmo_similaredges_exec(BMesh *bm, BMOperator *op)
MEM_freeN(indices);
/* transfer all marked edges to the output slot */
BMO_slot_from_flag(bm, op, "edgeout", EDGE_MARK, BM_EDGE);
BMO_slot_buffer_from_flag(bm, op, "edgeout", EDGE_MARK, BM_EDGE);
}
/******************************************************************************
@@ -966,7 +966,7 @@ void bmo_similarverts_exec(BMesh *bm, BMOperator *op)
MEM_freeN(indices);
MEM_freeN(v_ext);
BMO_slot_from_flag(bm, op, "vertout", VERT_MARK, BM_VERT);
BMO_slot_buffer_from_flag(bm, op, "vertout", VERT_MARK, BM_VERT);
}
/******************************************************************************
@@ -1294,5 +1294,5 @@ void bmo_vertexshortestpath_exec(BMesh *bm, BMOperator *op)
BLI_heap_free(h, NULL);
MEM_freeN(vert_list);
BMO_slot_from_flag(bm, op, "vertout", VERT_MARK, BM_VERT);
BMO_slot_buffer_from_flag(bm, op, "vertout", VERT_MARK, BM_VERT);
}

5
source/blender/editors/mesh/bmesh_tools.c
View File

@@ -248,8 +248,7 @@ static short EDBM_Extrude_edge(Object *obedit, BMEditMesh *em, const char hflag,
BMElem *ele;
BMO_op_init(bm, &extop, "extrude_face_region");
BMO_slot_from_hflag(bm, &extop, "edgefacein",
hflag, BM_VERT|BM_EDGE|BM_FACE);
BMO_slot_buffer_from_hflag(bm, &extop, "edgefacein", hflag, BM_VERT|BM_EDGE|BM_FACE);
/* 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.
@@ -3143,7 +3142,7 @@ static int knife_cut_exec(bContext *C, wmOperator *op)
}
}
BMO_slot_from_flag(bm, &bmop, "edges", 1, BM_EDGE);
BMO_slot_buffer_from_flag(bm, &bmop, "edges", 1, BM_EDGE);
if (mode == KNIFE_MIDPOINT) numcuts = 1;
BMO_slot_int_set(&bmop, "numcuts", numcuts);