archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

remove BM_ITER, BM_ITER_INDEX macros, use ELEM or MESH variants only (the maceros had unused args in both cases).

Browse Source
This commit is contained in:
Campbell Barton
2012-04-19 13:47:58 +00:00
parent 9276d7aeb2
commit 475ecbb0ce
72 changed files with 727 additions and 728 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
source/blender/blenkernel/intern/bvhutils.c
View File

@@ -572,7 +572,7 @@ BVHTree* bvhtree_from_mesh_faces(BVHTreeFromMesh *data, DerivedMesh *mesh, float
insert = 0;
}
else {
BM_ITER (v, &iter, em->bm, BM_VERTS_OF_FACE, f) {
BM_ITER_ELEM (v, &iter, f, BM_VERTS_OF_FACE) {
if (BM_elem_flag_test(v, BM_ELEM_SELECT)) {
/* Don't insert triangles tessellated from faces that have
* any selected verts.*/

2
source/blender/blenkernel/intern/cdderivedmesh.c
View File

@@ -1929,7 +1929,7 @@ DerivedMesh *CDDM_from_BMEditMesh(BMEditMesh *em, Mesh *UNUSED(me), int use_mdis
mp->loopstart = j;
mp->mat_nr = efa->mat_nr;
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
mloop->v = BM_elem_index_get(l->v);
mloop->e = BM_elem_index_get(l->e);
CustomData_from_bmesh_block(&bm->ldata, &dm->loopData, l->head.data, j);

4
source/blender/blenkernel/intern/customdata.c
View File

@@ -2204,8 +2204,8 @@ void CustomData_bmesh_merge(CustomData *source, CustomData *dest,
BMIter liter;
/*ensure all current elements follow new customdata layout*/
BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
tmp = NULL;
CustomData_bmesh_copy_data(&destold, dest, l->head.data, &tmp);
CustomData_bmesh_free_block(&destold, &l->head.data);

16
source/blender/blenkernel/intern/editderivedmesh.c
View File

@@ -493,7 +493,7 @@ static void emDM_drawUVEdges(DerivedMesh *dm)
BMIter iter;
glBegin(GL_LINES);
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
BMIter liter;
BMLoop *l;
MLoopUV *lastluv = NULL, *firstluv = NULL;
@@ -501,7 +501,7 @@ static void emDM_drawUVEdges(DerivedMesh *dm)
if (BM_elem_flag_test(efa, BM_ELEM_HIDDEN))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
MLoopUV *luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
if (luv) {
@@ -1468,8 +1468,8 @@ static void emDM_copyLoopArray(DerivedMesh *dm, MLoop *loop_r)
BM_mesh_elem_index_ensure(bm, BM_VERT | BM_EDGE);
BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
loop_r->v = BM_elem_index_get(l->v);
loop_r->e = BM_elem_index_get(l->e);
loop_r++;
@@ -1486,7 +1486,7 @@ static void emDM_copyPolyArray(DerivedMesh *dm, MPoly *poly_r)
int i;
i = 0;
BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
poly_r->flag = BM_face_flag_to_mflag(f);
poly_r->loopstart = i;
poly_r->totloop = f->len;
@@ -1559,7 +1559,7 @@ static void emDM_getVertCos(DerivedMesh *dm, float (*cos_r)[3])
int i;
i= 0;
BM_ITER (eve, &iter, emdm->tc->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, emdm->tc->bm, BM_VERTS_OF_MESH) {
if (emdm->vertexCos) {
copy_v3_v3(cos_r[i], emdm->vertexCos[i]);
}
@@ -1709,7 +1709,7 @@ DerivedMesh *getEditDerivedBMesh(
bmdm->polyNos = MEM_mallocN(sizeof(*bmdm->polyNos)*bm->totface, "bmdm_pno");
i = 0;
BM_ITER (efa, &fiter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &fiter, bm, BM_FACES_OF_MESH) {
BM_elem_index_set(efa, i); /* set_inline */
BM_face_normal_update_vcos(bm, efa, bmdm->polyNos[i], (float const (*)[3])vertexCos);
i++;
@@ -1719,7 +1719,7 @@ DerivedMesh *getEditDerivedBMesh(
eve=BM_iter_new(&viter, bm, BM_VERTS_OF_MESH, NULL);
for (i=0; eve; eve=BM_iter_step(&viter), i++) {
float *no = bmdm->vertexNos[i];
BM_ITER (efa, &fiter, bm, BM_FACES_OF_VERT, eve) {
BM_ITER_ELEM (efa, &fiter, eve, BM_FACES_OF_VERT) {
add_v3_v3(no, bmdm->polyNos[BM_elem_index_get(efa)]);
}

2
source/blender/blenkernel/intern/key.c
View File

@@ -520,7 +520,7 @@ static char *key_block_get_data(Key *key, KeyBlock *actkb, KeyBlock *kb, char **
a = 0;
co = MEM_callocN(sizeof(float) * 3 * me->edit_btmesh->bm->totvert, "key_block_get_data");
BM_ITER (eve, &iter, me->edit_btmesh->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, me->edit_btmesh->bm, BM_VERTS_OF_MESH) {
copy_v3_v3(co[a], eve->co);
a++;
}

2
source/blender/blenkernel/intern/object.c
View File

@@ -1770,7 +1770,7 @@ static void give_parvert(Object *par, int nr, float vec[3])
BMVert *eve;
BMIter iter;
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
int *keyindex = CustomData_bmesh_get(&em->bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
if (keyindex && *keyindex==nr) {

32
source/blender/bmesh/intern/bmesh_construct.c
View File

@@ -495,7 +495,7 @@ void BMO_remove_tagged_faces(BMesh *bm, const short oflag)
BMFace *f;
BMIter iter;
BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
if (BMO_elem_flag_test(bm, f, oflag)) {
BM_face_kill(bm, f);
}
@@ -507,7 +507,7 @@ void BMO_remove_tagged_edges(BMesh *bm, const short oflag)
BMEdge *e;
BMIter iter;
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
if (BMO_elem_flag_test(bm, e, oflag)) {
BM_edge_kill(bm, e);
}
@@ -519,7 +519,7 @@ void BMO_remove_tagged_verts(BMesh *bm, const short oflag)
BMVert *v;
BMIter iter;
BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
if (BMO_elem_flag_test(bm, v, oflag)) {
BM_vert_kill(bm, v);
}
@@ -545,14 +545,14 @@ static void bmo_remove_tagged_context_verts(BMesh *bm, const short oflag)
BMIter iter;
BMIter itersub;
BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
if (BMO_elem_flag_test(bm, v, oflag)) {
/* Visit edge */
BM_ITER (e, &itersub, bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e, &itersub, v, BM_EDGES_OF_VERT) {
BMO_elem_flag_enable(bm, e, oflag);
}
/* Visit face */
BM_ITER (f, &itersub, bm, BM_FACES_OF_VERT, v) {
BM_ITER_ELEM (f, &itersub, v, BM_FACES_OF_VERT) {
BMO_elem_flag_enable(bm, f, oflag);
}
}
@@ -571,9 +571,9 @@ static void bmo_remove_tagged_context_edges(BMesh *bm, const short oflag)
BMIter iter;
BMIter itersub;
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
if (BMO_elem_flag_test(bm, e, oflag)) {
BM_ITER (f, &itersub, bm, BM_FACES_OF_EDGE, e) {
BM_ITER_ELEM (f, &itersub, e, BM_FACES_OF_EDGE) {
BMO_elem_flag_enable(bm, f, oflag);
}
}
@@ -610,7 +610,7 @@ void BMO_remove_tagged_context(BMesh *bm, const short oflag, const int type)
case DEL_EDGES:
{
/* flush down to vert */
BM_ITER (e, &eiter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) {
if (BMO_elem_flag_test(bm, e, oflag)) {
BMO_elem_flag_enable(bm, e->v1, oflag);
BMO_elem_flag_enable(bm, e->v2, oflag);
@@ -618,7 +618,7 @@ void BMO_remove_tagged_context(BMesh *bm, const short oflag, const int type)
}
bmo_remove_tagged_context_edges(bm, oflag);
/* remove loose vertice */
BM_ITER (v, &viter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &viter, bm, BM_VERTS_OF_MESH) {
if (BMO_elem_flag_test(bm, v, oflag) && (!(v->e)))
BMO_elem_flag_enable(bm, v, DEL_WIREVERT);
}
@@ -649,7 +649,7 @@ void BMO_remove_tagged_context(BMesh *bm, const short oflag, const int type)
case DEL_FACES:
{
/* go through and mark all edges and all verts of all faces for delet */
BM_ITER (f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
if (BMO_elem_flag_test(bm, f, oflag)) {
for (e = BM_iter_new(&eiter, bm, BM_EDGES_OF_FACE, f); e; e = BM_iter_step(&eiter))
BMO_elem_flag_enable(bm, e, oflag);
@@ -658,7 +658,7 @@ void BMO_remove_tagged_context(BMesh *bm, const short oflag, const int type)
}
}
/* now go through and mark all remaining faces all edges for keeping */
BM_ITER (f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
if (!BMO_elem_flag_test(bm, f, oflag)) {
for (e = BM_iter_new(&eiter, bm, BM_EDGES_OF_FACE, f); e; e = BM_iter_step(&eiter)) {
BMO_elem_flag_disable(bm, e, oflag);
@@ -669,7 +669,7 @@ void BMO_remove_tagged_context(BMesh *bm, const short oflag, const int type)
}
}
/* also mark all the vertices of remaining edges for keeping */
BM_ITER (e, &eiter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) {
if (!BMO_elem_flag_test(bm, e, oflag)) {
BMO_elem_flag_disable(bm, e->v1, oflag);
BMO_elem_flag_disable(bm, e->v2, oflag);
@@ -687,13 +687,13 @@ void BMO_remove_tagged_context(BMesh *bm, const short oflag, const int type)
case DEL_ALL:
{
/* does this option even belong in here? */
BM_ITER (f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
BMO_elem_flag_enable(bm, f, oflag);
}
BM_ITER (e, &eiter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) {
BMO_elem_flag_enable(bm, e, oflag);
}
BM_ITER (v, &viter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &viter, bm, BM_VERTS_OF_MESH) {
BMO_elem_flag_enable(bm, v, oflag);
}

12
source/blender/bmesh/intern/bmesh_core.c
View File

@@ -1746,7 +1746,7 @@ int BM_vert_splice(BMesh *bm, BMVert *v, BMVert *vtarget)
}
/* retarget all the loops of v to vtarget */
BM_ITER (l, &liter, bm, BM_LOOPS_OF_VERT, v) {
BM_ITER_ELEM (l, &liter, v, BM_LOOPS_OF_VERT) {
l->v = vtarget;
}
@@ -1792,7 +1792,7 @@ int bmesh_vert_separate(BMesh *bm, BMVert *v, BMVert ***r_vout, int *r_vout_len)
visithash = BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, __func__);
maxindex = 0;
BM_ITER (e, &eiter, bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e, &eiter, v, BM_EDGES_OF_VERT) {
if (BLI_ghash_haskey(visithash, e)) {
continue;
}
@@ -1805,7 +1805,7 @@ int bmesh_vert_separate(BMesh *bm, BMVert *v, BMVert ***r_vout, int *r_vout_len)
while ((e = BLI_array_pop(stack))) {
BLI_ghash_insert(visithash, e, SET_INT_IN_POINTER(maxindex));
BM_ITER (l, &liter, bm, BM_LOOPS_OF_EDGE, e) {
BM_ITER_ELEM (l, &liter, e, BM_LOOPS_OF_EDGE) {
nl = (l->v == v) ? l->prev : l->next;
if (!BLI_ghash_haskey(visithash, nl->e)) {
BLI_array_append(stack, nl->e);
@@ -1825,7 +1825,7 @@ int bmesh_vert_separate(BMesh *bm, BMVert *v, BMVert ***r_vout, int *r_vout_len)
/* Replace v with the new verts in each group */
#if 0
BM_ITER (l, &liter, bm, BM_LOOPS_OF_VERT, v) {
BM_ITER_ELEM (l, &liter, v, BM_LOOPS_OF_VERT) {
/* call first since its faster then a hash lookup */
if (l->v != v) {
continue;
@@ -1851,7 +1851,7 @@ int bmesh_vert_separate(BMesh *bm, BMVert *v, BMVert ***r_vout, int *r_vout_len)
* bad practice but save alloc'ing a new array - note, the comment above is useful, keep it
* if you are tidying up code - campbell */
BLI_array_empty(stack);
BM_ITER (l, &liter, bm, BM_LOOPS_OF_VERT, v) {
BM_ITER_ELEM (l, &liter, v, BM_LOOPS_OF_VERT) {
if (l->v == v) {
BLI_array_append(stack, (BMEdge *)l);
}
@@ -1865,7 +1865,7 @@ int bmesh_vert_separate(BMesh *bm, BMVert *v, BMVert ***r_vout, int *r_vout_len)
BLI_array_free(stack);
BM_ITER (e, &eiter, bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e, &eiter, v, BM_EDGES_OF_VERT) {
i = GET_INT_FROM_POINTER(BLI_ghash_lookup(visithash, e));
if (i == 0) {
continue;

14
source/blender/bmesh/intern/bmesh_interp.c
View File

@@ -489,7 +489,7 @@ void BM_face_multires_bounds_smooth(BMesh *bm, BMFace *f)
if (!CustomData_has_layer(&bm->ldata, CD_MDISPS))
return;
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
MDisps *mdp = CustomData_bmesh_get(&bm->ldata, l->prev->head.data, CD_MDISPS);
MDisps *mdl = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_MDISPS);
MDisps *mdn = CustomData_bmesh_get(&bm->ldata, l->next->head.data, CD_MDISPS);
@@ -521,7 +521,7 @@ void BM_face_multires_bounds_smooth(BMesh *bm, BMFace *f)
}
}
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
MDisps *mdl1 = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_MDISPS);
MDisps *mdl2;
float co1[3], co2[3], co[3];
@@ -726,7 +726,7 @@ static void update_data_blocks(BMesh *bm, CustomData *olddata, CustomData *data)
CustomData_bmesh_init_pool(data, bm->totvert, BM_VERT);
BM_ITER (eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
block = NULL;
CustomData_bmesh_set_default(data, &block);
CustomData_bmesh_copy_data(olddata, data, eve->head.data, &block);
@@ -739,7 +739,7 @@ static void update_data_blocks(BMesh *bm, CustomData *olddata, CustomData *data)
CustomData_bmesh_init_pool(data, bm->totedge, BM_EDGE);
BM_ITER (eed, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (eed, &iter, bm, BM_EDGES_OF_MESH) {
block = NULL;
CustomData_bmesh_set_default(data, &block);
CustomData_bmesh_copy_data(olddata, data, eed->head.data, &block);
@@ -753,8 +753,8 @@ static void update_data_blocks(BMesh *bm, CustomData *olddata, CustomData *data)
BMLoop *l;
CustomData_bmesh_init_pool(data, bm->totloop, BM_LOOP);
BM_ITER (efa, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
block = NULL;
CustomData_bmesh_set_default(data, &block);
CustomData_bmesh_copy_data(olddata, data, l->head.data, &block);
@@ -768,7 +768,7 @@ static void update_data_blocks(BMesh *bm, CustomData *olddata, CustomData *data)
CustomData_bmesh_init_pool(data, bm->totface, BM_FACE);
BM_ITER (efa, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
block = NULL;
CustomData_bmesh_set_default(data, &block);
CustomData_bmesh_copy_data(olddata, data, efa->head.data, &block);

10
source/blender/bmesh/intern/bmesh_iterators.h
View File

@@ -82,10 +82,6 @@ typedef enum BMIterType {
/* the iterator htype for each iterator */
extern const char bm_iter_itype_htype_map[BM_ITYPE_MAX];
#define BM_ITER(ele, iter, bm, itype, data) \
for (ele = BM_iter_new(iter, bm, itype, data); ele; ele = BM_iter_step(iter))
#define BM_ITER_MESH(ele, iter, bm, itype) \
for (ele = BM_iter_new(iter, bm, itype, NULL); ele; ele = BM_iter_step(iter))
@@ -95,13 +91,9 @@ extern const char bm_iter_itype_htype_map[BM_ITYPE_MAX];
#define BM_ITER_ELEM(ele, iter, data, itype) \
for (ele = BM_iter_new(iter, NULL, itype, data); ele; ele = BM_iter_step(iter))
#define BM_ITER_ELEM_INDEX(ele, iter, data, itype) \
#define BM_ITER_ELEM_INDEX(ele, iter, data, itype, indexvar) \
for (ele = BM_iter_new(iter, NULL, itype, data), indexvar = 0; ele; ele = BM_iter_step(iter), (indexvar)++)
#define BM_ITER_INDEX(ele, iter, bm, itype, data, indexvar) \
for (ele = BM_iter_new(iter, bm, itype, data), indexvar = 0; ele; ele = BM_iter_step(iter), (indexvar)++)
/* Iterator Structure */
typedef struct BMIter {
BLI_mempool_iter pooliter;

50
source/blender/bmesh/intern/bmesh_marking.c
View File

@@ -84,7 +84,7 @@ void BM_mesh_select_mode_flush(BMesh *bm)
int ok;
if (bm->selectmode & SCE_SELECT_VERTEX) {
BM_ITER (e, &eiter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(e->v1, BM_ELEM_SELECT) &&
BM_elem_flag_test(e->v2, BM_ELEM_SELECT) &&
!BM_elem_flag_test(e, BM_ELEM_HIDDEN))
@@ -95,7 +95,7 @@ void BM_mesh_select_mode_flush(BMesh *bm)
BM_elem_flag_disable(e, BM_ELEM_SELECT);
}
}
BM_ITER (f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
ok = TRUE;
if (!BM_elem_flag_test(f, BM_ELEM_HIDDEN)) {
l_iter = l_first = BM_FACE_FIRST_LOOP(f);
@@ -114,7 +114,7 @@ void BM_mesh_select_mode_flush(BMesh *bm)
}
}
else if (bm->selectmode & SCE_SELECT_EDGE) {
BM_ITER (f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
ok = TRUE;
if (!BM_elem_flag_test(f, BM_ELEM_HIDDEN)) {
l_iter = l_first = BM_FACE_FIRST_LOOP(f);
@@ -154,7 +154,7 @@ void BM_mesh_deselect_flush(BMesh *bm)
int ok;
BM_ITER (e, &eiter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) {
if (!(BM_elem_flag_test(e->v1, BM_ELEM_SELECT) &&
BM_elem_flag_test(e->v2, BM_ELEM_SELECT) &&
!BM_elem_flag_test(e, BM_ELEM_HIDDEN)))
@@ -163,7 +163,7 @@ void BM_mesh_deselect_flush(BMesh *bm)
}
}
BM_ITER (f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
ok = TRUE;
if (!BM_elem_flag_test(f, BM_ELEM_HIDDEN)) {
l_iter = l_first = BM_FACE_FIRST_LOOP(f);
@@ -205,7 +205,7 @@ void BM_mesh_select_flush(BMesh *bm)
int ok;
BM_ITER (e, &eiter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(e->v1, BM_ELEM_SELECT) &&
BM_elem_flag_test(e->v2, BM_ELEM_SELECT) &&
!BM_elem_flag_test(e, BM_ELEM_HIDDEN))
@@ -214,7 +214,7 @@ void BM_mesh_select_flush(BMesh *bm)
}
}
BM_ITER (f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
ok = TRUE;
if (!BM_elem_flag_test(f, BM_ELEM_HIDDEN)) {
l_iter = l_first = BM_FACE_FIRST_LOOP(f);
@@ -360,10 +360,10 @@ void BM_face_select_set(BMesh *bm, BMFace *f, int select)
BM_elem_flag_disable(f, BM_ELEM_SELECT);
/* flush down to edges */
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
BMIter fiter;
BMFace *f2;
BM_ITER (f2, &fiter, bm, BM_FACES_OF_EDGE, l->e) {
BM_ITER_ELEM (f2, &fiter, l->e, BM_FACES_OF_EDGE) {
if (BM_elem_flag_test(f2, BM_ELEM_SELECT))
break;
}
@@ -374,10 +374,10 @@ void BM_face_select_set(BMesh *bm, BMFace *f, int select)
}
/* flush down to verts */
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
BMIter eiter;
BMEdge *e;
BM_ITER (e, &eiter, bm, BM_EDGES_OF_VERT, l->v) {
BM_ITER_ELEM (e, &eiter, l->v, BM_EDGES_OF_VERT) {
if (BM_elem_flag_test(e, BM_ELEM_SELECT))
break;
}
@@ -405,10 +405,10 @@ void BM_mesh_select_mode_set(BMesh *bm, int selectmode)
if (bm->selectmode & SCE_SELECT_VERTEX) {
/* disabled because selection flushing handles these */
#if 0
BM_ITER (ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (ele, &iter, bm, BM_EDGES_OF_MESH) {
BM_elem_flag_disable(ele, BM_ELEM_SELECT);
}
BM_ITER (ele, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (ele, &iter, bm, BM_FACES_OF_MESH) {
BM_elem_flag_disable(ele, BM_ELEM_SELECT);
}
#endif
@@ -417,12 +417,12 @@ void BM_mesh_select_mode_set(BMesh *bm, int selectmode)
else if (bm->selectmode & SCE_SELECT_EDGE) {
/* disabled because selection flushing handles these */
#if 0
BM_ITER (ele, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (ele, &iter, bm, BM_VERTS_OF_MESH) {
BM_elem_flag_disable(ele, BM_ELEM_SELECT);
}
#endif
BM_ITER (ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (ele, &iter, bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(ele, BM_ELEM_SELECT)) {
BM_edge_select_set(bm, (BMEdge *)ele, TRUE);
}
@@ -432,11 +432,11 @@ void BM_mesh_select_mode_set(BMesh *bm, int selectmode)
else if (bm->selectmode & SCE_SELECT_FACE) {
/* disabled because selection flushing handles these */
#if 0
BM_ITER (ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (ele, &iter, bm, BM_EDGES_OF_MESH) {
BM_elem_flag_disable(ele, BM_ELEM_SELECT);
}
#endif
BM_ITER (ele, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (ele, &iter, bm, BM_FACES_OF_MESH) {
if (BM_elem_flag_test(ele, BM_ELEM_SELECT)) {
BM_face_select_set(bm, (BMFace *)ele, TRUE);
}
@@ -543,7 +543,7 @@ BMFace *BM_active_face_get(BMesh *bm, int sloppy)
}
/* Last attempt: try to find any selected face */
if (f == NULL) {
BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
if (BM_elem_flag_test(f, BM_ELEM_SELECT)) {
break;
}
@@ -896,7 +896,7 @@ static void vert_flush_hide_set(BMesh *bm, BMVert *v)
BMEdge *e;
int hide = TRUE;
BM_ITER (e, &iter, bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e, &iter, v, BM_EDGES_OF_VERT) {
hide = hide && BM_elem_flag_test(e, BM_ELEM_HIDDEN);
}
@@ -909,7 +909,7 @@ static void edge_flush_hide(BMesh *bm, BMEdge *e)
BMFace *f;
int hide = TRUE;
BM_ITER (f, &iter, bm, BM_FACES_OF_EDGE, e) {
BM_ITER_ELEM (f, &iter, e, BM_FACES_OF_EDGE) {
hide = hide && BM_elem_flag_test(f, BM_ELEM_HIDDEN);
}
@@ -925,10 +925,10 @@ void BM_vert_hide_set(BMesh *bm, BMVert *v, int hide)
BM_elem_flag_set(v, BM_ELEM_HIDDEN, hide);
BM_ITER (e, &iter, bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e, &iter, v, BM_EDGES_OF_VERT) {
BM_elem_flag_set(e, BM_ELEM_HIDDEN, hide);
BM_ITER (f, &fiter, bm, BM_FACES_OF_EDGE, e) {
BM_ITER_ELEM (f, &fiter, e, BM_FACES_OF_EDGE) {
BM_elem_flag_set(f, BM_ELEM_HIDDEN, hide);
}
}
@@ -941,7 +941,7 @@ void BM_edge_hide_set(BMesh *bm, BMEdge *e, int hide)
/* BMVert *v; */
/* edge hiding: faces around the edge */
BM_ITER (f, &iter, bm, BM_FACES_OF_EDGE, e) {
BM_ITER_ELEM (f, &iter, e, BM_FACES_OF_EDGE) {
BM_elem_flag_set(f, BM_ELEM_HIDDEN, hide);
}
@@ -959,11 +959,11 @@ void BM_face_hide_set(BMesh *bm, BMFace *f, int hide)
BM_elem_flag_set(f, BM_ELEM_HIDDEN, hide);
BM_ITER (l, &iter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l, &iter, f, BM_LOOPS_OF_FACE) {
edge_flush_hide(bm, l->e);
}
BM_ITER (l, &iter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l, &iter, f, BM_LOOPS_OF_FACE) {
vert_flush_hide_set(bm, l->v);
}
}

42
source/blender/bmesh/intern/bmesh_mesh.c
View File

@@ -104,15 +104,15 @@ void BM_mesh_data_free(BMesh *bm)
BMIter iter;
BMIter itersub;
BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
CustomData_bmesh_free_block(&(bm->vdata), &(v->head.data));
}
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
CustomData_bmesh_free_block(&(bm->edata), &(e->head.data));
}
BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
CustomData_bmesh_free_block(&(bm->pdata), &(f->head.data));
BM_ITER (l, &itersub, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l, &itersub, f, BM_LOOPS_OF_FACE) {
CustomData_bmesh_free_block(&(bm->ldata), &(l->head.data));
}
}
@@ -211,7 +211,7 @@ void BM_mesh_normals_update(BMesh *bm, const short skip_hidden)
float (*edgevec)[3];
/* calculate all face normals */
BM_ITER (f, &faces, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &faces, bm, BM_FACES_OF_MESH) {
if (skip_hidden && BM_elem_flag_test(f, BM_ELEM_HIDDEN))
continue;
#if 0 /* UNUSED */
@@ -223,7 +223,7 @@ void BM_mesh_normals_update(BMesh *bm, const short skip_hidden)
}
/* Zero out vertex normals */
BM_ITER (v, &verts, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &verts, bm, BM_VERTS_OF_MESH) {
if (skip_hidden && BM_elem_flag_test(v, BM_ELEM_HIDDEN))
continue;
@@ -235,7 +235,7 @@ void BM_mesh_normals_update(BMesh *bm, const short skip_hidden)
* normals */
index = 0;
edgevec = MEM_callocN(sizeof(float) * 3 * bm->totedge, "BM normal computation array");
BM_ITER (e, &edges, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &edges, bm, BM_EDGES_OF_MESH) {
BM_elem_index_set(e, index); /* set_inline */
if (e->l) {
@@ -251,12 +251,12 @@ void BM_mesh_normals_update(BMesh *bm, const short skip_hidden)
bm->elem_index_dirty &= ~BM_EDGE;
/* add weighted face normals to vertices */
BM_ITER (f, &faces, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &faces, bm, BM_FACES_OF_MESH) {
if (skip_hidden && BM_elem_flag_test(f, BM_ELEM_HIDDEN))
continue;
BM_ITER (l, &loops, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l, &loops, f, BM_LOOPS_OF_FACE) {
float *e1diff, *e2diff;
float dotprod;
float fac;
@@ -282,7 +282,7 @@ void BM_mesh_normals_update(BMesh *bm, const short skip_hidden)
}
/* normalize the accumulated vertex normals */
BM_ITER (v, &verts, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &verts, bm, BM_VERTS_OF_MESH) {
if (skip_hidden && BM_elem_flag_test(v, BM_ELEM_HIDDEN))
continue;
@@ -312,7 +312,7 @@ static void bm_rationalize_normals(BMesh *bm, int undo)
BMIter iter;
if (undo) {
BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
if (BM_elem_flag_test(f, BM_ELEM_TAG)) {
BM_face_normal_flip(bm, f);
}
@@ -327,7 +327,7 @@ static void bm_rationalize_normals(BMesh *bm, int undo)
BMO_push(bm, &bmop);
bmo_righthandfaces_exec(bm, &bmop);
BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
BM_elem_flag_set(f, BM_ELEM_TAG, BMO_elem_flag_test(bm, f, FACE_FLIP));
}
@@ -350,10 +350,10 @@ static void UNUSED_FUNCTION(bm_mdisps_space_set)(Object *ob, BMesh *bm, int from
mdisps = CustomData_get_layer(&dm->loopData, CD_MDISPS);
BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
BMLoop *l;
BMIter liter;
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
MDisps *lmd = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_MDISPS);
if (!lmd->disps) {
@@ -463,7 +463,7 @@ void BM_mesh_elem_index_ensure(BMesh *bm, const char hflag)
if (hflag & BM_VERT) {
if (bm->elem_index_dirty & BM_VERT) {
int index = 0;
BM_ITER (ele, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (ele, &iter, bm, BM_VERTS_OF_MESH) {
BM_elem_index_set(ele, index); /* set_ok */
index++;
}
@@ -478,7 +478,7 @@ void BM_mesh_elem_index_ensure(BMesh *bm, const char hflag)
if (hflag & BM_EDGE) {
if (bm->elem_index_dirty & BM_EDGE) {
int index = 0;
BM_ITER (ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (ele, &iter, bm, BM_EDGES_OF_MESH) {
BM_elem_index_set(ele, index); /* set_ok */
index++;
}
@@ -493,7 +493,7 @@ void BM_mesh_elem_index_ensure(BMesh *bm, const char hflag)
if (hflag & BM_FACE) {
if (bm->elem_index_dirty & BM_FACE) {
int index = 0;
BM_ITER (ele, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (ele, &iter, bm, BM_FACES_OF_MESH) {
BM_elem_index_set(ele, index); /* set_ok */
index++;
}
@@ -712,7 +712,7 @@ void BM_mesh_remap(BMesh *bm, int *vert_idx, int *edge_idx, int *face_idx)
/* And now, fix all vertices/edges/faces/loops pointers! */
/* Verts' pointers, only edge pointers... */
if (eptr_map) {
BM_ITER (ve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (ve, &iter, bm, BM_VERTS_OF_MESH) {
/* printf("Vert e: %p -> %p\n", ve->e, BLI_ghash_lookup(eptr_map, (const void*)ve->e));*/
ve->e = BLI_ghash_lookup(eptr_map, (const void *)ve->e);
}
@@ -720,7 +720,7 @@ void BM_mesh_remap(BMesh *bm, int *vert_idx, int *edge_idx, int *face_idx)
/* Edges' pointers, only vert pointers (as we don’t mess with loops!)... */
if (vptr_map) {
BM_ITER (ed, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (ed, &iter, bm, BM_EDGES_OF_MESH) {
/* printf("Edge v1: %p -> %p\n", ed->v1, BLI_ghash_lookup(vptr_map, (const void*)ed->v1));*/
/* printf("Edge v2: %p -> %p\n", ed->v2, BLI_ghash_lookup(vptr_map, (const void*)ed->v2));*/
ed->v1 = BLI_ghash_lookup(vptr_map, (const void *)ed->v1);
@@ -729,8 +729,8 @@ void BM_mesh_remap(BMesh *bm, int *vert_idx, int *edge_idx, int *face_idx)
}
/* Faces' pointers (loops, in fact), always needed... */
BM_ITER (fa, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER (lo, &iterl, bm, BM_LOOPS_OF_FACE, fa) {
BM_ITER_MESH (fa, &iter, bm, BM_FACES_OF_MESH) {
BM_ITER_ELEM (lo, &iterl, fa, BM_LOOPS_OF_FACE) {
if (vptr_map) {
/* printf("Loop v: %p -> %p\n", lo->v, BLI_ghash_lookup(vptr_map, (const void*)lo->v));*/
lo->v = BLI_ghash_lookup(vptr_map, (const void *)lo->v);

26
source/blender/bmesh/intern/bmesh_mesh_conv.c
View File

@@ -336,7 +336,7 @@ void BM_mesh_bm_from_me(BMesh *bm, Mesh *me, int set_key, int act_key_nr)
if (i == me->act_face) bm->act_face = f;
j = 0;
BM_ITER_INDEX (l, &iter, bm, BM_LOOPS_OF_FACE, f, j) {
BM_ITER_ELEM_INDEX (l, &iter, f, BM_LOOPS_OF_FACE, j) {
/* Save index of correspsonding MLoop */
BM_elem_index_set(l, mpoly->loopstart + j); /* set_loop */
}
@@ -355,8 +355,8 @@ void BM_mesh_bm_from_me(BMesh *bm, Mesh *me, int set_key, int act_key_nr)
* but is an optimization, to avoid copying a bunch of interpolated customdata
* for each BMLoop (from previous BMLoops using the same edge), always followed
* by freeing the interpolated data and overwriting it with data from the Mesh. */
BM_ITER (f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
int li = BM_elem_index_get(l);
CustomData_to_bmesh_block(&me->ldata, &bm->ldata, li, &l->head.data);
BM_elem_index_set(l, 0); /* set_loop */
@@ -379,9 +379,9 @@ void BM_mesh_bm_from_me(BMesh *bm, Mesh *me, int set_key, int act_key_nr)
BMFace *face;
MSelect *msel;
BM_ITER_INDEX (vert, &iter, bm, BM_VERTS_OF_MESH, NULL, i) { vert_array[i] = vert; }
BM_ITER_INDEX (edge, &iter, bm, BM_EDGES_OF_MESH, NULL, i) { edge_array[i] = edge; }
BM_ITER_INDEX (face, &iter, bm, BM_FACES_OF_MESH, NULL, i) { face_array[i] = face; }
BM_ITER_MESH_INDEX (vert, &iter, bm, BM_VERTS_OF_MESH, i) { vert_array[i] = vert; }
BM_ITER_MESH_INDEX (edge, &iter, bm, BM_EDGES_OF_MESH, i) { edge_array[i] = edge; }
BM_ITER_MESH_INDEX (face, &iter, bm, BM_FACES_OF_MESH, i) { face_array[i] = face; }
for (i = 0, msel = me->mselect; i < me->totselect; i++, msel++) {
switch (msel->type) {
@@ -432,7 +432,7 @@ static BMVert **bm_to_mesh_vertex_map(BMesh *bm, int ototvert)
vertMap = MEM_callocN(sizeof(*vertMap) * ototvert, "vertMap");
if (CustomData_has_layer(&bm->vdata, CD_SHAPE_KEYINDEX)) {
int *keyi;
BM_ITER (eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
if (keyi) {
if (((index = *keyi) != ORIGINDEX_NONE) && (index < ototvert)) {
@@ -448,7 +448,7 @@ static BMVert **bm_to_mesh_vertex_map(BMesh *bm, int ototvert)
}
}
else {
BM_ITER (eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
if (i < ototvert) {
vertMap[i] = eve;
}
@@ -564,7 +564,7 @@ void BM_mesh_bm_to_me(BMesh *bm, Mesh *me, int dotess)
mesh_update_customdata_pointers(me, 0);
i = 0;
BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
float *bweight = CustomData_bmesh_get(&bm->vdata, v->head.data, CD_BWEIGHT);
mvert->bweight = bweight ? (char)((*bweight) * 255) : 0;
@@ -588,7 +588,7 @@ void BM_mesh_bm_to_me(BMesh *bm, Mesh *me, int dotess)
med = medge;
i = 0;
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
float *crease = CustomData_bmesh_get(&bm->edata, e->head.data, CD_CREASE);
float *bweight = CustomData_bmesh_get(&bm->edata, e->head.data, CD_BWEIGHT);
@@ -614,7 +614,7 @@ void BM_mesh_bm_to_me(BMesh *bm, Mesh *me, int dotess)
i = 0;
j = 0;
BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
mpoly->loopstart = j;
mpoly->totloop = f->len;
mpoly->mat_nr = f->mat_nr;
@@ -783,7 +783,7 @@ void BM_mesh_bm_to_me(BMesh *bm, Mesh *me, int dotess)
ofs = MEM_callocN(sizeof(float) * 3 * bm->totvert, "currkey->data");
mvert = me->mvert;
BM_ITER_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, NULL, i) {
BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, i) {
keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
if (keyi && *keyi != ORIGINDEX_NONE) {
sub_v3_v3v3(ofs[i], mvert->co, fp[*keyi]);
@@ -806,7 +806,7 @@ void BM_mesh_bm_to_me(BMesh *bm, Mesh *me, int dotess)
oldkey = currkey->data;
mvert = me->mvert;
BM_ITER (eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
if (currkey == actkey) {
copy_v3_v3(fp, eve->co);

8
source/blender/bmesh/intern/bmesh_mesh_validate.c
View File

@@ -70,7 +70,7 @@ int BM_mesh_validate(BMesh *bm)
bm->elem_index_dirty |= BM_ALL;
BM_mesh_elem_index_ensure(bm, BM_ALL);
BM_ITER_INDEX (v, &iter, bm, BM_VERTS_OF_MESH, NULL, i) {
BM_ITER_MESH_INDEX (v, &iter, bm, BM_VERTS_OF_MESH, i) {
if (BM_elem_flag_test(v, BM_ELEM_SELECT | BM_ELEM_HIDDEN) == (BM_ELEM_SELECT | BM_ELEM_HIDDEN)) {
ERRMSG("vert %d: is hidden and selected", i);
}
@@ -83,13 +83,13 @@ int BM_mesh_validate(BMesh *bm)
}
/* check edges */
BM_ITER_INDEX (e, &iter, bm, BM_EDGES_OF_MESH, NULL, i) {
BM_ITER_MESH_INDEX (e, &iter, bm, BM_EDGES_OF_MESH, i) {
if (e->v1 == e->v2)
ERRMSG("edge %d: duplicate index: %d", i, BM_elem_index_get(e->v1));
}
/* edge radial structure */
BM_ITER_INDEX (e, &iter, bm, BM_EDGES_OF_MESH, NULL, i) {
BM_ITER_MESH_INDEX (e, &iter, bm, BM_EDGES_OF_MESH, i) {
if (BM_elem_flag_test(e, BM_ELEM_SELECT | BM_ELEM_HIDDEN) == (BM_ELEM_SELECT | BM_ELEM_HIDDEN)) {
ERRMSG("edge %d: is hidden and selected", i);
}
@@ -117,7 +117,7 @@ int BM_mesh_validate(BMesh *bm)
}
/* face structure */
BM_ITER_INDEX (f, &iter, bm, BM_FACES_OF_MESH, NULL, i) {
BM_ITER_MESH_INDEX (f, &iter, bm, BM_FACES_OF_MESH, i) {
BMLoop *l_iter;
BMLoop *l_first;

8
source/blender/bmesh/intern/bmesh_mods.c
View File

@@ -286,8 +286,8 @@ BMEdge *BM_verts_connect(BMesh *bm, BMVert *v1, BMVert *v2, BMFace **r_f)
BMFace *f_iter;
/* be warned: this can do weird things in some ngon situation, see BM_face_legal_splits */
BM_ITER (f_iter, &fiter, bm, BM_FACES_OF_VERT, v1) {
BM_ITER (v_iter, &viter, bm, BM_FACES_OF_VERT, f_iter) {
BM_ITER_ELEM (f_iter, &fiter, v1, BM_FACES_OF_VERT) {
BM_ITER_ELEM (v_iter, &viter, f_iter, BM_FACES_OF_VERT) {
if (v_iter == v2) {
BMLoop *nl;
@@ -521,7 +521,7 @@ BMEdge *BM_vert_collapse_faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac,
BMFace *f;
BLI_array_staticdeclare(faces, 8);
BM_ITER (f, &iter, bm, BM_FACES_OF_VERT, kv) {
BM_ITER_ELEM (f, &iter, kv, BM_FACES_OF_VERT) {
BLI_array_append(faces, f);
}
@@ -556,7 +556,7 @@ BMEdge *BM_vert_collapse_faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac,
for (i = 0; i < 2; i++) {
/* cant kill data we loop on, build a list and remove those */
BLI_array_empty(bad_faces);
BM_ITER (f, &fiter, bm, BM_FACES_OF_VERT, verts[i]) {
BM_ITER_ELEM (f, &fiter, verts[i], BM_FACES_OF_VERT) {
if (f->len < 3) {
BLI_array_append(bad_faces, f);
}

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

@@ -663,21 +663,21 @@ static void BMO_slot_buffer_from_all(BMesh *bm, BMOperator *op, const char *slot
/* TODO - collapse these loops into one */
if (htype & BM_VERT) {
BM_ITER (ele, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (ele, &iter, bm, BM_VERTS_OF_MESH) {
((BMHeader **)output->data.p)[i] = ele;
i++;
}
}
if (htype & BM_EDGE) {
BM_ITER (ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (ele, &iter, bm, BM_EDGES_OF_MESH) {
((BMHeader **)output->data.p)[i] = ele;
i++;
}
}
if (htype & BM_FACE) {
BM_ITER (ele, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (ele, &iter, bm, BM_FACES_OF_MESH) {
((BMHeader **)output->data.p)[i] = ele;
i++;
}
@@ -714,7 +714,7 @@ static void bmo_slot_buffer_from_hflag(BMesh *bm, BMOperator *op, const char *sl
/* TODO - collapse these loops into one */
if (htype & BM_VERT) {
BM_ITER (ele, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (ele, &iter, bm, BM_VERTS_OF_MESH) {
if (!BM_elem_flag_test(ele, BM_ELEM_HIDDEN) &&
BM_elem_flag_test_bool(ele, hflag) == test_for_enabled)
{
@@ -725,7 +725,7 @@ static void bmo_slot_buffer_from_hflag(BMesh *bm, BMOperator *op, const char *sl
}
if (htype & BM_EDGE) {
BM_ITER (ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (ele, &iter, bm, BM_EDGES_OF_MESH) {
if (!BM_elem_flag_test(ele, BM_ELEM_HIDDEN) &&
BM_elem_flag_test_bool(ele, hflag) == test_for_enabled)
{
@@ -736,7 +736,7 @@ static void bmo_slot_buffer_from_hflag(BMesh *bm, BMOperator *op, const char *sl
}
if (htype & BM_FACE) {
BM_ITER (ele, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (ele, &iter, bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(ele, BM_ELEM_HIDDEN) &&
BM_elem_flag_test_bool(ele, hflag) == test_for_enabled)
{
@@ -828,7 +828,7 @@ static void bmo_slot_buffer_from_flag(BMesh *bm, BMOperator *op, const char *slo
/* TODO - collapse these loops into one */
if (htype & BM_VERT) {
BM_ITER (ele, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (ele, &iter, bm, BM_VERTS_OF_MESH) {
if (BMO_elem_flag_test_bool(bm, (BMElemF *)ele, oflag) == test_for_enabled) {
ele_array[i] = ele;
i++;
@@ -837,7 +837,7 @@ static void bmo_slot_buffer_from_flag(BMesh *bm, BMOperator *op, const char *slo
}
if (htype & BM_EDGE) {
BM_ITER (ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (ele, &iter, bm, BM_EDGES_OF_MESH) {
if (BMO_elem_flag_test_bool(bm, (BMElemF *)ele, oflag) == test_for_enabled) {
ele_array[i] = ele;
i++;
@@ -846,7 +846,7 @@ static void bmo_slot_buffer_from_flag(BMesh *bm, BMOperator *op, const char *slo
}
if (htype & BM_FACE) {
BM_ITER (ele, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (ele, &iter, bm, BM_FACES_OF_MESH) {
if (BMO_elem_flag_test_bool(bm, (BMElemF *)ele, oflag) == test_for_enabled) {
ele_array[i] = ele;
i++;
@@ -1035,19 +1035,19 @@ static void bmo_flag_layer_alloc(BMesh *bm)
bm->toolflagpool = newpool = BLI_mempool_create(sizeof(BMFlagLayer) * bm->totflags, 512, 512, 0);
/* now go through and memcpy all the flags. Loops don't get a flag layer at this time.. */
BM_ITER_INDEX (ele, &iter, bm, BM_VERTS_OF_MESH, NULL, i) {
BM_ITER_MESH_INDEX (ele, &iter, bm, BM_VERTS_OF_MESH, i) {
oldflags = ele->oflags;
ele->oflags = BLI_mempool_calloc(newpool);
memcpy(ele->oflags, oldflags, old_totflags_size);
BM_elem_index_set(ele, i); /* set_inline */
}
BM_ITER_INDEX (ele, &iter, bm, BM_EDGES_OF_MESH, NULL, i) {
BM_ITER_MESH_INDEX (ele, &iter, bm, BM_EDGES_OF_MESH, i) {
oldflags = ele->oflags;
ele->oflags = BLI_mempool_calloc(newpool);
memcpy(ele->oflags, oldflags, old_totflags_size);
BM_elem_index_set(ele, i); /* set_inline */
}
BM_ITER_INDEX (ele, &iter, bm, BM_FACES_OF_MESH, NULL, i) {
BM_ITER_MESH_INDEX (ele, &iter, bm, BM_FACES_OF_MESH, i) {
oldflags = ele->oflags;
ele->oflags = BLI_mempool_calloc(newpool);
memcpy(ele->oflags, oldflags, old_totflags_size);
@@ -1080,19 +1080,19 @@ static void bmo_flag_layer_free(BMesh *bm)
bm->toolflagpool = newpool = BLI_mempool_create(new_totflags_size, 512, 512, BLI_MEMPOOL_SYSMALLOC);
/* now go through and memcpy all the flag */
BM_ITER_INDEX (ele, &iter, bm, BM_VERTS_OF_MESH, NULL, i) {
BM_ITER_MESH_INDEX (ele, &iter, bm, BM_VERTS_OF_MESH, i) {
oldflags = ele->oflags;
ele->oflags = BLI_mempool_calloc(newpool);
memcpy(ele->oflags, oldflags, new_totflags_size);
BM_elem_index_set(ele, i); /* set_inline */
}
BM_ITER_INDEX (ele, &iter, bm, BM_EDGES_OF_MESH, NULL, i) {
BM_ITER_MESH_INDEX (ele, &iter, bm, BM_EDGES_OF_MESH, i) {
oldflags = ele->oflags;
ele->oflags = BLI_mempool_calloc(newpool);
memcpy(ele->oflags, oldflags, new_totflags_size);
BM_elem_index_set(ele, i); /* set_inline */
}
BM_ITER_INDEX (ele, &iter, bm, BM_FACES_OF_MESH, NULL, i) {
BM_ITER_MESH_INDEX (ele, &iter, bm, BM_FACES_OF_MESH, i) {
oldflags = ele->oflags;
ele->oflags = BLI_mempool_calloc(newpool);
memcpy(ele->oflags, oldflags, new_totflags_size);
@@ -1115,15 +1115,15 @@ static void bmo_flag_layer_clear(BMesh *bm)
const int totflags_offset = bm->totflags - 1;
/* now go through and memcpy all the flag */
BM_ITER_INDEX (ele, &iter, bm, BM_VERTS_OF_MESH, NULL, i) {
BM_ITER_MESH_INDEX (ele, &iter, bm, BM_VERTS_OF_MESH, i) {
memset(ele->oflags + totflags_offset, 0, sizeof(BMFlagLayer));
BM_elem_index_set(ele, i); /* set_inline */
}
BM_ITER_INDEX (ele, &iter, bm, BM_EDGES_OF_MESH, NULL, i) {
BM_ITER_MESH_INDEX (ele, &iter, bm, BM_EDGES_OF_MESH, i) {
memset(ele->oflags + totflags_offset, 0, sizeof(BMFlagLayer));
BM_elem_index_set(ele, i); /* set_inline */
}
BM_ITER_INDEX (ele, &iter, bm, BM_FACES_OF_MESH, NULL, i) {
BM_ITER_MESH_INDEX (ele, &iter, bm, BM_FACES_OF_MESH, i) {
memset(ele->oflags + totflags_offset, 0, sizeof(BMFlagLayer));
BM_elem_index_set(ele, i); /* set_inline */
}

6
source/blender/bmesh/intern/bmesh_polygon.c
View File

@@ -164,7 +164,7 @@ float BM_face_area_calc(BMesh *bm, BMFace *f)
BLI_array_fixedstack_declare(verts, BM_NGON_STACK_SIZE, f->len, __func__);
BM_ITER_INDEX (l, &iter, bm, BM_LOOPS_OF_FACE, f, i) {
BM_ITER_ELEM_INDEX (l, &iter, f, BM_LOOPS_OF_FACE, i) {
copy_v3_v3(verts[i], l->v->co);
}
@@ -360,7 +360,7 @@ void BM_vert_normal_update(BMesh *bm, BMVert *v)
zero_v3(v->no);
BM_ITER (l, &liter, bm, BM_LOOPS_OF_VERT, v) {
BM_ITER_ELEM (l, &liter, v, BM_LOOPS_OF_VERT) {
/* Same calculation used in BM_mesh_normals_update */
sub_v3_v3v3(vec1, l->v->co, l->prev->v->co);
sub_v3_v3v3(vec2, l->next->v->co, l->v->co);
@@ -384,7 +384,7 @@ void BM_vert_normal_update_all(BMesh *bm, BMVert *v)
BMIter iter;
BMFace *f;
BM_ITER (f, &iter, bm, BM_FACES_OF_VERT, v) {
BM_ITER_ELEM (f, &iter, v, BM_FACES_OF_VERT) {
BM_face_normal_update(bm, f);
}

26
source/blender/bmesh/intern/bmesh_queries.c
View File

@@ -125,7 +125,7 @@ BMLoop *BM_face_other_vert_loop(BMFace *f, BMVert *v_prev, BMVert *v)
BLI_assert(BM_edge_exists(v_prev, v) != NULL);
BM_ITER (l_iter, &liter, NULL, BM_LOOPS_OF_VERT, v) {
BM_ITER_ELEM (l_iter, &liter, v, BM_LOOPS_OF_VERT) {
if (l_iter->f == f) {
break;
}
@@ -379,7 +379,7 @@ int BM_vert_edge_count_nonwire(BMVert *v)
int count = 0;
BMIter eiter;
BMEdge *edge;
BM_ITER (edge, &eiter, NULL, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (edge, &eiter, v, BM_EDGES_OF_VERT) {
if (edge->l) {
count++;
}
@@ -416,7 +416,7 @@ int BM_vert_face_count(BMVert *v)
BMLoop *l;
BMIter iter;
BM_ITER (l, &iter, NULL, BM_LOOPS_OF_VERT, v) {
BM_ITER_ELEM (l, &iter, v, BM_LOOPS_OF_VERT) {
count++;
}
@@ -877,7 +877,7 @@ BMEdge *BM_edge_exists(BMVert *v1, BMVert *v2)
BMIter iter;
BMEdge *e;
BM_ITER (e, &iter, NULL, BM_EDGES_OF_VERT, v1) {
BM_ITER_ELEM (e, &iter, v1, BM_EDGES_OF_VERT) {
if (e->v1 == v2 || e->v2 == v2)
return e;
}
@@ -902,7 +902,7 @@ int BM_face_exists_overlap(BMesh *bm, BMVert **varr, int len, BMFace **r_overlap
int i, amount;
for (i = 0; i < len; i++) {
BM_ITER (f, &viter, bm, BM_FACES_OF_VERT, varr[i]) {
BM_ITER_ELEM (f, &viter, varr[i], BM_FACES_OF_VERT) {
amount = BM_verts_in_face(bm, f, varr, len);
if (amount >= len) {
if (r_overlapface) {
@@ -932,7 +932,7 @@ int BM_face_exists(BMesh *bm, BMVert **varr, int len, BMFace **r_existface)
int i, amount;
for (i = 0; i < len; i++) {
BM_ITER (f, &viter, bm, BM_FACES_OF_VERT, varr[i]) {
BM_ITER_ELEM (f, &viter, varr[i], BM_FACES_OF_VERT) {
amount = BM_verts_in_face(bm, f, varr, len);
if (amount == len && amount == f->len) {
if (r_existface) {
@@ -978,15 +978,15 @@ int BM_face_exists_multi(BMesh *bm, BMVert **varr, BMEdge **earr, int len)
for (i = 0; i < len; i++) {
/* save some time by looping over edge faces rather then vert faces
* will still loop over some faces twice but not as many */
BM_ITER (f, &fiter, bm, BM_FACES_OF_EDGE, earr[i]) {
BM_ITER_ELEM (f, &fiter, earr[i], BM_FACES_OF_EDGE) {
BM_elem_flag_disable(f, BM_ELEM_INTERNAL_TAG);
BM_ITER (v, &viter, bm, BM_VERTS_OF_FACE, f) {
BM_ITER_ELEM (v, &viter, f, BM_VERTS_OF_FACE) {
BM_elem_flag_disable(v, BM_ELEM_INTERNAL_TAG);
}
}
/* clear all edge tags */
BM_ITER (e, &fiter, bm, BM_EDGES_OF_VERT, varr[i]) {
BM_ITER_ELEM (e, &fiter, varr[i], BM_EDGES_OF_VERT) {
BM_elem_flag_disable(e, BM_ELEM_INTERNAL_TAG);
}
}
@@ -1005,10 +1005,10 @@ int BM_face_exists_multi(BMesh *bm, BMVert **varr, BMEdge **earr, int len)
/* 1) tag all faces connected to edges - if all their verts are boundary */
tot_tag = 0;
for (i = 0; i < len; i++) {
BM_ITER (f, &fiter, bm, BM_FACES_OF_EDGE, earr[i]) {
BM_ITER_ELEM (f, &fiter, earr[i], BM_FACES_OF_EDGE) {
if (!BM_elem_flag_test(f, BM_ELEM_INTERNAL_TAG)) {
ok = TRUE;
BM_ITER (v, &viter, bm, BM_VERTS_OF_FACE, f) {
BM_ITER_ELEM (v, &viter, f, BM_VERTS_OF_FACE) {
if (!BM_elem_flag_test(v, BM_ELEM_INTERNAL_TAG)) {
ok = FALSE;
break;
@@ -1036,7 +1036,7 @@ int BM_face_exists_multi(BMesh *bm, BMVert **varr, BMEdge **earr, int len)
* check each have 2 tagges faces connected (faces that only use 'varr' verts) */
ok = TRUE;
for (i = 0; i < len; i++) {
BM_ITER (e, &fiter, bm, BM_EDGES_OF_VERT, varr[i]) {
BM_ITER_ELEM (e, &fiter, varr[i], BM_EDGES_OF_VERT) {
if (/* non-boundary edge */
BM_elem_flag_test(e, BM_ELEM_INTERNAL_TAG) == FALSE &&
@@ -1045,7 +1045,7 @@ int BM_face_exists_multi(BMesh *bm, BMVert **varr, BMEdge **earr, int len)
BM_elem_flag_test(e->v2, BM_ELEM_INTERNAL_TAG) == TRUE)
{
int tot_face_tag = 0;
BM_ITER (f, &fiter, bm, BM_FACES_OF_EDGE, e) {
BM_ITER_ELEM (f, &fiter, e, BM_FACES_OF_EDGE) {
if (BM_elem_flag_test(f, BM_ELEM_INTERNAL_TAG)) {
tot_face_tag++;
}

12
source/blender/bmesh/intern/bmesh_walkers_impl.c
View File

@@ -115,7 +115,7 @@ static void bmw_ShellWalker_begin(BMWalker *walker, void *data)
/* starting the walk at a vert, add all the edges
* to the worklist */
v = (BMVert *)h;
BM_ITER (e, &eiter, walker->bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e, &eiter, v, BM_EDGES_OF_VERT) {
bmw_ShellWalker_visitEdge(walker, e);
}
break;
@@ -151,7 +151,7 @@ static void *bmw_ShellWalker_step(BMWalker *walker)
for (i = 0; i < 2; i++) {
v = i ? e->v2 : e->v1;
BM_ITER (e2, &iter, walker->bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e2, &iter, v, BM_EDGES_OF_VERT) {
bmw_ShellWalker_visitEdge(walker, e2);
}
}
@@ -249,7 +249,7 @@ static void *bmw_ConnectedVertexWalker_step(BMWalker *walker)
BMW_state_remove(walker);
BM_ITER (e, &iter, walker->bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e, &iter, v, BM_EDGES_OF_VERT) {
v2 = BM_edge_other_vert(e, v);
if (!BLI_ghash_haskey(walker->visithash, v2)) {
bmw_ConnectedVertexWalker_visitVertex(walker, v2);
@@ -450,7 +450,7 @@ static void bmw_LoopWalker_begin(BMWalker *walker, void *data)
BMFace *f_iter;
BMFace *f_best = NULL;
BM_ITER (f_iter, &iter, walker->bm, BM_FACES_OF_EDGE, e) {
BM_ITER_ELEM (f_iter, &iter, e, BM_FACES_OF_EDGE) {
if (f_best == NULL || f_best->len < f_iter->len) {
f_best = f_iter;
}
@@ -606,7 +606,7 @@ static void *bmw_LoopWalker_step(BMWalker *walker)
for (i = 0; i < 2; i++) {
v = i ? e->v2 : e->v1;
BM_ITER (nexte, &eiter, walker->bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (nexte, &eiter, v, BM_EDGES_OF_VERT) {
if ((nexte->l == NULL) &&
bmw_mask_check_edge(walker, nexte) &&
!BLI_ghash_haskey(walker->visithash, nexte))
@@ -953,7 +953,7 @@ static void *bmw_UVEdgeWalker_step(BMWalker *walker)
* mloopuv's coordinates. in addition, push on l->next if necessary */
for (i = 0; i < 2; i++) {
cl = i ? nl : l;
BM_ITER (l2, &liter, walker->bm, BM_LOOPS_OF_VERT, cl->v) {
BM_ITER_ELEM (l2, &liter, cl->v, BM_LOOPS_OF_VERT) {
d1 = CustomData_bmesh_get_layer_n(&walker->bm->ldata,
cl->head.data, walker->layer);

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

@@ -80,7 +80,7 @@ static void calc_corner_co(BMesh *bm, BMLoop *l, const float fac, float r_co[3],
copy_v3_v3(l_co_prev, l->prev->v->co);
copy_v3_v3(l_co, l->v->co);
BM_ITER (l2, &iter, bm, BM_LOOPS_OF_VERT, l->v) {
BM_ITER_ELEM (l2, &iter, l->v, BM_LOOPS_OF_VERT) {
if (l2->f != l->f) {
copy_v3_v3(l_co_next, BM_edge_other_vert(l2->e, l2->next->v)->co);
break;
@@ -228,14 +228,14 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
#endif
}
BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
BMO_elem_flag_enable(bm, v, VERT_OLD);
}
#if 0
//a bit of cleaner code that, alas, doens't work.
/* build edge tag */
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
if (BMO_elem_flag_test(bm, e->v1, BEVEL_FLAG) || BMO_elem_flag_test(bm, e->v2, BEVEL_FLAG)) {
BMIter liter;
BMLoop *l;
@@ -247,14 +247,14 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
BMO_elem_flag_enable(bm, e, EDGE_OLD);
}
BM_ITER (l, &liter, bm, BM_LOOPS_OF_EDGE, e) {
BM_ITER_ELEM (l, &liter, e, BM_LOOPS_OF_EDGE) {
BMLoop *l2;
BMIter liter2;
if (BMO_elem_flag_test(bm, l->f, BEVEL_FLAG))
continue;
BM_ITER (l2, &liter2, bm, BM_LOOPS_OF_FACE, l->f) {
BM_ITER_ELEM (l2, &liter2, l->f, BM_LOOPS_OF_FACE) {
BM_elem_index_set(l2, BLI_array_count(tags)); /* set_loop */
BLI_array_growone(tags);
@@ -299,7 +299,7 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
/* find all faces surrounding e->v1 and, e->v2 */
for (i = 0; i < 2; i++) {
BM_ITER (l, &liter, bm, BM_LOOPS_OF_VERT, i ? e->v2:e->v1) {
BM_ITER_ELEM (l, &liter, i ? e->v2:e->v1, BM_LOOPS_OF_VERT) {
BMLoop *l2;
BMIter liter2;
@@ -308,7 +308,7 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
continue;
/* create tags for all loops in l-> */
BM_ITER (l2, &liter2, bm, BM_LOOPS_OF_FACE, l->f) {
BM_ITER_ELEM (l2, &liter2, l->f, BM_LOOPS_OF_FACE) {
BLI_array_growone(tags);
BM_elem_index_set(l2, BLI_array_count(tags) - 1); /* set_loop */
@@ -329,13 +329,13 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
bm->elem_index_dirty |= BM_EDGE;
BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
BMIter eiter;
if (!BMO_elem_flag_test(bm, v, BEVEL_FLAG))
continue;
BM_ITER (e, &eiter, bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e, &eiter, v, BM_EDGES_OF_VERT) {
if (!BMO_elem_flag_test(bm, e, BEVEL_FLAG) && !ETAG_GET(e, v)) {
BMVert *v2;
float co[3];
@@ -364,7 +364,7 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
BMO_elem_flag_enable(bm, faces[i], FACE_OLD);
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, faces[i]) {
BM_ITER_ELEM (l, &liter, faces[i], BM_LOOPS_OF_FACE) {
float co[3];
if (BMO_elem_flag_test(bm, l->e, BEVEL_FLAG)) {
@@ -438,7 +438,7 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
BLI_array_empty(verts);
BLI_array_empty(edges);
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, faces[i]) {
BM_ITER_ELEM (l, &liter, faces[i], BM_LOOPS_OF_FACE) {
BMVert *v2;
tag = tags + BM_elem_index_get(l);
@@ -489,7 +489,7 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
int j;
/* create quad spans between split edge */
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, faces[i]) {
BM_ITER_ELEM (l, &liter, faces[i], BM_LOOPS_OF_FACE) {
BMVert *v1 = NULL, *v2 = NULL, *v3 = NULL, *v4 = NULL;
if (!BMO_elem_flag_test(bm, l->e, BEVEL_FLAG))
@@ -516,7 +516,7 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
BMIter eiter;
BMVert *v = j ? v4 : v3;
BM_ITER (e, &eiter, bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e, &eiter, v, BM_EDGES_OF_VERT) {
if (!BM_vert_in_edge(e, v3) || !BM_vert_in_edge(e, v4))
continue;
@@ -600,7 +600,7 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
BMO_elem_flag_enable(bm, f, FACE_NEW|FACE_SPAN);
/* un-tag edges in f for deletio */
BM_ITER (l2, &liter2, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l2, &liter2, f, BM_LOOPS_OF_FACE) {
BMO_elem_flag_disable(bm, l2->e, BEVEL_DEL);
}
}
@@ -611,7 +611,7 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
}
/* fill in holes at vertices */
BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
BMIter eiter;
BMVert *vv, *vstart = NULL, *lastv = NULL;
SmallHash tmphash;
@@ -625,7 +625,7 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
BLI_array_empty(verts);
BLI_array_empty(edges);
BM_ITER (e, &eiter, bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e, &eiter, v, BM_EDGES_OF_VERT) {
BMIter liter;
BMVert *v1 = NULL, *v2 = NULL;
BMLoop *l;
@@ -637,7 +637,7 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
continue;
rad = 0;
BM_ITER (l, &liter, bm, BM_LOOPS_OF_EDGE, e) {
BM_ITER_ELEM (l, &liter, e, BM_LOOPS_OF_EDGE) {
if (!BMO_elem_flag_test(bm, l->f, FACE_OLD))
continue;
@@ -685,7 +685,7 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
vstart = vstart ? vstart : verts[0];
vv = vstart;
do {
BM_ITER (e, &eiter, bm, BM_EDGES_OF_VERT, vv) {
BM_ITER_ELEM (e, &eiter, vv, BM_EDGES_OF_VERT) {
BMVert *vv2 = BM_edge_other_vert(e, vv);
if (vv2 != lastv && BLI_smallhash_haskey(&tmphash, (intptr_t)vv2)) {
@@ -730,7 +730,7 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
lastv = NULL;
BLI_array_empty(edges);
do {
BM_ITER (e, &eiter, bm, BM_EDGES_OF_VERT, vv) {
BM_ITER_ELEM (e, &eiter, vv, BM_EDGES_OF_VERT) {
BMVert *vv2 = BM_edge_other_vert(e, vv);
if (vv2 != lastv && BLI_smallhash_haskey(&tmphash, (intptr_t)vv2)) {
@@ -787,7 +787,7 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
BMIter liter;
BMFace *f = faces[i];
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
BMLoop *l2;
BMIter liter2;
@@ -795,7 +795,7 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
if (!tag->newv)
continue;
BM_ITER (l2, &liter2, bm, BM_LOOPS_OF_VERT, tag->newv) {
BM_ITER_ELEM (l2, &liter2, tag->newv, BM_LOOPS_OF_VERT) {
if (!BMO_elem_flag_test(bm, l2->f, FACE_NEW) || (l2->v != tag->newv && l2->v != l->v))
continue;
@@ -812,7 +812,7 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
BMLoop *l3;
BMIter liter3;
BM_ITER (l3, &liter3, bm, BM_LOOPS_OF_FACE, l2->f) {
BM_ITER_ELEM (l3, &liter3, l2->f, BM_LOOPS_OF_FACE) {
BM_loop_interp_multires(bm, l3, l->f);
}
}
@@ -821,7 +821,7 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
}
/* handle vertices along boundary edge */
BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
if (BMO_elem_flag_test(bm, v, VERT_OLD) &&
BMO_elem_flag_test(bm, v, BEVEL_FLAG) &&
!BMO_elem_flag_test(bm, v, BEVEL_DEL))
@@ -830,7 +830,7 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
BMLoop *lorig = NULL;
BMIter liter;
BM_ITER (l, &liter, bm, BM_LOOPS_OF_VERT, v) {
BM_ITER_ELEM (l, &liter, v, BM_LOOPS_OF_VERT) {
// BMIter liter2;
// BMLoop *l2 = l->v == v ? l : l->next, *l3;
@@ -843,7 +843,7 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
if (!lorig)
continue;
BM_ITER (l, &liter, bm, BM_LOOPS_OF_VERT, v) {
BM_ITER_ELEM (l, &liter, v, BM_LOOPS_OF_VERT) {
BMLoop *l2 = l->v == v ? l : l->next;
BM_elem_attrs_copy(bm, bm, lorig->f, l2->f);
@@ -853,7 +853,7 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
}
#if 0
/* clean up any remaining 2-edged face */
BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
if (f->len == 2) {
BMFace *faces[2] = {f, BM_FACE_FIRST_LOOP(f)->radial_next->f};
@@ -868,7 +868,7 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
BMO_op_callf(bm, "del geom=%fv context=%i", BEVEL_DEL, DEL_VERTS);
/* clean up any edges that might not get properly delete */
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
if (BMO_elem_flag_test(bm, e, EDGE_OLD) && !e->l)
BMO_elem_flag_enable(bm, e, BEVEL_DEL);
}

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

@@ -135,7 +135,7 @@ static BMVert *get_outer_vert(BMesh *bm, BMEdge *e)
int i;
i = 0;
BM_ITER (e2, &iter, bm, BM_EDGES_OF_VERT, e->v1) {
BM_ITER_ELEM (e2, &iter, e->v1, BM_EDGES_OF_VERT) {
if (BMO_elem_flag_test(bm, e2, EDGE_MARK)) {
i++;
}
@@ -191,7 +191,7 @@ static void bm_vert_loop_pair(BMesh *bm, BMVert *v1, BMVert *v2, BMLoop **l1, BM
if ((v1->e && v1->e->l) &&
(v2->e && v2->e->l))
{
BM_ITER (l, &liter, bm, BM_LOOPS_OF_VERT, v1) {
BM_ITER_ELEM (l, &liter, v1, BM_LOOPS_OF_VERT) {
if (l->prev->v == v2) {
*l1 = l;
*l2 = l->prev;
@@ -241,7 +241,7 @@ void bmo_bridge_loops_exec(BMesh *bm, BMOperator *op)
do {
v = BM_edge_other_vert(e2, v);
nexte = NULL;
BM_ITER (e3, &iter, bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e3, &iter, v, BM_EDGES_OF_VERT) {
if (e3 != e2 && BMO_elem_flag_test(bm, e3, EDGE_MARK)) {
if (nexte == NULL) {
nexte = e3;
@@ -278,7 +278,7 @@ void bmo_bridge_loops_exec(BMesh *bm, BMOperator *op)
BMO_elem_flag_enable(bm, e2, EDGE_DONE);
v = BM_edge_other_vert(e2, v);
BM_ITER (e3, &iter, bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e3, &iter, v, BM_EDGES_OF_VERT) {
if (e3 != e2 && BMO_elem_flag_test(bm, e3, EDGE_MARK) && !BMO_elem_flag_test(bm, e3, EDGE_DONE)) {
break;
}

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

@@ -225,7 +225,7 @@ static int UNUSED_FUNCTION(rotsys_fill_faces)(BMesh *bm, EdgeData *edata, VertDa
SmallHash visithash, *hash = &visithash;
int i;
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
BMEdge *e2, *starte;
BMVert *startv;
int rad, ok;
@@ -366,7 +366,7 @@ static void init_rotsys(BMesh *bm, EdgeData *edata, VertData *vdata)
#define SIGN(n) ((n)<0.0f)
BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
BMIter eiter;
float no[3], cent[3];
int j, k = 0, totedge = 0;
@@ -376,7 +376,7 @@ static void init_rotsys(BMesh *bm, EdgeData *edata, VertData *vdata)
BLI_array_empty(edges);
BM_ITER (e, &eiter, bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e, &eiter, v, BM_EDGES_OF_VERT) {
if (BMO_elem_flag_test(bm, e, EDGE_MARK)) {
BLI_array_append(edges, e);
totedge++;
@@ -581,7 +581,7 @@ static void init_rotsys(BMesh *bm, EdgeData *edata, VertData *vdata)
#if 0
/* create visualizing geometr */
BMVert *lastv;
BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
BMVert *v2;
BMFace *f;
int totedge = BM_vert_edge_count(v);
@@ -915,12 +915,12 @@ void bmo_edgenet_fill_exec(BMesh *bm, BMOperator *op)
BM_mesh_elem_index_ensure(bm, BM_VERT);
BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
BMO_elem_flag_enable(bm, f, ELE_ORIG);
}
i = 0;
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
BM_elem_index_set(e, i); /* set_inline */
if (!BMO_elem_flag_test(bm, e, EDGE_MARK)) {
@@ -1076,7 +1076,7 @@ static BMEdge *edge_next(BMesh *bm, BMEdge *e)
int i;
for (i = 0; i < 2; i++) {
BM_ITER (e2, &iter, bm, BM_EDGES_OF_VERT, i ? e->v2 : e->v1) {
BM_ITER_ELEM (e2, &iter, i ? e->v2 : e->v1, BM_EDGES_OF_VERT) {
if ((BMO_elem_flag_test(bm, e2, EDGE_MARK)) &&
(!BMO_elem_flag_test(bm, e2, EDGE_VIS)) &&
(e2 != e))
@@ -1317,7 +1317,7 @@ void bmo_contextual_create_exec(BMesh *bm, BMOperator *op)
BMO_ITER (v, &oiter, bm, op, "geom", BM_VERT) {
/* count how many flagged edges this vertex uses */
int tot_edges = 0;
BM_ITER (e, &iter, bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e, &iter, v, BM_EDGES_OF_VERT) {
if (BMO_elem_flag_test(bm, e, ELE_NEW)) {
tot_edges++;
if (tot_edges > 2) {
@@ -1392,7 +1392,7 @@ void bmo_contextual_create_exec(BMesh *bm, BMOperator *op)
/* now, count how many verts we have */
amount = 0;
BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
if (BMO_elem_flag_test(bm, v, ELE_NEW)) {
verts[amount] = v;
amount++;

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

@@ -93,7 +93,7 @@ void bmo_dissolve_faces_exec(BMesh *bm, BMOperator *op)
BMIter viter;
BMVert *v;
BM_ITER (v, &viter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &viter, bm, BM_VERTS_OF_MESH) {
BMO_elem_flag_set(bm, v, VERT_MARK, (BM_vert_edge_count(v) != 2));
}
}
@@ -171,7 +171,7 @@ void bmo_dissolve_faces_exec(BMesh *bm, BMOperator *op)
BMIter viter;
BMVert *v;
BM_ITER (v, &viter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &viter, bm, BM_VERTS_OF_MESH) {
if (BMO_elem_flag_test(bm, v, VERT_MARK)) {
if (BM_vert_edge_count(v) == 2) {
BM_vert_collapse_edge(bm, v->e, v, TRUE);
@@ -219,7 +219,7 @@ void bmo_dissolve_edgeloop_exec(BMesh *bm, BMOperator *op)
}
}
BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
if (BMO_elem_flag_test(bm, v, VERT_MARK) && BM_vert_edge_count(v) == 2) {
BLI_array_append(verts, v);
}
@@ -257,7 +257,7 @@ void bmo_dissolve_edges_exec(BMesh *bm, BMOperator *op)
int use_verts = BMO_slot_bool_get(op, "use_verts");
if (use_verts) {
BM_ITER (v, &viter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &viter, bm, BM_VERTS_OF_MESH) {
BMO_elem_flag_set(bm, v, VERT_MARK, (BM_vert_edge_count(v) != 2));
}
}
@@ -276,7 +276,7 @@ void bmo_dissolve_edges_exec(BMesh *bm, BMOperator *op)
}
if (use_verts) {
BM_ITER (v, &viter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &viter, bm, BM_VERTS_OF_MESH) {
if (BMO_elem_flag_test(bm, v, VERT_MARK)) {
if (BM_vert_edge_count(v) == 2) {
BM_vert_collapse_edge(bm, v->e, v, TRUE);

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

@@ -163,8 +163,8 @@ static BMFace *copy_face(BMOperator *op, BMesh *source_mesh,
BMO_elem_flag_enable(target_mesh, target_face, DUPE_NEW);
/* copy per-loop custom data */
BM_ITER (source_loop, &iter, source_mesh, BM_LOOPS_OF_FACE, source_face) {
BM_ITER (target_loop, &iter2, target_mesh, BM_LOOPS_OF_FACE, target_face) {
BM_ITER_ELEM (source_loop, &iter, source_face, BM_LOOPS_OF_FACE) {
BM_ITER_ELEM (target_loop, &iter2, target_face, BM_LOOPS_OF_FACE) {
if (BLI_ghash_lookup(vhash, source_loop->v) == target_loop->v) {
BM_elem_attrs_copy(source_mesh, target_mesh, source_loop, target_loop);
break;
@@ -201,7 +201,7 @@ static void copy_mesh(BMOperator *op, BMesh *source, BMesh *target)
ehash = BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, "bmesh dupeops e");
/* duplicate flagged vertices */
BM_ITER (v, &viter, source, BM_VERTS_OF_MESH, source) {
BM_ITER_MESH (v, &viter, source, BM_VERTS_OF_MESH) {
if (BMO_elem_flag_test(source, v, DUPE_INPUT) &&
!BMO_elem_flag_test(source, v, DUPE_DONE))
{
@@ -210,7 +210,7 @@ static void copy_mesh(BMOperator *op, BMesh *source, BMesh *target)
v2 = copy_vertex(source, v, target, vhash);
BM_ITER (f, &iter, source, BM_FACES_OF_VERT, v) {
BM_ITER_ELEM (f, &iter, v, BM_FACES_OF_VERT) {
if (BMO_elem_flag_test(source, f, DUPE_INPUT)) {
isolated = 0;
break;
@@ -218,7 +218,7 @@ static void copy_mesh(BMOperator *op, BMesh *source, BMesh *target)
}
if (isolated) {
BM_ITER (e, &iter, source, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e, &iter, v, BM_EDGES_OF_VERT) {
if (BMO_elem_flag_test(source, e, DUPE_INPUT)) {
isolated = 0;
break;
@@ -235,7 +235,7 @@ static void copy_mesh(BMOperator *op, BMesh *source, BMesh *target)
}
/* now we dupe all the edges */
BM_ITER (e, &eiter, source, BM_EDGES_OF_MESH, source) {
BM_ITER_MESH (e, &eiter, source, BM_EDGES_OF_MESH) {
if (BMO_elem_flag_test(source, e, DUPE_INPUT) &&
!BMO_elem_flag_test(source, e, DUPE_DONE))
{
@@ -255,10 +255,10 @@ static void copy_mesh(BMOperator *op, BMesh *source, BMesh *target)
}
/* first we dupe all flagged faces and their elements from source */
BM_ITER (f, &fiter, source, BM_FACES_OF_MESH, source) {
BM_ITER_MESH (f, &fiter, source, BM_FACES_OF_MESH) {
if (BMO_elem_flag_test(source, f, DUPE_INPUT)) {
/* vertex pass */
BM_ITER (v, &viter, source, BM_VERTS_OF_FACE, f) {
BM_ITER_ELEM (v, &viter, f, BM_VERTS_OF_FACE) {
if (!BMO_elem_flag_test(source, v, DUPE_DONE)) {
copy_vertex(source, v, target, vhash);
BMO_elem_flag_enable(source, v, DUPE_DONE);
@@ -266,7 +266,7 @@ static void copy_mesh(BMOperator *op, BMesh *source, BMesh *target)
}
/* edge pass */
BM_ITER (e, &eiter, source, BM_EDGES_OF_FACE, f) {
BM_ITER_ELEM (e, &eiter, f, BM_EDGES_OF_FACE) {
if (!BMO_elem_flag_test(source, e, DUPE_DONE)) {
copy_edge(op, source, e, target, vhash, ehash);
BMO_elem_flag_enable(source, e, DUPE_DONE);

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

@@ -60,7 +60,7 @@ static void bm_edgesplit_validate_seams(BMesh *bm, BMOperator *op)
vtouch = MEM_callocN(sizeof(char) * bm->totvert, __func__);
/* tag all boundary verts so as not to untag an edge which is inbetween only 2 faces [] */
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
/* unrelated to flag assignment in this function - since this is the
* only place we loop over all edges, disable tag */

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

@@ -62,7 +62,7 @@ void bmo_extrude_face_indiv_exec(BMesh *bm, BMOperator *op)
i = 0;
firstv = lastv = NULL;
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
v = BM_vert_create(bm, l->v->co, l->v);
/* skip on the first iteration */
@@ -93,7 +93,7 @@ void bmo_extrude_face_indiv_exec(BMesh *bm, BMOperator *op)
BM_elem_attrs_copy(bm, bm, f, f2);
l2 = BM_iter_new(&liter2, bm, BM_LOOPS_OF_FACE, f2);
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
BM_elem_attrs_copy(bm, bm, l, l2);
l3 = l->next;
@@ -258,7 +258,7 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op)
/* 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, "alwayskeeporig")) {
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
int edge_face_tot;
@@ -269,7 +269,7 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op)
found = FALSE; /* found a face that isn't input? */
edge_face_tot = 0; /* edge/face count */
BM_ITER (f, &fiter, bm, BM_FACES_OF_EDGE, e) {
BM_ITER_ELEM (f, &fiter, e, BM_FACES_OF_EDGE) {
if (!BMO_elem_flag_test(bm, f, EXT_INPUT)) {
found = TRUE;
delorig = TRUE;
@@ -287,10 +287,10 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op)
}
/* calculate verts to delete */
BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
found = FALSE;
BM_ITER (e, &viter, bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e, &viter, v, BM_EDGES_OF_VERT) {
if (!BMO_elem_flag_test(bm, e, EXT_INPUT) || !BMO_elem_flag_test(bm, e, EXT_DEL)) {
found = TRUE;
break;
@@ -299,7 +299,7 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op)
/* avoid an extra loop */
if (found == TRUE) {
BM_ITER (f, &viter, bm, BM_FACES_OF_VERT, v) {
BM_ITER_ELEM (f, &viter, v, BM_FACES_OF_VERT) {
if (!BMO_elem_flag_test(bm, f, EXT_INPUT)) {
found = TRUE;
break;
@@ -312,7 +312,7 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op)
}
}
BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
if (BMO_elem_flag_test(bm, f, EXT_INPUT)) {
BMO_elem_flag_enable(bm, f, EXT_DEL);
}
@@ -335,7 +335,7 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op)
/* if not delorig, reverse loops of original face */
if (!delorig) {
BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
if (BMO_elem_flag_test(bm, f, EXT_INPUT)) {
BM_face_normal_flip(bm, f);
}
@@ -418,18 +418,18 @@ static void calc_solidify_normals(BMesh *bm)
/* can't use BM_edge_face_count because we need to count only marked faces */
int *edge_face_count = MEM_callocN(sizeof(int) * bm->totedge, __func__);
BM_ITER (v, &viter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &viter, bm, BM_VERTS_OF_MESH) {
BM_elem_flag_enable(v, BM_ELEM_TAG);
}
BM_mesh_elem_index_ensure(bm, BM_EDGE);
BM_ITER (f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
if (!BMO_elem_flag_test(bm, f, FACE_MARK)) {
continue;
}
BM_ITER (e, &eiter, bm, BM_EDGES_OF_FACE, f) {
BM_ITER_ELEM (e, &eiter, f, BM_EDGES_OF_FACE) {
/* And mark all edges and vertices on the
* marked faces */
@@ -440,7 +440,7 @@ static void calc_solidify_normals(BMesh *bm)
}
}
BM_ITER (e, &eiter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) {
if (!BMO_elem_flag_test(bm, e, EDGE_MARK)) {
continue;
}
@@ -458,7 +458,7 @@ static void calc_solidify_normals(BMesh *bm)
MEM_freeN(edge_face_count);
edge_face_count = NULL; /* don't re-use */
BM_ITER (v, &viter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &viter, bm, BM_VERTS_OF_MESH) {
if (!BM_vert_is_manifold(v)) {
BMO_elem_flag_enable(bm, v, VERT_NONMAN);
continue;
@@ -469,7 +469,7 @@ static void calc_solidify_normals(BMesh *bm)
}
}
BM_ITER (e, &eiter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) {
/* If the edge is not part of a the solidify region
* its normal should not be considered */
@@ -485,7 +485,7 @@ static void calc_solidify_normals(BMesh *bm)
f1 = f2 = NULL;
BM_ITER (f, &fiter, bm, BM_FACES_OF_EDGE, e) {
BM_ITER_ELEM (f, &fiter, e, BM_FACES_OF_EDGE) {
if (BMO_elem_flag_test(bm, f, FACE_MARK)) {
if (f1 == NULL) {
f1 = f;
@@ -530,7 +530,7 @@ static void calc_solidify_normals(BMesh *bm)
}
/* normalize accumulated vertex normal */
BM_ITER (v, &viter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &viter, bm, BM_VERTS_OF_MESH) {
if (!BMO_elem_flag_test(bm, v, VERT_MARK)) {
continue;
}
@@ -542,7 +542,7 @@ static void calc_solidify_normals(BMesh *bm)
else if (normalize_v3(v->no) == 0.0f && !BM_elem_flag_test(v, BM_ELEM_TAG)) {
/* exceptional case, totally flat. use the normal
* of any marked face around the vertex */
BM_ITER (f, &fiter, bm, BM_FACES_OF_VERT, v) {
BM_ITER_ELEM (f, &fiter, v, BM_FACES_OF_VERT) {
if (BMO_elem_flag_test(bm, f, FACE_MARK)) {
break;
}
@@ -571,13 +571,13 @@ static void solidify_add_thickness(BMesh *bm, const float dist)
BM_mesh_elem_index_ensure(bm, BM_VERT);
BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
if (!BMO_elem_flag_test(bm, f, FACE_MARK)) {
continue;
}
BLI_array_growitems(verts, f->len);
BM_ITER_INDEX (l, &loopIter, bm, BM_LOOPS_OF_FACE, f, i) {
BM_ITER_ELEM_INDEX (l, &loopIter, f, BM_LOOPS_OF_FACE, i) {
verts[i] = l->v->co;
}
@@ -585,7 +585,7 @@ static void solidify_add_thickness(BMesh *bm, const float dist)
angle_poly_v3(face_angles, (const float **)verts, f->len);
i = 0;
BM_ITER (l, &loopIter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l, &loopIter, f, BM_LOOPS_OF_FACE) {
v = l->v;
index = BM_elem_index_get(v);
vert_accum[index] += face_angles[i];
@@ -597,7 +597,7 @@ static void solidify_add_thickness(BMesh *bm, const float dist)
BLI_array_empty(face_angles);
}
BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
index = BM_elem_index_get(v);
if (vert_accum[index]) { /* zero if unselected */
madd_v3_v3fl(v->co, v->no, dist * (vert_angles[index] / vert_accum[index]));

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

@@ -122,7 +122,7 @@ void bmo_inset_exec(BMesh *bm, BMOperator *op)
/* first count all inset edges we will split */
/* fill in array and initialize tagging */
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
if (
/* tag if boundary is enabled */
(use_boundary && BM_edge_is_boundary(e) && BM_elem_flag_test(e->l->f, BM_ELEM_TAG)) ||
@@ -152,7 +152,7 @@ void bmo_inset_exec(BMesh *bm, BMOperator *op)
/* fill in array and initialize tagging */
es = edge_info;
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
i = BM_elem_index_get(e);
if (i != -1) {
/* calc edge-split info */
@@ -246,7 +246,7 @@ void bmo_inset_exec(BMesh *bm, BMOperator *op)
int vecpair[2];
/* find adjacent */
BM_ITER (e, &iter, bm, BM_EDGES_OF_VERT, v_split) {
BM_ITER_ELEM (e, &iter, v_split, BM_EDGES_OF_VERT) {
if (BM_elem_flag_test(e, BM_ELEM_TAG) &&
e->l && BM_elem_flag_test(e->l->f, BM_ELEM_TAG))
{
@@ -411,7 +411,7 @@ void bmo_inset_exec(BMesh *bm, BMOperator *op)
if (r_vout_len > 2) {
int ok = TRUE;
/* last step, NULL this vertex if has a tagged face */
BM_ITER (f, &iter, bm, BM_FACES_OF_VERT, v_split) {
BM_ITER_ELEM (f, &iter, v_split, BM_FACES_OF_VERT) {
if (BM_elem_flag_test(f, BM_ELEM_TAG)) {
ok = FALSE;
break;

12
source/blender/bmesh/operators/bmo_join_triangles.c
View File

@@ -239,13 +239,13 @@ void bmo_join_triangles_exec(BMesh *bm, BMOperator *op)
/* flag all edges of all input face */
BMO_ITER (f1, &siter, bm, op, "faces", BM_FACE) {
BMO_elem_flag_enable(bm, f1, FACE_INPUT);
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f1) {
BM_ITER_ELEM (l, &liter, f1, BM_LOOPS_OF_FACE) {
BMO_elem_flag_enable(bm, l->e, EDGE_MARK);
}
}
/* unflag edges that are invalid; e.g. aren't surrounded by triangle */
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
if (!BMO_elem_flag_test(bm, e, EDGE_MARK))
continue;
@@ -266,7 +266,7 @@ void bmo_join_triangles_exec(BMesh *bm, BMOperator *op)
}
i = 0;
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
BMVert *v1, *v2, *v3, *v4;
BMFace *f1, *f2;
float measure;
@@ -323,7 +323,7 @@ void bmo_join_triangles_exec(BMesh *bm, BMOperator *op)
BMO_elem_flag_enable(bm, e, EDGE_CHOSEN);
}
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
if (!BMO_elem_flag_test(bm, e, EDGE_CHOSEN))
continue;
@@ -332,7 +332,7 @@ void bmo_join_triangles_exec(BMesh *bm, BMOperator *op)
BM_faces_join_pair(bm, f1, f2, e, TRUE);
}
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
if (BMO_elem_flag_test(bm, e, EDGE_MARK)) {
/* ok, this edge wasn't merged, check if it's
* in a 2-tri-pair island, and if so merg */
@@ -344,7 +344,7 @@ void bmo_join_triangles_exec(BMesh *bm, BMOperator *op)
continue;
for (i = 0; i < 2; i++) {
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, i ? f2 : f1) {
BM_ITER_ELEM (l, &liter, i ? f2 : f1, BM_LOOPS_OF_FACE) {
if (l->e != e && BMO_elem_flag_test(bm, l->e, EDGE_MARK)) {
break;
}

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

@@ -102,7 +102,7 @@ void bmo_mirror_exec(BMesh *bm, BMOperator *op)
BMIter liter;
BMO_ITER (f, &siter, bm, &dupeop, "newout", BM_FACE) {
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
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++) {
luv = CustomData_bmesh_get_n(&bm->ldata, l->head.data, CD_MLOOPUV, i);

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

@@ -370,7 +370,7 @@ void bmo_create_uvsphere_exec(BMesh *bm, BMOperator *op)
}
/* and now do imat */
BM_ITER (eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
if (BMO_elem_flag_test(bm, eve, VERT_MARK)) {
mul_m4_v3(mat, eve->co);
}
@@ -415,7 +415,7 @@ void bmo_create_icosphere_exec(BMesh *bm, BMOperator *op)
eftemp = BM_face_create_quad_tri(bm, v1, v2, v3, NULL, NULL, FALSE);
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, eftemp) {
BM_ITER_ELEM (l, &liter, eftemp, BM_LOOPS_OF_FACE) {
BMO_elem_flag_enable(bm, l->e, EDGE_MARK);
}
@@ -437,7 +437,7 @@ void bmo_create_icosphere_exec(BMesh *bm, BMOperator *op)
}
/* must transform after because of sphere subdivision */
BM_ITER (v, &viter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &viter, bm, BM_VERTS_OF_MESH) {
if (BMO_elem_flag_test(bm, v, VERT_MARK)) {
mul_m4_v3(mat, v->co);
}

34
source/blender/bmesh/operators/bmo_removedoubles.c
View File

@@ -43,7 +43,7 @@ static void remdoubles_splitface(BMFace *f, BMesh *bm, BMOperator *op)
BMVert *v2, *doub;
int split = FALSE;
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
v2 = BMO_slot_map_ptr_get(bm, op, "targetmap", l->v);
/* ok: if v2 is NULL (e.g. not in the map) then it's
* a target vert, otherwise it's a double */
@@ -108,7 +108,7 @@ void bmo_weldverts_exec(BMesh *bm, BMOperator *op)
int a, b;
/* mark merge verts for deletion */
BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
if ((v2 = BMO_slot_map_ptr_get(bm, op, "targetmap", v))) {
BMO_elem_flag_enable(bm, v, ELE_DEL);
@@ -119,11 +119,11 @@ void bmo_weldverts_exec(BMesh *bm, BMOperator *op)
/* check if any faces are getting their own corners merged
together, split face if so */
BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
remdoubles_splitface(f, bm, op);
}
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
if (BMO_elem_flag_test(bm, e->v1, ELE_DEL) || BMO_elem_flag_test(bm, e->v2, ELE_DEL)) {
v = BMO_slot_map_ptr_get(bm, op, "targetmap", e->v1);
v2 = BMO_slot_map_ptr_get(bm, op, "targetmap", e->v2);
@@ -143,9 +143,9 @@ void bmo_weldverts_exec(BMesh *bm, BMOperator *op)
}
/* BMESH_TODO, stop abusing face index here */
BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
BM_elem_index_set(f, 0); /* set_dirty! */
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
if (BMO_elem_flag_test(bm, l->v, ELE_DEL)) {
BMO_elem_flag_enable(bm, f, FACE_MARK|ELE_DEL);
}
@@ -158,7 +158,7 @@ void bmo_weldverts_exec(BMesh *bm, BMOperator *op)
/* faces get "modified" by creating new faces here, then at the
end the old faces are deleted */
BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
if (!BMO_elem_flag_test(bm, f, FACE_MARK))
continue;
@@ -170,7 +170,7 @@ void bmo_weldverts_exec(BMesh *bm, BMOperator *op)
BLI_array_empty(edges);
BLI_array_empty(loops);
a = 0;
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
v = l->v;
v2 = l->next->v;
if (BMO_elem_flag_test(bm, v, ELE_DEL)) {
@@ -218,7 +218,7 @@ void bmo_weldverts_exec(BMesh *bm, BMOperator *op)
BM_elem_attrs_copy(bm, bm, f, f2);
a = 0;
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f2) {
BM_ITER_ELEM (l, &liter, f2, BM_LOOPS_OF_FACE) {
l2 = loops[a];
BM_elem_attrs_copy(bm, bm, l2, l);
@@ -269,7 +269,7 @@ void bmo_pointmerge_facedata_exec(BMesh *bm, BMOperator *op)
return;
fac = 1.0f / tot;
BM_ITER (l, &iter, bm, BM_LOOPS_OF_VERT, snapv) {
BM_ITER_ELEM (l, &iter, snapv, BM_LOOPS_OF_VERT) {
if (!firstl) {
firstl = l;
}
@@ -291,7 +291,7 @@ void bmo_pointmerge_facedata_exec(BMesh *bm, BMOperator *op)
}
BMO_ITER (v, &siter, bm, op, "verts", BM_VERT) {
BM_ITER (l, &iter, bm, BM_LOOPS_OF_VERT, v) {
BM_ITER_ELEM (l, &iter, v, BM_LOOPS_OF_VERT) {
if (l == firstl) {
continue;
}
@@ -319,7 +319,7 @@ void bmo_vert_average_facedata_exec(BMesh *bm, BMOperator *op)
CustomData_data_initminmax(type, &min, &max);
BMO_ITER (v, &siter, bm, op, "verts", BM_VERT) {
BM_ITER (l, &iter, bm, BM_LOOPS_OF_VERT, v) {
BM_ITER_ELEM (l, &iter, v, BM_LOOPS_OF_VERT) {
block = CustomData_bmesh_get_layer_n(&bm->ldata, l->head.data, i);
CustomData_data_dominmax(type, block, &min, &max);
}
@@ -330,7 +330,7 @@ void bmo_vert_average_facedata_exec(BMesh *bm, BMOperator *op)
CustomData_data_add(type, &min, &max);
BMO_ITER (v, &siter, bm, op, "verts", BM_VERT) {
BM_ITER (l, &iter, bm, BM_LOOPS_OF_VERT, v) {
BM_ITER_ELEM (l, &iter, v, BM_LOOPS_OF_VERT) {
block = CustomData_bmesh_get_layer_n(&bm->ldata, l->head.data, i);
CustomData_data_copy_value(type, &min, block);
}
@@ -384,7 +384,7 @@ void bmo_collapse_exec(BMesh *bm, BMOperator *op)
BMW_FLAG_NOP, /* no need to use BMW_FLAG_TEST_HIDDEN, already marked data */
BMW_NIL_LAY);
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
if (!BMO_elem_flag_test(bm, e, EDGE_MARK))
continue;
@@ -444,8 +444,8 @@ static void bmo_collapsecon_do_layer(BMesh *bm, BMOperator *op, int layer)
BMW_FLAG_NOP, /* no need to use BMW_FLAG_TEST_HIDDEN, already marked data */
layer);
BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
if (BMO_elem_flag_test(bm, l->e, EDGE_MARK)) {
/* walk */
BLI_array_empty(blocks);
@@ -583,7 +583,7 @@ void bmo_automerge_exec(BMesh *bm, BMOperator *op)
* can be merged away into any other verts. Mark all other verts
* as VERT_KEEP. */
BMO_slot_buffer_flag_enable(bm, op, "verts", BM_VERT, VERT_IN);
BM_ITER (v, &viter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &viter, bm, BM_VERTS_OF_MESH) {
if (!BMO_elem_flag_test(bm, v, VERT_IN)) {
BMO_elem_flag_enable(bm, v, VERT_KEEP);
}

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

@@ -88,7 +88,7 @@ void bmo_vertex_slide_exec(BMesh *bm, BMOperator *op)
}
/* Make sure we get the correct edge. */
BM_ITER (edge, &iter, bm, BM_EDGES_OF_VERT, vertex) {
BM_ITER_ELEM (edge, &iter, vertex, BM_EDGES_OF_VERT) {
if (BMO_elem_flag_test(bm, edge, EDGE_MARK) && BM_vert_in_edge(edge, vertex)) {
slide_edge = edge;
break;

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

@@ -742,7 +742,7 @@ void bmo_esubd_exec(BMesh *bmesh, BMOperator *op)
BM_data_layer_add(bmesh, &bmesh->vdata, CD_SHAPEKEY);
skey = CustomData_number_of_layers(&bmesh->vdata, CD_SHAPEKEY) - 1;
BM_ITER (v, &viter, bmesh, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &viter, bmesh, BM_VERTS_OF_MESH) {
float *co = CustomData_bmesh_get_n(&bmesh->vdata, v->head.data, CD_SHAPEKEY, skey);
copy_v3_v3(co, v->co);
}
@@ -768,7 +768,7 @@ void bmo_esubd_exec(BMesh *bmesh, BMOperator *op)
BM_EDGE, EDGE_PERCENT);
BM_ITER (face, &fiter, bmesh, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (face, &fiter, bmesh, BM_FACES_OF_MESH) {
BMEdge *e1 = NULL, *e2 = NULL;
float vec1[3], vec2[3];
@@ -783,7 +783,7 @@ void bmo_esubd_exec(BMesh *bmesh, BMOperator *op)
matched = 0;
totesel = 0;
BM_ITER_INDEX (nl, &liter, bmesh, BM_LOOPS_OF_FACE, face, i) {
BM_ITER_ELEM_INDEX (nl, &liter, face, BM_LOOPS_OF_FACE, i) {
edges[i] = nl->e;
verts[i] = nl->v;
@@ -894,7 +894,7 @@ void bmo_esubd_exec(BMesh *bmesh, BMOperator *op)
}
/* copy original-geometry displacements to current coordinates */
BM_ITER (v, &viter, bmesh, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &viter, bmesh, BM_VERTS_OF_MESH) {
float *co = CustomData_bmesh_get_n(&bmesh->vdata, v->head.data, CD_SHAPEKEY, skey);
copy_v3_v3(v->co, co);
}
@@ -916,7 +916,7 @@ void bmo_esubd_exec(BMesh *bmesh, BMOperator *op)
BLI_array_empty(splits);
/* for case of two edges, connecting them shouldn't be too hard */
BM_ITER (l, &liter, bmesh, BM_LOOPS_OF_FACE, face) {
BM_ITER_ELEM (l, &liter, face, BM_LOOPS_OF_FACE) {
BLI_array_growone(loops);
loops[BLI_array_count(loops) - 1] = l;
}
@@ -1003,7 +1003,7 @@ void bmo_esubd_exec(BMesh *bmesh, BMOperator *op)
}
/* copy original-geometry displacements to current coordinates */
BM_ITER (v, &viter, bmesh, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &viter, bmesh, BM_VERTS_OF_MESH) {
float *co = CustomData_bmesh_get_n(&bmesh->vdata, v->head.data, CD_SHAPEKEY, skey);
copy_v3_v3(v->co, co);
}
@@ -1064,7 +1064,7 @@ void BM_mesh_esubdivideflag(Object *UNUSED(obedit), BMesh *bm, int flag, float s
BMEdge *e;
BMIter eiter;
BM_ITER (e, &eiter, bm, BM_EDGES_OF_VERT, ele) {
BM_ITER_ELEM (e, &eiter, ele, BM_EDGES_OF_VERT) {
if (!BM_elem_flag_test(e, BM_ELEM_SELECT) &&
BM_elem_flag_test(e->v1, BM_ELEM_SELECT) &&
BM_elem_flag_test(e->v2, BM_ELEM_SELECT))

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

@@ -103,7 +103,7 @@ void bmo_beautify_fill_exec(BMesh *bm, BMOperator *op)
while (!stop) {
stop = 1;
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
BMVert *v1, *v2, *v3, *v4;
if (!BM_edge_is_manifold(e) || BMO_elem_flag_test(bm, e, EDGE_MARK)) {
@@ -206,7 +206,7 @@ void bmo_triangle_fill_exec(BMesh *bm, BMOperator *op)
BMIter liter;
BMO_elem_flag_enable(bm, f, ELE_NEW);
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
if (!BMO_elem_flag_test(bm, l->e, EDGE_MARK)) {
BMO_elem_flag_enable(bm, l->e, ELE_NEW);
}

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

@@ -181,13 +181,13 @@ static void bmo_regionextend_extend(BMesh *bm, BMOperator *op, int usefaces)
if (!usefaces) {
BMO_ITER (v, &siter, bm, op, "geom", BM_VERT) {
BM_ITER (e, &eiter, bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e, &eiter, v, BM_EDGES_OF_VERT) {
if (!BMO_elem_flag_test(bm, e, SEL_ORIG))
break;
}
if (e) {
BM_ITER (e, &eiter, bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e, &eiter, v, BM_EDGES_OF_VERT) {
BMO_elem_flag_enable(bm, e, SEL_FLAG);
BMO_elem_flag_enable(bm, BM_edge_other_vert(e, v), SEL_FLAG);
}
@@ -200,8 +200,8 @@ static void bmo_regionextend_extend(BMesh *bm, BMOperator *op, int usefaces)
BMLoop *l;
BMO_ITER (f, &siter, bm, op, "geom", BM_FACE) {
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER (f2, &fiter, bm, BM_FACES_OF_EDGE, l->e) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
BM_ITER_ELEM (f2, &fiter, l->e, BM_FACES_OF_EDGE) {
if (!BMO_elem_flag_test(bm, f2, SEL_ORIG)) {
BMO_elem_flag_enable(bm, f2, SEL_FLAG);
}
@@ -220,7 +220,7 @@ static void bmo_regionextend_constrict(BMesh *bm, BMOperator *op, int usefaces)
if (!usefaces) {
BMO_ITER (v, &siter, bm, op, "geom", BM_VERT) {
BM_ITER (e, &eiter, bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e, &eiter, v, BM_EDGES_OF_VERT) {
if (!BMO_elem_flag_test(bm, e, SEL_ORIG))
break;
}
@@ -228,7 +228,7 @@ static void bmo_regionextend_constrict(BMesh *bm, BMOperator *op, int usefaces)
if (e) {
BMO_elem_flag_enable(bm, v, SEL_FLAG);
BM_ITER (e, &eiter, bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e, &eiter, v, BM_EDGES_OF_VERT) {
BMO_elem_flag_enable(bm, e, SEL_FLAG);
}
@@ -241,8 +241,8 @@ static void bmo_regionextend_constrict(BMesh *bm, BMOperator *op, int usefaces)
BMLoop *l;
BMO_ITER (f, &siter, bm, op, "geom", BM_FACE) {
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER (f2, &fiter, bm, BM_FACES_OF_EDGE, l->e) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
BM_ITER_ELEM (f2, &fiter, l->e, BM_FACES_OF_EDGE) {
if (!BMO_elem_flag_test(bm, f2, SEL_ORIG)) {
BMO_elem_flag_enable(bm, f, SEL_FLAG);
break;
@@ -358,8 +358,8 @@ void bmo_righthandfaces_exec(BMesh *bm, BMOperator *op)
f = fstack[i];
i--;
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER (l2, &liter2, bm, BM_LOOPS_OF_LOOP, l) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
BM_ITER_ELEM (l2, &liter2, l, BM_LOOPS_OF_LOOP) {
if (!BMO_elem_flag_test(bm, l2->f, FACE_FLAG) || l2 == l)
continue;
@@ -424,7 +424,7 @@ void bmo_vertexsmooth_exec(BMesh *bm, BMOperator *op)
co = cos[i];
j = 0;
BM_ITER (e, &iter, bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e, &iter, v, BM_EDGES_OF_VERT) {
co2 = BM_edge_other_vert(e, v)->co;
add_v3_v3v3(co, co, co2);
j += 1;
@@ -475,7 +475,7 @@ static float ngon_fake_area(BMesh *bm, BMFace *f)
BM_face_center_mean_calc(bm, f, c);
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
if (num_verts == 0) {
copy_v3_v3(v, l->v->co);
copy_v3_v3(sv, l->v->co);
@@ -545,7 +545,7 @@ void bmo_similarfaces_exec(BMesh *bm, BMOperator *op)
f_ext = (SimSel_FaceExt *)MEM_callocN(sizeof(SimSel_FaceExt) * num_total, "f_ext util.c");
/* loop through all the faces and fill the faces/indices structure */
BM_ITER (fm, &fm_iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (fm, &fm_iter, bm, BM_FACES_OF_MESH) {
f_ext[i].f = fm;
if (BMO_elem_flag_test(bm, fm, FACE_MARK)) {
indices[idx] = i;
@@ -673,7 +673,7 @@ static float edge_angle(BMesh *bm, BMEdge *e)
/* first edge faces, don't account for 3+ */
BM_ITER (f, &fiter, bm, BM_FACES_OF_EDGE, e) {
BM_ITER_ELEM (f, &fiter, e, BM_FACES_OF_EDGE) {
if (f_prev == NULL) {
f_prev = f;
}
@@ -733,7 +733,7 @@ void bmo_similaredges_exec(BMesh *bm, BMOperator *op)
e_ext = (SimSel_EdgeExt *)MEM_callocN(sizeof(SimSel_EdgeExt) * num_total, "e_ext util.c");
/* loop through all the edges and fill the edges/indices structure */
BM_ITER (e, &e_iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &e_iter, bm, BM_EDGES_OF_MESH) {
e_ext[i].e = e;
if (BMO_elem_flag_test(bm, e, EDGE_MARK)) {
indices[idx] = i;
@@ -897,7 +897,7 @@ void bmo_similarverts_exec(BMesh *bm, BMOperator *op)
v_ext = (SimSel_VertExt *)MEM_mallocN(sizeof(SimSel_VertExt) * num_total, "vertex extra");
/* loop through all the vertices and fill the vertices/indices structure */
BM_ITER (v, &v_iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &v_iter, bm, BM_VERTS_OF_MESH) {
v_ext[i].v = v;
if (BMO_elem_flag_test(bm, v, VERT_MARK)) {
indices[idx] = i;
@@ -993,7 +993,7 @@ void bmo_face_rotateuvs_exec(BMesh *bm, BMOperator *op)
float t_uv[2]; /* tmp uvs */
int n = 0;
BM_ITER (lf, &l_iter, bm, BM_LOOPS_OF_FACE, fs) {
BM_ITER_ELEM (lf, &l_iter, fs, BM_LOOPS_OF_FACE) {
/* current loop uv is the previous loop uv */
MLoopUV *luv = CustomData_bmesh_get(&bm->ldata, lf->head.data, CD_MLOOPUV);
if (n == 0) {
@@ -1017,7 +1017,7 @@ void bmo_face_rotateuvs_exec(BMesh *bm, BMOperator *op)
float t_uv[2]; /* current uvs */
int n = 0;
BM_ITER (lf, &l_iter, bm, BM_LOOPS_OF_FACE, fs) {
BM_ITER_ELEM (lf, &l_iter, fs, BM_LOOPS_OF_FACE) {
/* previous loop uv is the current loop uv */
luv = CustomData_bmesh_get(&bm->ldata, lf->head.data, CD_MLOOPUV);
if (n == 0) {
@@ -1058,7 +1058,7 @@ void bmo_face_reverseuvs_exec(BMesh *bm, BMOperator *op)
BLI_array_empty(uvs);
BLI_array_growitems(uvs, fs->len);
BM_ITER_INDEX (lf, &l_iter, bm, BM_LOOPS_OF_FACE, fs, i) {
BM_ITER_ELEM_INDEX (lf, &l_iter, fs, BM_LOOPS_OF_FACE, i) {
MLoopUV *luv = CustomData_bmesh_get(&bm->ldata, lf->head.data, CD_MLOOPUV);
/* current loop uv is the previous loop uv */
@@ -1067,7 +1067,7 @@ void bmo_face_reverseuvs_exec(BMesh *bm, BMOperator *op)
/* now that we have the uvs in the array, reverse! */
i = 0;
BM_ITER (lf, &l_iter, bm, BM_LOOPS_OF_FACE, fs) {
BM_ITER_ELEM (lf, &l_iter, fs, BM_LOOPS_OF_FACE) {
/* current loop uv is the previous loop uv */
MLoopUV *luv = CustomData_bmesh_get(&bm->ldata, lf->head.data, CD_MLOOPUV);
luv->uv[0] = uvs[(fs->len - i - 1)][0];
@@ -1102,7 +1102,7 @@ void bmo_rotatecolors_exec(BMesh *bm, BMOperator *op)
MLoopCol t_col; /* tmp color */
int n = 0;
BM_ITER (lf, &l_iter, bm, BM_LOOPS_OF_FACE, fs) {
BM_ITER_ELEM (lf, &l_iter, fs, BM_LOOPS_OF_FACE) {
/* current loop color is the previous loop color */
MLoopCol *luv = CustomData_bmesh_get(&bm->ldata, lf->head.data, CD_MLOOPCOL);
if (n == 0) {
@@ -1126,7 +1126,7 @@ void bmo_rotatecolors_exec(BMesh *bm, BMOperator *op)
MLoopCol t_col; /* current color */
int n = 0;
BM_ITER (lf, &l_iter, bm, BM_LOOPS_OF_FACE, fs) {
BM_ITER_ELEM (lf, &l_iter, fs, BM_LOOPS_OF_FACE) {
/* previous loop color is the current loop color */
lcol = CustomData_bmesh_get(&bm->ldata, lf->head.data, CD_MLOOPCOL);
if (n == 0) {
@@ -1164,7 +1164,7 @@ void bmo_face_reversecolors_exec(BMesh *bm, BMOperator *op)
int i = 0;
BLI_array_empty(cols);
BM_ITER (lf, &l_iter, bm, BM_LOOPS_OF_FACE, fs) {
BM_ITER_ELEM (lf, &l_iter, fs, BM_LOOPS_OF_FACE) {
MLoopCol *lcol = CustomData_bmesh_get(&bm->ldata, lf->head.data, CD_MLOOPCOL);
/* current loop uv is the previous loop color */
@@ -1175,7 +1175,7 @@ void bmo_face_reversecolors_exec(BMesh *bm, BMOperator *op)
/* now that we have the uvs in the array, reverse! */
i = 0;
BM_ITER (lf, &l_iter, bm, BM_LOOPS_OF_FACE, fs) {
BM_ITER_ELEM (lf, &l_iter, fs, BM_LOOPS_OF_FACE) {
/* current loop uv is the previous loop color */
MLoopCol *lcol = CustomData_bmesh_get(&bm->ldata, lf->head.data, CD_MLOOPCOL);
*lcol = cols[(fs->len - i - 1)];
@@ -1227,7 +1227,7 @@ void bmo_vertexshortestpath_exec(BMesh *bm, BMOperator *op)
/* iterate through all the mesh vertices */
/* loop through all the vertices and fill the vertices/indices structure */
i = 0;
BM_ITER (v, &v_iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &v_iter, bm, BM_VERTS_OF_MESH) {
vert_list[i].v = v;
vert_list[i].parent = NULL;
vert_list[i].weight = FLT_MAX;
@@ -1262,7 +1262,7 @@ void bmo_vertexshortestpath_exec(BMesh *bm, BMOperator *op)
v_weight = vert_list[BM_elem_index_get(v)].weight;
BM_ITER (e, &e_i, bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e, &e_i, v, BM_EDGES_OF_VERT) {
BMVert *u;
float e_weight = v_weight;

36
source/blender/bmesh/tools/BME_bevel.c
View File

@@ -661,7 +661,7 @@ static BMFace *BME_bevel_poly(BMesh *bm, BMFace *f, float value, int options, BM
zero_v3(up_vec);
/* find a good normal for this face (there's better ways, I'm sure) */
BM_ITER (l, &iter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l, &iter, f, BM_LOOPS_OF_FACE) {
BME_bevel_get_vec(vec1, l->v, l->next->v, td);
BME_bevel_get_vec(vec2, l->prev->v, l->v, td);
cross_v3_v3v3(vec3, vec2, vec1);
@@ -690,7 +690,7 @@ static BMFace *BME_bevel_poly(BMesh *bm, BMFace *f, float value, int options, BM
/* max pass */
if (value > 0.5f && max > 0) {
max = -1;
BM_ITER (l, &iter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l, &iter, f, BM_LOOPS_OF_FACE) {
if (BMO_elem_flag_test(bm, l->e, BME_BEVEL_BEVEL) || BMO_elem_flag_test(bm, l->e, BME_BEVEL_ORIG)) {
BME_bevel_get_vec(vec1, l->v, l->next->v, td);
vtd1 = BME_get_transdata(td, l->v);
@@ -788,13 +788,13 @@ static float UNUSED_FUNCTION(BME_bevel_get_angle_vert)(BMesh *bm, BMVert *v)
float angle_diff = 0.0f;
BM_ITER (l, &iter, bm, BM_LOOPS_OF_VERT, v) {
BM_ITER_ELEM (l, &iter, v, BM_LOOPS_OF_VERT) {
BM_loop_face_normal(l, n_tmp);
madd_v3_v3fl(n, n_tmp, BM_loop_face_angle(l));
}
normalize_v3(n);
BM_ITER (l, &iter, bm, BM_LOOPS_OF_VERT, v) {
BM_ITER_ELEM (l, &iter, v, BM_LOOPS_OF_VERT) {
/* could cache from before */
BM_loop_face_normal(l, n_tmp);
angle_diff += angle_normalized_v3v3(n, n_tmp) * (BM_loop_face_angle(l) * (float)(M_PI * 0.5));
@@ -848,7 +848,7 @@ static void bevel_init_verts(BMesh *bm, int options, float angle, BME_TransData_
// const float threshold = (options & BME_BEVEL_ANGLE) ? cosf(angle + 0.001) : 0.0f;
(void)angle;
BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
weight = 0.0f;
if (!BMO_elem_flag_test(bm, v, BME_BEVEL_NONMAN)) {
/* modifiers should not use selection */
@@ -889,7 +889,7 @@ static void bevel_init_edges(BMesh *bm, int options, float angle, BME_TransData_
BMIter iter;
const float threshold = (options & BME_BEVEL_ANGLE) ? cosf(angle + 0.001) : 0.0f;
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
weight = 0.0;
if (!BMO_elem_flag_test(bm, e, BME_BEVEL_NONMAN)) {
if (options & BME_BEVEL_SELECT) {
@@ -930,7 +930,7 @@ static void bevel_init_edges(BMesh *bm, int options, float angle, BME_TransData_
}
/* clean up edges with 2 faces that share more than one edg */
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
if (BMO_elem_flag_test(bm, e, BME_BEVEL_BEVEL)) {
count = BM_face_share_edge_count(e->l->f, e->l->radial_next->f);
if (count > 1) BMO_elem_flag_disable(bm, e, BME_BEVEL_BEVEL);
@@ -947,7 +947,7 @@ static BMesh *BME_bevel_initialize(BMesh *bm, int options, int UNUSED(defgrp_ind
int /* wire, */ len;
/* tag non-manifold geometr */
BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
BMO_elem_flag_enable(bm, v, BME_BEVEL_ORIG);
if (v->e) {
BME_assign_transdata(td, bm, v, v->co, v->co, NULL, NULL, 0, -1, -1, NULL);
@@ -965,7 +965,7 @@ static BMesh *BME_bevel_initialize(BMesh *bm, int options, int UNUSED(defgrp_ind
}
}
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
BMO_elem_flag_enable(bm, e, BME_BEVEL_ORIG);
if (!(BM_edge_is_boundary(e) || BM_edge_is_manifold(e))) {
BMO_elem_flag_enable(bm, e->v1, BME_BEVEL_NONMAN);
@@ -977,7 +977,7 @@ static BMesh *BME_bevel_initialize(BMesh *bm, int options, int UNUSED(defgrp_ind
}
}
BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
BMO_elem_flag_enable(bm, f, BME_BEVEL_ORIG);
}
@@ -1001,13 +1001,13 @@ static BMesh *BME_bevel_reinitialize(BMesh *bm)
BMFace *f;
BMIter iter;
BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
BMO_elem_flag_enable(bm, v, BME_BEVEL_ORIG);
}
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
BMO_elem_flag_enable(bm, e, BME_BEVEL_ORIG);
}
BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
BMO_elem_flag_enable(bm, f, BME_BEVEL_ORIG);
}
return bm;
@@ -1041,21 +1041,21 @@ static BMesh *BME_bevel_mesh(BMesh *bm, float value, int UNUSED(res), int option
/* unsigned int i, len; */
/* bevel poly */
BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
if (BMO_elem_flag_test(bm, f, BME_BEVEL_ORIG)) {
BME_bevel_poly(bm, f, value, options, td);
}
}
/* get rid of beveled edge */
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
if (BMO_elem_flag_test(bm, e, BME_BEVEL_BEVEL) && BMO_elem_flag_test(bm, e, BME_BEVEL_ORIG)) {
BM_faces_join_pair(bm, e->l->f, e->l->radial_next->f, e, TRUE);
}
}
/* link up corners and cli */
BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
if (BMO_elem_flag_test(bm, v, BME_BEVEL_ORIG) && BMO_elem_flag_test(bm, v, BME_BEVEL_BEVEL)) {
curedge = v->e;
do {
@@ -1075,7 +1075,7 @@ static BMesh *BME_bevel_mesh(BMesh *bm, float value, int UNUSED(res), int option
#ifdef DEBUG
/* Debug print, remov */
BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
if (f->len == 2) {
printf("%s: warning, 2 edge face\n", __func__);
}
@@ -1128,7 +1128,7 @@ BMesh *BME_bevel(BMEditMesh *em, float value, int res, int options, int defgrp_i
}
/* otherwise apply transforms */
BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
if ((vtd = BME_get_transdata(td, v))) {
if (vtd->max && (*vtd->max > 0 && value > *vtd->max)) {
d = *vtd->max;

4
source/blender/editors/mesh/editface.c
View File

@@ -814,7 +814,7 @@ void ED_mesh_mirrtopo_init(Mesh *me, const int ob_mode, MirrTopoStore_t *mesh_to
if (em) {
totedge = me->edit_btmesh->bm->totedge;
BM_ITER (eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (eed, &iter, em->bm, BM_EDGES_OF_MESH) {
topo_hash[BM_elem_index_get(eed->v1)]++;
topo_hash[BM_elem_index_get(eed->v2)]++;
}
@@ -835,7 +835,7 @@ void ED_mesh_mirrtopo_init(Mesh *me, const int ob_mode, MirrTopoStore_t *mesh_to
/* use the number of edges per vert to give verts unique topology IDs */
if (em) {
BM_ITER (eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (eed, &iter, em->bm, BM_EDGES_OF_MESH) {
topo_hash[BM_elem_index_get(eed->v1)] += topo_hash_prev[BM_elem_index_get(eed->v2)];
topo_hash[BM_elem_index_get(eed->v2)] += topo_hash_prev[BM_elem_index_get(eed->v1)];
}

2
source/blender/editors/mesh/editmesh_bvh.c
View File

@@ -125,7 +125,7 @@ BMBVHTree *BMBVH_NewBVH(BMEditMesh *em, int flag, Scene *scene, Object *obedit)
void *data[3];
tree->cos = MEM_callocN(sizeof(float) * 3 * em->bm->totvert, "bmbvh cos");
BM_ITER_INDEX (v, &iter, em->bm, BM_VERTS_OF_MESH, NULL, i) {
BM_ITER_MESH_INDEX (v, &iter, em->bm, BM_VERTS_OF_MESH, i) {
BM_elem_index_set(v, i); /* set_inline */
copy_v3_v3(tree->cos[i], v->co);
}

22
source/blender/editors/mesh/editmesh_knife.c
View File

@@ -557,7 +557,7 @@ static void knife_get_vert_faces(knifetool_opdata *kcd, KnifeVert *kfv, BMFace *
}
else if (kfv->v) {
BMesh *bm = kcd->em->bm;
BM_ITER (f, &bmiter, bm, BM_FACES_OF_VERT, kfv->v) {
BM_ITER_ELEM (f, &bmiter, kfv->v, BM_FACES_OF_VERT) {
knife_append_list(kcd, lst, f);
}
}
@@ -570,7 +570,7 @@ static void knife_get_edge_faces(knifetool_opdata *kcd, KnifeEdge *kfe, ListBase
if (kfe->e) {
BMesh *bm = kcd->em->bm;
BM_ITER (f, &bmiter, bm, BM_FACES_OF_EDGE, kfe->e) {
BM_ITER_ELEM (f, &bmiter, kfe->e, BM_FACES_OF_EDGE) {
knife_append_list(kcd, lst, f);
}
}
@@ -1706,7 +1706,7 @@ static void remerge_faces(knifetool_opdata *kcd)
BMO_op_finish(bm, &bmop);
BLI_smallhash_init(visit);
BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
BMIter eiter;
BMEdge *e;
BMFace *f2;
@@ -1727,14 +1727,14 @@ static void remerge_faces(knifetool_opdata *kcd)
BLI_array_append(faces, f2);
BM_ITER (e, &eiter, bm, BM_EDGES_OF_FACE, f2) {
BM_ITER_ELEM (e, &eiter, f2, BM_EDGES_OF_FACE) {
BMIter fiter;
BMFace *f3;
if (BMO_elem_flag_test(bm, e, BOUNDARY))
continue;
BM_ITER (f3, &fiter, bm, BM_FACES_OF_EDGE, e) {
BM_ITER_ELEM (f3, &fiter, e, BM_FACES_OF_EDGE) {
if (!BMO_elem_flag_test(bm, f3, FACE_NEW))
continue;
if (BLI_smallhash_haskey(visit, (intptr_t)f3))
@@ -1789,14 +1789,14 @@ static void knifenet_fill_faces(knifetool_opdata *kcd)
/* BMESH_TODO this should be valid now, leaving here until we can ensure this - campbell */
i = 0;
BM_ITER (f, &bmiter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &bmiter, bm, BM_FACES_OF_MESH) {
BM_elem_index_set(f, i); /* set_inline */
faces[i] = f;
i++;
}
bm->elem_index_dirty &= ~BM_FACE;
BM_ITER (e, &bmiter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &bmiter, bm, BM_EDGES_OF_MESH) {
BMO_elem_flag_enable(bm, e, BOUNDARY);
}
@@ -1984,7 +1984,7 @@ static void knifenet_fill_faces(knifetool_opdata *kcd)
bm->elem_index_dirty |= BM_FACE;
/* interpolate customdata */
BM_ITER (f, &bmiter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &bmiter, bm, BM_FACES_OF_MESH) {
BMLoop *l1;
BMFace *f2;
BMIter liter1;
@@ -1999,7 +1999,7 @@ static void knifenet_fill_faces(knifetool_opdata *kcd)
BM_elem_attrs_copy(bm, bm, f2, f);
BM_ITER (l1, &liter1, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l1, &liter1, f, BM_LOOPS_OF_FACE) {
BM_loop_interp_from_face(bm, l1, f2, TRUE, TRUE);
}
}
@@ -2306,7 +2306,7 @@ static int find_hole_chains(knifetool_opdata *kcd, ListBase *hole, BMFace *f, Li
}
j = 0;
BM_ITER (v, &iter, kcd->em->bm, BM_VERTS_OF_FACE, f) {
BM_ITER_ELEM (v, &iter, f, BM_VERTS_OF_FACE) {
fco[j] = BLI_memarena_alloc(kcd->arena, 2 * sizeof(float));
fco[j][0] = v->co[ax];
fco[j][1] = v->co[ay];
@@ -2413,7 +2413,7 @@ static int knife_edge_in_face(knifetool_opdata *kcd, KnifeEdge *kfe, BMFace *f)
l2 = NULL;
/* find out if v1 and v2, if set, are part of the face */
BM_ITER (l, &iter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l, &iter, f, BM_LOOPS_OF_FACE) {
if (v1 && l->v == v1)
l1 = l;
if (v2 && l->v == v2)

2
source/blender/editors/mesh/editmesh_loopcut.c
View File

@@ -145,7 +145,7 @@ static void edgering_find_order(BMEditMesh *em, BMEdge *lasteed, BMEdge *eed,
/* find correct order for v[1] */
if (!(BM_edge_in_face(l->f, eed) && BM_edge_in_face(l->f, lasteed))) {
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_LOOP, l) {
BM_ITER_ELEM (l, &liter, l, BM_LOOPS_OF_LOOP) {
if (BM_edge_in_face(l->f, eed) && BM_edge_in_face(l->f, lasteed))
break;
}

26
source/blender/editors/mesh/editmesh_rip.c
View File

@@ -158,7 +158,7 @@ static BMEdge *edbm_ripsel_edge_mark_step(BMesh *bm, BMVert *v, const int uid)
{
BMIter iter;
BMEdge *e;
BM_ITER (e, &iter, bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e, &iter, v, BM_EDGES_OF_VERT) {
if (IS_VISIT_POSSIBLE(e) && !IS_VISIT_DONE(e)) {
BMLoop *l_a, *l_b;
@@ -196,8 +196,8 @@ static EdgeLoopPair *edbm_ripsel_looptag_helper(BMesh *bm)
EdgeLoopPair *lp;
/* initialize loops with dummy invalid index values */
BM_ITER (f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
BM_elem_index_set(l, INVALID_UID);
}
}
@@ -213,7 +213,7 @@ static EdgeLoopPair *edbm_ripsel_looptag_helper(BMesh *bm)
BMEdge *e_last;
e_first = NULL;
BM_ITER (e, &eiter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) {
if (IS_VISIT_POSSIBLE(e) && !IS_VISIT_DONE(e)) {
e_first = e;
break;
@@ -290,7 +290,7 @@ static BMEdge *edbm_ripsel_edge_uid_step(BMesh *bm, BMEdge *e_orig, BMVert **v_p
BMVert *v = BM_edge_other_vert(e_orig, *v_prev);
const int uid_cmp = BM_elem_index_get(e_orig->l) - 1;
BM_ITER (e, &eiter, bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e, &eiter, v, BM_EDGES_OF_VERT) {
if (BM_elem_index_get(e->l) == uid_cmp) {
*v_prev = v;
return e;
@@ -374,7 +374,7 @@ static int edbm_rip_invoke(bContext *C, wmOperator *op, wmEvent *event)
ED_view3d_ob_project_mat_get(rv3d, obedit, projectMat);
/* BM_ELEM_SELECT --> BM_ELEM_TAG */
BM_ITER (e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
BM_elem_flag_set(e, BM_ELEM_TAG, BM_elem_flag_test(e, BM_ELEM_SELECT));
}
@@ -393,7 +393,7 @@ static int edbm_rip_invoke(bContext *C, wmOperator *op, wmEvent *event)
else {
ese.ele = NULL;
BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(v, BM_ELEM_SELECT))
break;
}
@@ -407,7 +407,7 @@ static int edbm_rip_invoke(bContext *C, wmOperator *op, wmEvent *event)
if (v->e) {
/* find closest edge to mouse cursor */
BM_ITER (e, &iter, bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e, &iter, v, BM_EDGES_OF_VERT) {
int is_boundary = BM_edge_is_boundary(e);
/* consider wire as boundary for this purpose,
* otherwise we can't a face away from a wire edge */
@@ -455,7 +455,7 @@ static int edbm_rip_invoke(bContext *C, wmOperator *op, wmEvent *event)
dist = FLT_MAX;
for (i = 0; i < vout_len; i++) {
BM_ITER (l, &iter, bm, BM_LOOPS_OF_VERT, vout[i]) {
BM_ITER_ELEM (l, &iter, vout[i], BM_LOOPS_OF_VERT) {
if (!BM_elem_flag_test(l->f, BM_ELEM_HIDDEN)) {
float l_mid_co[3];
BM_loop_face_tangent(l, l_mid_co);
@@ -534,10 +534,10 @@ static int edbm_rip_invoke(bContext *C, wmOperator *op, wmEvent *event)
}
else {
/* expand edge selection */
BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
e2 = NULL;
i = 0;
BM_ITER (e, &eiter, bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e, &eiter, v, BM_EDGES_OF_VERT) {
/* important to check selection rather then tag here
* else we get feedback loop */
if (BM_elem_flag_test(e, BM_ELEM_SELECT)) {
@@ -604,12 +604,12 @@ static int edbm_rip_invoke(bContext *C, wmOperator *op, wmEvent *event)
#else
dist = FLT_MAX;
BM_ITER (v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(v, BM_ELEM_SELECT)) {
/* disable by default, re-enable winner at end */
BM_elem_select_set(bm, v, FALSE);
BM_ITER (l, &liter, bm, BM_LOOPS_OF_VERT, v) {
BM_ITER_ELEM (l, &liter, v, BM_LOOPS_OF_VERT) {
/* calculate a point in the face, rather then calculate the middle,
* make a vector pointing between the 2 edges attached to this loop */
sub_v3_v3v3(l_prev_co, l->prev->v->co, l->v->co);

90
source/blender/editors/mesh/editmesh_select.c
View File

@@ -75,7 +75,7 @@ void EDBM_select_mirrored(Object *UNUSED(obedit), BMEditMesh *em, int extend)
BMVert *v1, *v2;
BMIter iter;
BM_ITER (v1, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v1, &iter, em->bm, BM_VERTS_OF_MESH) {
if (!BM_elem_flag_test(v1, BM_ELEM_SELECT) || BM_elem_flag_test(v1, BM_ELEM_HIDDEN)) {
BM_elem_flag_disable(v1, BM_ELEM_TAG);
}
@@ -89,7 +89,7 @@ void EDBM_select_mirrored(Object *UNUSED(obedit), BMEditMesh *em, int extend)
if (!extend)
EDBM_flag_disable_all(em, BM_ELEM_SELECT);
BM_ITER (v1, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v1, &iter, em->bm, BM_VERTS_OF_MESH) {
if (!BM_elem_flag_test(v1, BM_ELEM_TAG) || BM_elem_flag_test(v1, BM_ELEM_HIDDEN))
continue;
@@ -1221,7 +1221,7 @@ static int edgetag_shortest_path(Scene *scene, BMEditMesh *em, BMEdge *source, B
/* note, would pass BM_EDGE except we are looping over all edges anyway */
BM_mesh_elem_index_ensure(em->bm, BM_VERT /* | BM_EDGE */);
BM_ITER (e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(e, BM_ELEM_HIDDEN)) {
BLI_smallhash_insert(&visithash, (uintptr_t)e, NULL);
}
@@ -1239,7 +1239,7 @@ static int edgetag_shortest_path(Scene *scene, BMEditMesh *em, BMEdge *source, B
cost = MEM_mallocN(sizeof(*cost) * totedge, "SeamPathCost");
/* count edges, compute adjacent edges offsets and fill adjacent */
BM_ITER (e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
nedges[BM_elem_index_get(e->v1) + 1]++;
nedges[BM_elem_index_get(e->v2) + 1]++;
}
@@ -1252,7 +1252,7 @@ static int edgetag_shortest_path(Scene *scene, BMEditMesh *em, BMEdge *source, B
nedges[0] = nedges[1] = 0;
i = 0;
BM_ITER (e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
edges[nedges[BM_elem_index_get(e->v1) + 1]++] = i;
edges[nedges[BM_elem_index_get(e->v2) + 1]++] = i;
@@ -1643,7 +1643,7 @@ void EDBM_deselect_by_material(BMEditMesh *em, const short index, const short se
BMIter iter;
BMFace *efa;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (BM_elem_flag_test(efa, BM_ELEM_HIDDEN))
continue;
if (efa->mat_nr == index) {
@@ -1668,21 +1668,21 @@ void EDBM_select_swap(BMEditMesh *em) /* exported for UV */
BMFace *efa;
if (em->bm->selectmode & SCE_SELECT_VERTEX) {
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(eve, BM_ELEM_HIDDEN))
continue;
BM_elem_select_set(em->bm, eve, !BM_elem_flag_test(eve, BM_ELEM_SELECT));
}
}
else if (em->selectmode & SCE_SELECT_EDGE) {
BM_ITER (eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (eed, &iter, em->bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(eed, BM_ELEM_HIDDEN))
continue;
BM_elem_select_set(em->bm, eed, !BM_elem_flag_test(eed, BM_ELEM_SELECT));
}
}
else {
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (BM_elem_flag_test(efa, BM_ELEM_HIDDEN))
continue;
BM_elem_select_set(em->bm, efa, !BM_elem_flag_test(efa, BM_ELEM_SELECT));
@@ -1702,13 +1702,13 @@ int EDBM_select_interior_faces(BMEditMesh *em)
int ok;
int change = FALSE;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (BM_elem_flag_test(efa, BM_ELEM_HIDDEN))
continue;
ok = TRUE;
BM_ITER (eed, &eiter, bm, BM_EDGES_OF_FACE, efa) {
BM_ITER_ELEM (eed, &eiter, efa, BM_EDGES_OF_FACE) {
if (BM_edge_face_count(eed) < 3) {
ok = FALSE;
break;
@@ -1785,7 +1785,7 @@ static int edbm_select_linked_pick_invoke(bContext *C, wmOperator *op, wmEvent *
if (limit) {
/* hflag no-seam --> bmo-tag */
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
/* BMESH_TODO, don't use 'BM_ELEM_SELECT' here, its a HFLAG only! */
BMO_elem_flag_set(bm, e, BM_ELEM_SELECT, !BM_elem_flag_test(e, BM_ELEM_SEAM));
}
@@ -1870,13 +1870,13 @@ static int edbm_select_linked_exec(bContext *C, wmOperator *op)
if (em->selectmode == SCE_SELECT_FACE) {
BMFace *efa;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
BM_elem_flag_set(efa, BM_ELEM_TAG, (BM_elem_flag_test(efa, BM_ELEM_SELECT) &&
!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)));
}
if (limit) {
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
/* BMESH_TODO, don't use 'BM_ELEM_SELECT' here, its a HFLAG only! */
BMO_elem_flag_set(bm, e, BM_ELEM_SELECT, !BM_elem_flag_test(e, BM_ELEM_SEAM));
}
@@ -1887,7 +1887,7 @@ static int edbm_select_linked_exec(bContext *C, wmOperator *op)
BMW_FLAG_TEST_HIDDEN,
BMW_NIL_LAY);
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (BM_elem_flag_test(efa, BM_ELEM_TAG)) {
e = BMW_begin(&walker, efa);
for (; efa; efa = BMW_step(&walker)) {
@@ -1898,7 +1898,7 @@ static int edbm_select_linked_exec(bContext *C, wmOperator *op)
BMW_end(&walker);
}
else {
BM_ITER (v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(v, BM_ELEM_SELECT)) {
BM_elem_flag_enable(v, BM_ELEM_TAG);
}
@@ -1912,7 +1912,7 @@ static int edbm_select_linked_exec(bContext *C, wmOperator *op)
BMW_FLAG_TEST_HIDDEN,
BMW_NIL_LAY);
BM_ITER (v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(v, BM_ELEM_TAG)) {
e = BMW_begin(&walker, v);
for (; e; e = BMW_step(&walker)) {
@@ -2102,7 +2102,7 @@ static void deselect_nth_active(BMEditMesh *em, BMVert **r_eve, BMEdge **r_eed,
}
if (em->selectmode & SCE_SELECT_VERTEX) {
BM_ITER (v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(v, BM_ELEM_SELECT)) {
*r_eve = v;
return;
@@ -2110,7 +2110,7 @@ static void deselect_nth_active(BMEditMesh *em, BMVert **r_eve, BMEdge **r_eed,
}
}
else if (em->selectmode & SCE_SELECT_EDGE) {
BM_ITER (e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(e, BM_ELEM_SELECT)) {
*r_eed = e;
return;
@@ -2223,7 +2223,7 @@ static int edbm_select_sharp_edges_exec(bContext *C, wmOperator *op)
sharp = DEG2RADF(sharp);
BM_ITER (e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(e, BM_ELEM_HIDDEN) || !e->l)
continue;
@@ -2278,11 +2278,11 @@ static int edbm_select_linked_flat_faces_exec(bContext *C, wmOperator *op)
sharp = (sharp * M_PI) / 180.0;
BM_ITER (f, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, em->bm, BM_FACES_OF_MESH) {
BM_elem_flag_disable(f, BM_ELEM_TAG);
}
BM_ITER (f, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, em->bm, BM_FACES_OF_MESH) {
if (BM_elem_flag_test(f, BM_ELEM_HIDDEN) || !BM_elem_flag_test(f, BM_ELEM_SELECT) || BM_elem_flag_test(f, BM_ELEM_TAG))
continue;
@@ -2300,8 +2300,8 @@ static int edbm_select_linked_flat_faces_exec(bContext *C, wmOperator *op)
BM_elem_flag_enable(f, BM_ELEM_TAG);
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, f) {
BM_ITER (l2, &liter2, em->bm, BM_LOOPS_OF_LOOP, l) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
BM_ITER_ELEM (l2, &liter2, l, BM_LOOPS_OF_LOOP) {
float angle;
if (BM_elem_flag_test(l2->f, BM_ELEM_TAG) || BM_elem_flag_test(l2->f, BM_ELEM_HIDDEN))
@@ -2363,13 +2363,13 @@ static int edbm_select_non_manifold_exec(bContext *C, wmOperator *op)
return OPERATOR_CANCELLED;
}
BM_ITER (v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
if (!BM_elem_flag_test(v, BM_ELEM_HIDDEN) && !BM_vert_is_manifold(v)) {
BM_elem_select_set(em->bm, v, TRUE);
}
}
BM_ITER (e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
if (!BM_elem_flag_test(e, BM_ELEM_HIDDEN) && !BM_edge_is_manifold(e)) {
BM_elem_select_set(em->bm, e, TRUE);
}
@@ -2411,7 +2411,7 @@ static int edbm_select_random_exec(bContext *C, wmOperator *op)
EDBM_flag_disable_all(em, BM_ELEM_SELECT);
if (em->selectmode & SCE_SELECT_VERTEX) {
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN) && BLI_frand() < randfac) {
BM_elem_select_set(em->bm, eve, TRUE);
}
@@ -2419,7 +2419,7 @@ static int edbm_select_random_exec(bContext *C, wmOperator *op)
EDBM_selectmode_flush(em);
}
else if (em->selectmode & SCE_SELECT_EDGE) {
BM_ITER (eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (eed, &iter, em->bm, BM_EDGES_OF_MESH) {
if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN) && BLI_frand() < randfac) {
BM_elem_select_set(em->bm, eed, TRUE);
}
@@ -2427,7 +2427,7 @@ static int edbm_select_random_exec(bContext *C, wmOperator *op)
EDBM_selectmode_flush(em);
}
else {
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN) && BLI_frand() < randfac) {
BM_elem_select_set(em->bm, efa, TRUE);
}
@@ -2469,15 +2469,15 @@ static int edbm_select_next_loop_exec(bContext *C, wmOperator *UNUSED(op))
BMVert *v;
BMIter iter;
BM_ITER (v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
BM_elem_flag_disable(v, BM_ELEM_TAG);
}
BM_ITER (f, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, em->bm, BM_FACES_OF_MESH) {
BMLoop *l;
BMIter liter;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
if (BM_elem_flag_test(l->v, BM_ELEM_SELECT)) {
BM_elem_flag_enable(l->next->v, BM_ELEM_TAG);
BM_elem_select_set(em->bm, l->v, FALSE);
@@ -2485,7 +2485,7 @@ static int edbm_select_next_loop_exec(bContext *C, wmOperator *UNUSED(op))
}
}
BM_ITER (v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(v, BM_ELEM_TAG)) {
BM_elem_select_set(em->bm, v, TRUE);
}
@@ -2522,18 +2522,18 @@ static int edbm_region_to_loop_exec(bContext *C, wmOperator *UNUSED(op))
em_setup_viewcontext(C, &vc);
BM_ITER (e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
BM_elem_flag_disable(e, BM_ELEM_TAG);
}
BM_ITER (f, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, em->bm, BM_FACES_OF_MESH) {
BMLoop *l1, *l2;
BMIter liter1, liter2;
BM_ITER (l1, &liter1, em->bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l1, &liter1, f, BM_LOOPS_OF_FACE) {
int tot = 0, totsel = 0;
BM_ITER (l2, &liter2, em->bm, BM_LOOPS_OF_EDGE, l1->e) {
BM_ITER_ELEM (l2, &liter2, l1->e, BM_LOOPS_OF_EDGE) {
tot++;
totsel += BM_elem_flag_test(l2->f, BM_ELEM_SELECT) != 0;
}
@@ -2545,7 +2545,7 @@ static int edbm_region_to_loop_exec(bContext *C, wmOperator *UNUSED(op))
EDBM_flag_disable_all(em, BM_ELEM_SELECT);
BM_ITER (e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(e, BM_ELEM_TAG) && !BM_elem_flag_test(e, BM_ELEM_HIDDEN))
BM_edge_select_set(em->bm, e, TRUE);
}
@@ -2597,11 +2597,11 @@ static int loop_find_region(BMEditMesh *em, BMLoop *l, int flag,
f = BLI_array_pop(stack);
BLI_array_append(region, f);
BM_ITER (l1, &liter1, em->bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l1, &liter1, f, BM_LOOPS_OF_FACE) {
if (BM_elem_flag_test(l1->e, flag))
continue;
BM_ITER (l2, &liter2, em->bm, BM_LOOPS_OF_EDGE, l1->e) {
BM_ITER_ELEM (l2, &liter2, l1->e, BM_LOOPS_OF_EDGE) {
if (BLI_smallhash_haskey(fhash, (uintptr_t)l2->f))
continue;
@@ -2644,11 +2644,11 @@ static int loop_find_regions(BMEditMesh *em, int selbigger)
BLI_smallhash_init(&visithash);
BM_ITER (f, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, em->bm, BM_FACES_OF_MESH) {
BM_elem_flag_disable(f, BM_ELEM_TAG);
}
BM_ITER (e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(e, BM_ELEM_SELECT)) {
BLI_array_append(edges, e);
BM_elem_flag_enable(e, BM_ELEM_TAG);
@@ -2672,7 +2672,7 @@ static int loop_find_regions(BMEditMesh *em, int selbigger)
if (!BM_elem_flag_test(e, BM_ELEM_TAG))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_EDGE, e) {
BM_ITER_ELEM (l, &liter, e, BM_LOOPS_OF_EDGE) {
if (BLI_smallhash_haskey(&visithash, (uintptr_t)l->f))
continue;
@@ -2699,7 +2699,7 @@ static int loop_find_regions(BMEditMesh *em, int selbigger)
for (j = 0; j < tot; j++) {
BM_elem_flag_enable(region[j], BM_ELEM_TAG);
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, region[j]) {
BM_ITER_ELEM (l, &liter, region[j], BM_LOOPS_OF_FACE) {
BM_elem_flag_disable(l->e, BM_ELEM_TAG);
}
}
@@ -2735,7 +2735,7 @@ static int edbm_loop_to_region_exec(bContext *C, wmOperator *op)
EDBM_flag_disable_all(em, BM_ELEM_SELECT);
BM_ITER (f, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, em->bm, BM_FACES_OF_MESH) {
if (BM_elem_flag_test(f, BM_ELEM_TAG) && !BM_elem_flag_test(f, BM_ELEM_HIDDEN)) {
BM_face_select_set(em->bm, f, TRUE);
}

2
source/blender/editors/mesh/editmesh_slide.c
View File

@@ -504,7 +504,7 @@ static int vtx_slide_set_frame(VertexSlideOp *vso)
}
/* Iterate over edges of vertex and copy them */
BM_ITER_INDEX (edge, &iter, bm, BM_EDGES_OF_VERT, sel_vtx, idx) {
BM_ITER_ELEM_INDEX (edge, &iter, sel_vtx, BM_EDGES_OF_VERT, idx) {
curr_vert = BM_edge_other_vert(edge, sel_vtx);
if (curr_vert) {
BLI_array_growone(vtx_frame);

44
source/blender/editors/mesh/editmesh_tools.c
View File

@@ -159,7 +159,7 @@ void EMBM_project_snap_verts(bContext *C, ARegion *ar, Object *obedit, BMEditMes
BMIter iter;
BMVert *eve;
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
float mval[2], vec[3], no_dummy[3];
int dist_dummy;
@@ -194,7 +194,7 @@ static short edbm_extrude_face_indiv(BMEditMesh *em, wmOperator *op, const char
BM_elem_select_set(em->bm, f, TRUE);
/* set face vertex normals to face normal */
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
copy_v3_v3(l->v->no, f->no);
}
}
@@ -734,7 +734,7 @@ static int edbm_dupli_extrude_cursor_invoke(bContext *C, wmOperator *op, wmEvent
INIT_MINMAX(min, max);
BM_ITER (v1, &iter, vc.em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v1, &iter, vc.em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(v1, BM_ELEM_SELECT)) {
DO_MINMAX(v1->co, min, max);
done = 1;
@@ -756,7 +756,7 @@ static int edbm_dupli_extrude_cursor_invoke(bContext *C, wmOperator *op, wmEvent
/* check for edges that are half selected, use for rotation */
done = 0;
BM_ITER (eed, &iter, vc.em->bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (eed, &iter, vc.em->bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) {
float co1[3], co2[3];
mul_v3_m4v3(co1, vc.obedit->obmat, eed->v1->co);
@@ -1074,7 +1074,7 @@ static int edbm_mark_seam(bContext *C, wmOperator *op)
}
if (clear) {
BM_ITER (eed, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (eed, &iter, bm, BM_EDGES_OF_MESH) {
if (!BM_elem_flag_test(eed, BM_ELEM_SELECT) || BM_elem_flag_test(eed, BM_ELEM_HIDDEN))
continue;
@@ -1082,7 +1082,7 @@ static int edbm_mark_seam(bContext *C, wmOperator *op)
}
}
else {
BM_ITER (eed, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (eed, &iter, bm, BM_EDGES_OF_MESH) {
if (!BM_elem_flag_test(eed, BM_ELEM_SELECT) || BM_elem_flag_test(eed, BM_ELEM_HIDDEN))
continue;
BM_elem_flag_enable(eed, BM_ELEM_SEAM);
@@ -1128,7 +1128,7 @@ static int edbm_mark_sharp(bContext *C, wmOperator *op)
}
if (!clear) {
BM_ITER (eed, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (eed, &iter, bm, BM_EDGES_OF_MESH) {
if (!BM_elem_flag_test(eed, BM_ELEM_SELECT) || BM_elem_flag_test(eed, BM_ELEM_HIDDEN))
continue;
@@ -1136,7 +1136,7 @@ static int edbm_mark_sharp(bContext *C, wmOperator *op)
}
}
else {
BM_ITER (eed, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (eed, &iter, bm, BM_EDGES_OF_MESH) {
if (!BM_elem_flag_test(eed, BM_ELEM_SELECT) || BM_elem_flag_test(eed, BM_ELEM_HIDDEN))
continue;
@@ -1340,7 +1340,7 @@ static int edbm_edge_rotate_selected_exec(bContext *C, wmOperator *op)
}
/* first see if we have two adjacent faces */
BM_ITER (eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (eed, &iter, em->bm, BM_EDGES_OF_MESH) {
BM_elem_flag_disable(eed, BM_ELEM_TAG);
if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) {
BMFace *fa, *fb;
@@ -1580,7 +1580,7 @@ static void mesh_set_smooth_faces(BMEditMesh *em, short smooth)
if (em == NULL) return;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
BM_elem_flag_set(efa, BM_ELEM_SMOOTH, smooth);
}
@@ -1862,7 +1862,7 @@ static int merge_target(BMEditMesh *em, Scene *scene, View3D *v3d, Object *ob,
else {
float fac;
int i = 0;
BM_ITER (v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
if (!BM_elem_flag_test(v, BM_ELEM_SELECT))
continue;
add_v3_v3(cent, v->co);
@@ -2148,7 +2148,7 @@ static void shape_propagate(BMEditMesh *em, wmOperator *op)
return;
}
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
if (!BM_elem_flag_test(eve, BM_ELEM_SELECT) || BM_elem_flag_test(eve, BM_ELEM_HIDDEN))
continue;
@@ -2217,7 +2217,7 @@ static int edbm_blend_from_shape_exec(bContext *C, wmOperator *op)
if (totshape == 0 || shape < 0 || shape >= totshape)
return OPERATOR_CANCELLED;
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
if (!BM_elem_flag_test(eve, BM_ELEM_SELECT) || BM_elem_flag_test(eve, BM_ELEM_HIDDEN))
continue;
@@ -2322,7 +2322,7 @@ static int edbm_select_axis_exec(bContext *C, wmOperator *op)
else if (mode == 1)
value += limit;
BM_ITER (ev, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (ev, &iter, em->bm, BM_VERTS_OF_MESH) {
if (!BM_elem_flag_test(ev, BM_ELEM_HIDDEN)) {
switch (mode) {
case -1: /* aligned */
@@ -2796,7 +2796,7 @@ static int mesh_separate_selected(Main *bmain, Scene *scene, Base *editbase, wmO
EDBM_op_callf(em, wmop, "del geom=%hvef context=%i", BM_ELEM_SELECT, DEL_FACES);
/* clean up any loose edges */
BM_ITER (e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(e, BM_ELEM_HIDDEN))
continue;
@@ -2807,7 +2807,7 @@ static int mesh_separate_selected(Main *bmain, Scene *scene, Base *editbase, wmO
EDBM_op_callf(em, wmop, "del geom=%hvef context=%i", BM_ELEM_SELECT, DEL_EDGES);
/* clean up any loose verts */
BM_ITER (v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(v, BM_ELEM_HIDDEN))
continue;
@@ -2843,7 +2843,7 @@ static int mesh_separate_material(Main *bmain, Scene *scene, Base *editbase, wmO
const short mat_nr = f_cmp->mat_nr;
int tot = 0;
BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
if (f->mat_nr == mat_nr) {
BM_face_select_set(bm, f, TRUE);
tot++;
@@ -2887,7 +2887,7 @@ static int mesh_separate_loose(Main *bmain, Scene *scene, Base *editbase, wmOper
for (i = 0; i < max_iter; i++) {
/* Get a seed vertex to start the walk */
v_seed = NULL;
BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
v_seed = v;
break;
}
@@ -3661,7 +3661,7 @@ static void xsortvert_flag(bContext *C, int flag)
sortblock = MEM_callocN(sizeof(xvertsort) * totvert, "xsort sorted");
/* Stores unchanged verts, will be reused as final old2new vert mapping... */
unchangedblock = MEM_callocN(sizeof(int) * totvert, "xsort unchanged");
BM_ITER_INDEX (ve, &iter, em->bm, BM_VERTS_OF_MESH, NULL, i) {
BM_ITER_MESH_INDEX (ve, &iter, em->bm, BM_VERTS_OF_MESH, i) {
if (BM_elem_flag_test(ve, flag)) {
sortblock[i].org_idx = i;
sorted++;
@@ -4022,7 +4022,7 @@ static int edbm_noise_exec(bContext *C, wmOperator *op)
if (tex->type == TEX_STUCCI) {
float b2, vec[3];
float ofs = tex->turbul / 200.0;
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
b2 = BLI_hnoise(tex->noisesize, eve->co[0], eve->co[1], eve->co[2]);
if (tex->stype) ofs *= (b2 * b2);
@@ -4035,7 +4035,7 @@ static int edbm_noise_exec(bContext *C, wmOperator *op)
}
}
else {
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
float tin, dum;
externtex(ma->mtex[0], eve->co, &tin, &dum, &dum, &dum, &dum, 0);
@@ -4086,7 +4086,7 @@ static int edbm_bevel_exec(bContext *C, wmOperator *op)
BM_data_layer_add(em->bm, &em->bm->edata, CD_PROP_FLT);
li = CustomData_number_of_layers(&em->bm->edata, CD_PROP_FLT) - 1;
BM_ITER (eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (eed, &iter, em->bm, BM_EDGES_OF_MESH) {
float d = len_v3v3(eed->v1->co, eed->v2->co);
float *dv = CustomData_bmesh_get_n(&em->bm->edata, eed->head.data, CD_PROP_FLT, li);

24
source/blender/editors/mesh/editmesh_utils.c
View File

@@ -614,7 +614,7 @@ UvVertMap *EDBM_uv_vert_map_create(BMEditMesh *em, int selected, int do_face_idx
totuv = 0;
/* generate UvMapVert array */
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (!selected || ((!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) && BM_elem_flag_test(efa, BM_ELEM_SELECT)))
totuv += efa->len;
}
@@ -642,10 +642,10 @@ UvVertMap *EDBM_uv_vert_map_create(BMEditMesh *em, int selected, int do_face_idx
}
a = 0;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (!selected || ((!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) && BM_elem_flag_test(efa, BM_ELEM_SELECT))) {
i = 0;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
buf->tfindex = i;
buf->f = a;
buf->separate = 0;
@@ -663,7 +663,7 @@ UvVertMap *EDBM_uv_vert_map_create(BMEditMesh *em, int selected, int do_face_idx
/* sort individual uvs for each vert */
a = 0;
BM_ITER (ev, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (ev, &iter, em->bm, BM_VERTS_OF_MESH) {
UvMapVert *newvlist = NULL, *vlist = vmap->vert[a];
UvMapVert *iterv, *v, *lastv, *next;
float *uv, *uv2, uvdiff[2];
@@ -762,7 +762,7 @@ UvElementMap *EDBM_uv_element_map_create(BMEditMesh *em, int selected, int do_is
}
/* generate UvElement array */
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (!selected || ((!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) && BM_elem_flag_test(efa, BM_ELEM_SELECT)))
totuv += efa->len;
}
@@ -787,10 +787,10 @@ UvElementMap *EDBM_uv_element_map_create(BMEditMesh *em, int selected, int do_is
}
j = 0;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
island_number[j++] = INVALID_ISLAND;
if (!selected || ((!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) && BM_elem_flag_test(efa, BM_ELEM_SELECT))) {
BM_ITER_INDEX (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa, i) {
BM_ITER_ELEM_INDEX (l, &liter, efa, BM_LOOPS_OF_FACE, i) {
buf->l = l;
buf->face = efa;
buf->separate = 0;
@@ -807,7 +807,7 @@ UvElementMap *EDBM_uv_element_map_create(BMEditMesh *em, int selected, int do_is
/* sort individual uvs for each vert */
i = 0;
BM_ITER (ev, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (ev, &iter, em->bm, BM_VERTS_OF_MESH) {
UvElement *newvlist = NULL, *vlist = element_map->vert[i];
UvElement *iterv, *v, *lastv, *next;
float *uv, *uv2, uvdiff[2];
@@ -871,7 +871,7 @@ UvElementMap *EDBM_uv_element_map_create(BMEditMesh *em, int selected, int do_is
while (stacksize > 0) {
efa = stack[--stacksize];
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
UvElement *element, *initelement = element_map->vert[BM_elem_index_get(l->v)];
for (element = initelement; element; element = element->next) {
@@ -1019,7 +1019,7 @@ static BMVert *cache_mirr_intptr_as_bmvert(intptr_t *index_lookup, int index)
* EDBM_verts_mirror_cache_begin(em);
* ...
* ...
* BM_ITER (v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
* BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
* mirrorv = EDBM_verts_mirror_get(em, v);
* }
* ...
@@ -1071,7 +1071,7 @@ void EDBM_verts_mirror_cache_begin(BMEditMesh *em, const short use_select)
tree = BMBVH_NewBVH(em, 0, NULL, NULL);
}
BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
/* temporary for testing, check for selection */
if (use_select && !BM_elem_flag_test(v, BM_ELEM_SELECT)) {
@@ -1159,7 +1159,7 @@ void EDBM_verts_mirror_apply(BMEditMesh *em, const int sel_from, const int sel_t
BLI_assert(em->vert_index != NULL);
BM_ITER (v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(v, BM_ELEM_SELECT) == sel_from) {
BMVert *mirr = EDBM_verts_mirror_get(em, v);
if (mirr) {

10
source/blender/editors/mesh/mesh_data.c
View File

@@ -199,7 +199,7 @@ static void editmesh_face_copy_customdata(BMEditMesh *em, int type, int index)
const int n = CustomData_get_active_layer(pdata, type);
/* ensure all current elements follow new customdata layout */
BM_ITER (efa, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
void *data = CustomData_bmesh_get_n(pdata, efa->head.data, type, n);
CustomData_bmesh_set_n(pdata, efa->head.data, type, index, data);
}
@@ -217,8 +217,8 @@ static void editmesh_loop_copy_customdata(BMEditMesh *em, int type, int index)
const int n = CustomData_get_active_layer(ldata, type);
/* ensure all current elements follow new customdata layout */
BM_ITER (efa, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER (loop, &liter, bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
BM_ITER_ELEM (loop, &liter, efa, BM_LOOPS_OF_FACE) {
void *data = CustomData_bmesh_get_n(ldata, loop->head.data, type, n);
CustomData_bmesh_set_n(ldata, loop->head.data, type, index, data);
}
@@ -245,12 +245,12 @@ int ED_mesh_uv_loop_reset_ex(struct bContext *C, struct Mesh *me, const int laye
BLI_assert(CustomData_has_layer(&em->bm->ldata, CD_MLOOPUV));
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_SELECT))
continue;
i = 0;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get_n(&em->bm->ldata, l->head.data, CD_MLOOPUV, layernum);
BLI_array_append(uvs, luv->uv);
i++;

6
source/blender/editors/mesh/mesh_navmesh.c
View File

@@ -500,7 +500,7 @@ static int navmesh_face_copy_exec(bContext *C, wmOperator *op)
if (targetPolyIdx > 0) {
/* set target poly idx to other selected faces */
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (BM_elem_flag_test(efa, BM_ELEM_SELECT) && efa != efa_act) {
int *recastDataBlock = (int *)CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_RECAST);
*recastDataBlock = targetPolyIdx;
@@ -549,7 +549,7 @@ static int findFreeNavPolyIndex(BMEditMesh *em)
int i, idx = em->bm->totface - 1, freeIdx = 1;
/*XXX this originally went last to first, but that isn't possible anymore*/
BM_ITER (ef, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (ef, &iter, em->bm, BM_FACES_OF_MESH) {
int polyIdx = *(int *)CustomData_bmesh_get(&em->bm->pdata, ef->head.data, CD_RECAST);
indices[idx] = polyIdx;
idx--;
@@ -585,7 +585,7 @@ static int navmesh_face_add_exec(bContext *C, wmOperator *UNUSED(op))
/* set target poly idx to selected faces */
/*XXX this originally went last to first, but that isn't possible anymore*/
BM_ITER (ef, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (ef, &iter, em->bm, BM_FACES_OF_MESH) {
if (BM_elem_flag_test(ef, BM_ELEM_SELECT)) {
int *recastDataBlock = (int *)CustomData_bmesh_get(&em->bm->pdata, ef->head.data, CD_RECAST);
*recastDataBlock = targetPolyIdx;

10
source/blender/editors/mesh/meshtools.c
View File

@@ -803,7 +803,7 @@ intptr_t mesh_octree_table(Object *ob, BMEditMesh *em, float *co, char mode)
BMIter iter;
BMVert *eve;
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
DO_MINMAX(eve->co, min, max);
}
}
@@ -840,7 +840,7 @@ intptr_t mesh_octree_table(Object *ob, BMEditMesh *em, float *co, char mode)
BMVert *eve;
BMIter iter;
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
mesh_octree_add_nodes(MeshOctree.table, eve->co, MeshOctree.offs, MeshOctree.div, (intptr_t)(eve));
}
}
@@ -953,7 +953,7 @@ static BMVert *editbmesh_get_x_mirror_vert_topo(Object *ob, struct BMEditMesh *e
BMVert *v;
index = 0;
BM_ITER (v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
if (v == eve)
break;
index++;
@@ -1015,14 +1015,14 @@ static float *editmesh_get_mirror_uv(BMEditMesh *em, int axis, float *uv, float
BMIter iter;
BMFace *efa;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
poly_uv_center(em, efa, cent);
if ( (fabs(cent[0] - cent_vec[0]) < 0.001) && (fabs(cent[1] - cent_vec[1]) < 0.001) ) {
BMIter liter;
BMLoop *l;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
MLoopUV *luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
if ( (fabs(luv->uv[0] - vec[0]) < 0.001) && (fabs(luv->uv[1] - vec[1]) < 0.001) ) {
return luv->uv;

8
source/blender/editors/object/object_hook.c
View File

@@ -78,7 +78,7 @@ static int return_editmesh_indexar(BMEditMesh *em, int *tot, int **indexar, floa
BMIter iter;
int *index, nr, totvert=0;
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) totvert++;
}
if (totvert==0) return 0;
@@ -88,7 +88,7 @@ static int return_editmesh_indexar(BMEditMesh *em, int *tot, int **indexar, floa
nr= 0;
zero_v3(cent);
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
*index= nr; index++;
add_v3_v3(cent, eve->co);
@@ -114,7 +114,7 @@ static int return_editmesh_vgroup(Object *obedit, BMEditMesh *em, char *name, fl
BMIter iter;
/* find the vertices */
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
dvert= CustomData_bmesh_get(&em->bm->vdata, eve->head.data, CD_MDEFORMVERT);
if (dvert) {
@@ -146,7 +146,7 @@ static void select_editbmesh_hook(Object *ob, HookModifierData *hmd)
if (hmd->indexar == NULL)
return;
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
if (nr==hmd->indexar[index]) {
BM_elem_select_set(em->bm, eve, TRUE);
if (index < hmd->totindex-1) index++;

2
source/blender/editors/object/object_relations.c
View File

@@ -137,7 +137,7 @@ static int vertex_parent_set_exec(bContext *C, wmOperator *op)
* so re-create it here */
makeDerivedMesh(scene, obedit, em, CD_MASK_BAREMESH, 0);
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
if (v1==0) v1= nr;
else if (v2==0) v2= nr;

4
source/blender/editors/object/object_transform.c
View File

@@ -687,7 +687,7 @@ static int object_origin_set_exec(bContext *C, wmOperator *op)
mul_m4_v3(obedit->imat, cent);
}
else {
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
if (around==V3D_CENTROID) {
total++;
add_v3_v3(cent, eve->co);
@@ -700,7 +700,7 @@ static int object_origin_set_exec(bContext *C, wmOperator *op)
}
}
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
sub_v3_v3(eve->co, cent);
}

20
source/blender/editors/object/object_vgroup.c
View File

@@ -206,14 +206,14 @@ static int ED_vgroup_give_parray(ID *id, MDeformVert ***dvert_arr, int *dvert_to
i = 0;
if (use_vert_sel) {
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
(*dvert_arr)[i] = BM_elem_flag_test(eve, BM_ELEM_SELECT) ?
CustomData_bmesh_get(&em->bm->vdata, eve->head.data, CD_MDEFORMVERT) : NULL;
i++;
}
}
else {
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
(*dvert_arr)[i] = CustomData_bmesh_get(&em->bm->vdata, eve->head.data, CD_MDEFORMVERT);
i++;
}
@@ -593,7 +593,7 @@ static void vgroup_select_verts(Object *ob, int select)
BMIter iter;
BMVert *eve;
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) {
dv= CustomData_bmesh_get(&em->bm->vdata, eve->head.data, CD_MDEFORMVERT);
if (defvert_find_index(dv, def_nr)) {
@@ -1296,7 +1296,7 @@ static void vgroup_blend(Object *ob, const float fac)
vg_users = MEM_callocN(sizeof(int) * dvert_tot, "vgroup_blend_i");
if (bm) {
BM_ITER (eed, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (eed, &iter, bm, BM_EDGES_OF_MESH) {
sel1 = BM_elem_flag_test(eed->v1, BM_ELEM_SELECT);
sel2 = BM_elem_flag_test(eed->v2, BM_ELEM_SELECT);
@@ -1322,7 +1322,7 @@ static void vgroup_blend(Object *ob, const float fac)
}
}
BM_ITER_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, NULL, i) {
BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, i) {
if (BM_elem_flag_test(eve, BM_ELEM_SELECT) && vg_users[i] > 0) {
dv = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_MDEFORMVERT);
@@ -1571,7 +1571,7 @@ void ED_vgroup_mirror(Object *ob, const short mirror_weights, const short flip_v
EDBM_verts_mirror_cache_begin(em, FALSE);
/* Go through the list of editverts and assign them */
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
if ((eve_mirr= EDBM_verts_mirror_get(em, eve))) {
sel= BM_elem_flag_test(eve, BM_ELEM_SELECT);
sel_mirr= BM_elem_flag_test(eve_mirr, BM_ELEM_SELECT);
@@ -1796,7 +1796,7 @@ static void vgroup_active_remove_verts(Object *ob, const int allverts, bDeformGr
BMVert *eve;
BMIter iter;
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
dv= CustomData_bmesh_get(&em->bm->vdata, eve->head.data, CD_MDEFORMVERT);
if (dv && dv->dw && (allverts || BM_elem_flag_test(eve, BM_ELEM_SELECT))) {
@@ -1866,7 +1866,7 @@ static void vgroup_delete_edit_mode(Object *ob, bDeformGroup *dg)
BMVert *eve;
MDeformVert *dvert;
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
dvert= CustomData_bmesh_get(&em->bm->vdata, eve->head.data, CD_MDEFORMVERT);
if (dvert)
@@ -1998,7 +1998,7 @@ static void vgroup_assign_verts(Object *ob, const float weight)
BM_data_layer_add(em->bm, &em->bm->vdata, CD_MDEFORMVERT);
/* Go through the list of editverts and assign them */
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
MDeformWeight *dw;
dv= CustomData_bmesh_get(&em->bm->vdata, eve->head.data, CD_MDEFORMVERT); /* can be NULL */
@@ -2855,7 +2855,7 @@ static int vgroup_do_remap(Object *ob, char *name_array, wmOperator *op)
BMIter iter;
BMVert *eve;
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
dvert= CustomData_bmesh_get(&em->bm->vdata, eve->head.data, CD_MDEFORMVERT);
if (dvert && dvert->totweight) {
defvert_remap(dvert, sort_map, defbase_tot);

2
source/blender/editors/render/render_shading.c
View File

@@ -170,7 +170,7 @@ static int material_slot_assign_exec(bContext *C, wmOperator *UNUSED(op))
BMIter iter;
if (em) {
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (BM_elem_flag_test(efa, BM_ELEM_SELECT))
efa->mat_nr = ob->actcol - 1;
}

4
source/blender/editors/sculpt_paint/sculpt_uv.c
View File

@@ -594,8 +594,8 @@ static UvSculptData *uv_sculpt_stroke_init(bContext *C, wmOperator *op, wmEvent
/* Now, on to generate our uv connectivity data */
counter = 0;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
int offset1, itmp1 = uv_element_offset_from_face_get(data->elementMap, efa, l, island_index, do_island_optimization);
int offset2, itmp2 = uv_element_offset_from_face_get(data->elementMap, efa, l->next, island_index, do_island_optimization);

6
source/blender/editors/space_view3d/drawobject.c
View File

@@ -2957,7 +2957,7 @@ static void draw_em_indices(BMEditMesh *em)
i = 0;
if (em->selectmode & SCE_SELECT_VERTEX) {
UI_GetThemeColor3ubv(TH_DRAWEXTRA_FACEANG, col);
BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(v, BM_ELEM_SELECT)) {
sprintf(numstr, "%d", i);
view3d_cached_text_draw_add(v->co, numstr, 0, txt_flag, col);
@@ -2969,7 +2969,7 @@ static void draw_em_indices(BMEditMesh *em)
if (em->selectmode & SCE_SELECT_EDGE) {
i = 0;
UI_GetThemeColor3ubv(TH_DRAWEXTRA_EDGELEN, col);
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(e, BM_ELEM_SELECT)) {
sprintf(numstr, "%d", i);
mid_v3_v3v3(pos, e->v1->co, e->v2->co);
@@ -2982,7 +2982,7 @@ static void draw_em_indices(BMEditMesh *em)
if (em->selectmode & SCE_SELECT_FACE) {
i = 0;
UI_GetThemeColor3ubv(TH_DRAWEXTRA_FACEAREA, col);
BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
if (BM_elem_flag_test(f, BM_ELEM_SELECT)) {
BM_face_center_mean_calc(bm, f, pos);
sprintf(numstr, "%d", i);

20
source/blender/editors/space_view3d/view3d_buttons.c
View File

@@ -157,7 +157,7 @@ static void v3d_editvertex_buts(uiLayout *layout, View3D *v3d, Object *ob, float
BMEdge *eed;
BMIter iter;
BM_ITER (eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
evedef = eve;
tot++;
@@ -165,7 +165,7 @@ static void v3d_editvertex_buts(uiLayout *layout, View3D *v3d, Object *ob, float
}
}
BM_ITER (eed, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (eed, &iter, bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) {
float *f;
@@ -404,7 +404,7 @@ static void v3d_editvertex_buts(uiLayout *layout, View3D *v3d, Object *ob, float
if (len_v3(median) > 0.000001f) {
BM_ITER (eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
add_v3_v3(eve->co, median);
}
@@ -418,7 +418,7 @@ static void v3d_editvertex_buts(uiLayout *layout, View3D *v3d, Object *ob, float
const float sca = compute_scale_factor(ve_median[3], median[3]);
if (ELEM(sca, 0.0f, 1.0f)) {
BM_ITER (eed, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (eed, &iter, bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) {
float *crease = (float *)CustomData_bmesh_get(&bm->edata, eed->head.data, CD_CREASE);
if (crease) {
@@ -428,7 +428,7 @@ static void v3d_editvertex_buts(uiLayout *layout, View3D *v3d, Object *ob, float
}
}
else if (sca > 0.0f) {
BM_ITER (eed, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (eed, &iter, bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(eed, BM_ELEM_SELECT) && !BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
float *crease = (float *)CustomData_bmesh_get(&bm->edata, eed->head.data, CD_CREASE);
if (crease) {
@@ -439,7 +439,7 @@ static void v3d_editvertex_buts(uiLayout *layout, View3D *v3d, Object *ob, float
}
}
else {
BM_ITER (eed, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (eed, &iter, bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(eed, BM_ELEM_SELECT) && !BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
float *crease = (float *)CustomData_bmesh_get(&bm->edata, eed->head.data, CD_CREASE);
if (crease) {
@@ -456,7 +456,7 @@ static void v3d_editvertex_buts(uiLayout *layout, View3D *v3d, Object *ob, float
const float sca = compute_scale_factor(ve_median[6], median[6]);
if (ELEM(sca, 0.0f, 1.0f)) {
BM_ITER (eed, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (eed, &iter, bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) {
float *bweight = (float *)CustomData_bmesh_get(&bm->edata, eed->head.data, CD_BWEIGHT);
if (bweight) {
@@ -466,7 +466,7 @@ static void v3d_editvertex_buts(uiLayout *layout, View3D *v3d, Object *ob, float
}
}
else if (sca > 0.0f) {
BM_ITER (eed, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (eed, &iter, bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(eed, BM_ELEM_SELECT) && !BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
float *bweight = (float *)CustomData_bmesh_get(&bm->edata, eed->head.data, CD_BWEIGHT);
if (bweight) {
@@ -477,7 +477,7 @@ static void v3d_editvertex_buts(uiLayout *layout, View3D *v3d, Object *ob, float
}
}
else {
BM_ITER (eed, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (eed, &iter, bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(eed, BM_ELEM_SELECT) && !BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
float *bweight = (float *)CustomData_bmesh_get(&bm->edata, eed->head.data, CD_BWEIGHT);
if (bweight) {
@@ -678,7 +678,7 @@ static void vgroup_copy_active_to_sel(Object *ob)
MDeformVert *dvert;
int index = 0;
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(eve, BM_ELEM_SELECT) && eve != eve_act) {
dvert = CustomData_bmesh_get(&em->bm->vdata, eve->head.data, CD_MDEFORMVERT);
if (dvert) {

18
source/blender/editors/space_view3d/view3d_snap.c
View File

@@ -242,7 +242,7 @@ static void make_trans_verts(Object *obedit, float *min, float *max, int mode)
// transform now requires awareness for select mode, so we tag the f1 flags in verts
tottrans = 0;
if (em->selectmode & SCE_SELECT_VERTEX) {
BM_ITER (eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN) && BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
BM_elem_index_set(eve, 1); /* set_dirty! */
tottrans++;
@@ -253,40 +253,40 @@ static void make_trans_verts(Object *obedit, float *min, float *max, int mode)
else if (em->selectmode & SCE_SELECT_EDGE) {
BMEdge *eed;
BM_ITER (eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
BM_elem_index_set(eve, 0); /* set_dirty! */
}
BM_ITER (eed, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (eed, &iter, bm, BM_EDGES_OF_MESH) {
if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN) && BM_elem_flag_test(eed, BM_ELEM_SELECT)) {
BM_elem_index_set(eed->v1, 1); /* set_dirty! */
BM_elem_index_set(eed->v2, 1); /* set_dirty! */
}
}
BM_ITER (eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
if (BM_elem_index_get(eve)) tottrans++;
}
}
else {
BMFace *efa;
BM_ITER (eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
BM_elem_index_set(eve, 0); /* set_dirty! */
}
BM_ITER (efa, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN) && BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
BMIter liter;
BMLoop *l;
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
BM_elem_index_set(l->v, 1); /* set_dirty! */
}
}
}
BM_ITER (eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
if (BM_elem_index_get(eve)) tottrans++;
}
}
@@ -298,7 +298,7 @@ static void make_trans_verts(Object *obedit, float *min, float *max, int mode)
tv = transvmain = MEM_callocN(tottrans * sizeof(TransVert), "maketransverts");
a = 0;
BM_ITER (eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
if (BM_elem_index_get(eve)) {
BM_elem_index_set(eve, a); /* set_dirty! */
copy_v3_v3(tv->oldloc, eve->co);

24
source/blender/editors/transform/transform.c
View File

@@ -4318,7 +4318,7 @@ static BMEdge *get_other_edge(BMesh *bm, BMVert *v, BMEdge *e)
BMIter iter;
BMEdge *e2;
BM_ITER (e2, &iter, bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e2, &iter, v, BM_EDGES_OF_VERT) {
if (BM_elem_flag_test(e2, BM_ELEM_SELECT) && e2 != e)
return e2;
}
@@ -4419,10 +4419,10 @@ static int createSlideVerts(TransInfo *t)
BLI_smallhash_init(&table);
/*ensure valid selection*/
BM_ITER (v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(v, BM_ELEM_SELECT)) {
numsel = 0;
BM_ITER (e, &iter2, em->bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e, &iter2, v, BM_EDGES_OF_VERT) {
if (BM_elem_flag_test(e, BM_ELEM_SELECT)) {
/* BMESH_TODO: this is probably very evil,
* set v->e to a selected edge*/
@@ -4440,7 +4440,7 @@ static int createSlideVerts(TransInfo *t)
}
}
BM_ITER (e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(e, BM_ELEM_SELECT)) {
if (!BM_edge_is_manifold(e)) {
MEM_freeN(sld);
@@ -4451,7 +4451,7 @@ static int createSlideVerts(TransInfo *t)
}
j = 0;
BM_ITER (v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(v, BM_ELEM_SELECT)) {
BM_elem_flag_enable(v, BM_ELEM_TAG);
BLI_smallhash_insert(&table, (uintptr_t)v, SET_INT_IN_POINTER(j));
@@ -4473,7 +4473,7 @@ static int createSlideVerts(TransInfo *t)
j = 0;
while (1) {
v = NULL;
BM_ITER (v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(v, BM_ELEM_TAG))
break;
@@ -4591,7 +4591,7 @@ static int createSlideVerts(TransInfo *t)
/* size = 50.0; */ /* UNUSED */
zero_v3(lastvec); zero_v3(dir);
/* ee = le = NULL; */ /* UNUSED */
BM_ITER (e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(e, BM_ELEM_SELECT)) {
BMIter iter2;
BMEdge *e2;
@@ -4602,7 +4602,7 @@ static int createSlideVerts(TransInfo *t)
dis2 = -1.0f;
for (i=0; i<2; i++) {
v = i?e->v1:e->v2;
BM_ITER (e2, &iter2, em->bm, BM_EDGES_OF_VERT, v) {
BM_ITER_ELEM (e2, &iter2, v, BM_EDGES_OF_VERT) {
if (BM_elem_flag_test(e2, BM_ELEM_SELECT))
continue;
@@ -4648,14 +4648,14 @@ static int createSlideVerts(TransInfo *t)
BMFace *f;
BMLoop *l;
BM_ITER (f, &fiter, em->bm, BM_FACES_OF_VERT, tempsv->v) {
BM_ITER_ELEM (f, &fiter, tempsv->v, BM_FACES_OF_VERT) {
if (!BLI_smallhash_haskey(&sld->origfaces, (uintptr_t)f)) {
BMFace *copyf = BM_face_copy(em->bm, f, TRUE, TRUE);
BM_elem_select_set(em->bm, copyf, FALSE);
BM_elem_flag_enable(copyf, BM_ELEM_HIDDEN);
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, copyf) {
BM_ITER_ELEM (l, &liter, copyf, BM_LOOPS_OF_FACE) {
BM_elem_select_set(em->bm, l->v, FALSE);
BM_elem_flag_enable(l->v, BM_ELEM_HIDDEN);
BM_elem_select_set(em->bm, l->e, FALSE);
@@ -4720,7 +4720,7 @@ void projectSVData(TransInfo *t, int final)
BMIter fiter;
BMFace *f;
BM_ITER (f, &fiter, em->bm, BM_FACES_OF_VERT, tempsv->v) {
BM_ITER_ELEM (f, &fiter, tempsv->v, BM_FACES_OF_VERT) {
BMIter liter2;
BMFace *copyf, *copyf2;
BMLoop *l2;
@@ -4740,7 +4740,7 @@ void projectSVData(TransInfo *t, int final)
copyf2 = BLI_smallhash_lookup(&sld->origfaces, (uintptr_t)f);
/* project onto copied projection face */
BM_ITER (l2, &liter2, em->bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l2, &liter2, f, BM_LOOPS_OF_FACE) {
copyf = copyf2;
if (BM_elem_flag_test(l2->e, BM_ELEM_SELECT) || BM_elem_flag_test(l2->prev->e, BM_ELEM_SELECT)) {

22
source/blender/editors/transform/transform_conversions.c
View File

@@ -309,7 +309,7 @@ static void createTransEdge(TransInfo *t)
int count=0, countsel=0;
int propmode = t->flag & T_PROP_EDIT;
BM_ITER (eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (eed, &iter, em->bm, BM_EDGES_OF_MESH) {
if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) countsel++;
if (propmode) count++;
@@ -331,7 +331,7 @@ static void createTransEdge(TransInfo *t)
copy_m3_m4(mtx, t->obedit->obmat);
invert_m3_m3(smtx, mtx);
BM_ITER (eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (eed, &iter, em->bm, BM_EDGES_OF_MESH) {
if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN) && (BM_elem_flag_test(eed, BM_ELEM_SELECT) || propmode)) {
float *bweight = CustomData_bmesh_get(&em->bm->edata, eed->head.data, CD_BWEIGHT);
float *crease = CustomData_bmesh_get(&em->bm->edata, eed->head.data, CD_CREASE);
@@ -1888,7 +1888,7 @@ static void editmesh_set_connectivity_distance(BMEditMesh *em, float mtx[][3], f
BLI_smallhash_init(visit);
BM_ITER (v, &viter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &viter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(v, BM_ELEM_SELECT)==0 || BM_elem_flag_test(v, BM_ELEM_HIDDEN))
continue;
@@ -1909,7 +1909,7 @@ static void editmesh_set_connectivity_distance(BMEditMesh *em, float mtx[][3], f
v2 = queue[start];
d = dqueue[start];
BM_ITER (e, &eiter, em->bm, BM_EDGES_OF_VERT, v2) {
BM_ITER_ELEM (e, &eiter, v2, BM_EDGES_OF_VERT) {
float d2;
v3 = BM_edge_other_vert(e, v2);
@@ -1959,7 +1959,7 @@ static void editmesh_set_connectivity_distance(BMEditMesh *em, float mtx[][3], f
BMFace *efa;
BMIter iter;
BM_ITER (efa, &iter, bm, BM_FACES_OF_VERT, eve) {
BM_ITER_ELEM (efa, &iter, eve, BM_FACES_OF_VERT) {
if (BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
BM_face_center_mean_calc(bm, efa, cent_r);
break;
@@ -1972,7 +1972,7 @@ static void get_edge_center(float cent_r[3], BMesh *bm, BMVert *eve)
BMEdge *eed;
BMIter iter;
BM_ITER (eed, &iter, bm, BM_EDGES_OF_VERT, eve) {
BM_ITER_ELEM (eed, &iter, eve, BM_EDGES_OF_VERT) {
if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) {
mid_v3_v3v3(cent_r, eed->v1->co, eed->v2->co);
break;
@@ -2051,7 +2051,7 @@ static void createTransEditVerts(bContext *C, TransInfo *t)
// transform now requires awareness for select mode, so we tag the f1 flags in verts
if (selectmode & SCE_SELECT_VERTEX) {
BM_ITER (eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
BM_elem_flag_set(eve, BM_ELEM_TAG, BM_elem_flag_test(eve, BM_ELEM_SELECT));
}
}
@@ -2452,7 +2452,7 @@ static void createTransUVs(bContext *C, TransInfo *t)
if (!ED_space_image_show_uvedit(sima, t->obedit)) return;
/* count */
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
tf= CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
if (!uvedit_face_visible(scene, ima, efa, tf)) {
@@ -2461,7 +2461,7 @@ static void createTransUVs(bContext *C, TransInfo *t)
}
BM_elem_flag_enable(efa, BM_ELEM_TAG);
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
if (uvedit_uv_selected(em, scene, l))
countsel++;
@@ -2485,11 +2485,11 @@ static void createTransUVs(bContext *C, TransInfo *t)
td= t->data;
td2d= t->data2d;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_TAG))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
if (!propmode && !uvedit_uv_selected(em, scene, l))
continue;

10
source/blender/editors/transform/transform_manipulator.c
View File

@@ -315,7 +315,7 @@ int calc_manipulator_stats(const bContext *C)
* mode. note we can't use just vertex selection flag because
* it is not flush down on changes */
if (ts->selectmode & SCE_SELECT_VERTEX) {
BM_ITER (eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) {
if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
totsel++;
@@ -327,10 +327,10 @@ int calc_manipulator_stats(const bContext *C)
else if (ts->selectmode & SCE_SELECT_EDGE) {
BMIter itersub;
BMEdge *eed;
BM_ITER (eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) {
/* check the vertex has a selected edge, only add it once */
BM_ITER (eed, &itersub, bm, BM_EDGES_OF_VERT, eve) {
BM_ITER_ELEM (eed, &itersub, eve, BM_EDGES_OF_VERT) {
if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) {
totsel++;
calc_tw_center(scene, eve->co);
@@ -343,10 +343,10 @@ int calc_manipulator_stats(const bContext *C)
else {
BMIter itersub;
BMFace *efa;
BM_ITER (eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) {
/* check the vertex has a selected face, only add it once */
BM_ITER (efa, &itersub, bm, BM_FACES_OF_VERT, eve) {
BM_ITER_ELEM (efa, &itersub, eve, BM_FACES_OF_VERT) {
if (BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
totsel++;
calc_tw_center(scene, eve->co);

14
source/blender/editors/transform/transform_orientations.c
View File

@@ -599,7 +599,7 @@ int getTransformOrientation(const bContext *C, float normal[3], float plane[3],
BMFace *efa;
BMIter iter;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
add_v3_v3(normal, efa->no);
sub_v3_v3v3(vec,
@@ -616,7 +616,7 @@ int getTransformOrientation(const bContext *C, float normal[3], float plane[3],
BMIter iter;
float cotangent[3];
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
if (v1 == NULL) {
v1 = eve;
@@ -640,7 +640,7 @@ int getTransformOrientation(const bContext *C, float normal[3], float plane[3],
BMEdge *eed = NULL;
BMIter iter;
BM_ITER (eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (eed, &iter, em->bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) {
sub_v3_v3v3(plane, eed->v2->co, eed->v1->co);
break;
@@ -654,7 +654,7 @@ int getTransformOrientation(const bContext *C, float normal[3], float plane[3],
BMEdge *eed = NULL;
BMIter iter;
BM_ITER (eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (eed, &iter, em->bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) {
/* use average vert normals as plane and edge vector as normal */
copy_v3_v3(plane, eed->v1->no);
@@ -669,7 +669,7 @@ int getTransformOrientation(const bContext *C, float normal[3], float plane[3],
BMVert *v1 = NULL, *v2 = NULL;
BMIter iter;
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
if (v1 == NULL) {
v1 = eve;
@@ -689,7 +689,7 @@ int getTransformOrientation(const bContext *C, float normal[3], float plane[3],
else if (em->bm->totvertsel == 1) {
BMIter iter;
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
copy_v3_v3(normal, eve->no);
break;
@@ -702,7 +702,7 @@ int getTransformOrientation(const bContext *C, float normal[3], float plane[3],
zero_v3(normal);
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
add_v3_v3(normal, eve->no);
}

6
source/blender/editors/util/crazyspace.c
View File

@@ -149,11 +149,11 @@ void crazyspace_set_quats_editmesh(BMEditMesh *em, float *origcos, float *mapped
BM_mesh_elem_index_ensure(em->bm, BM_VERT);
BM_ITER (v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
if (!BM_elem_flag_test(v, BM_ELEM_SELECT) || BM_elem_flag_test(v, BM_ELEM_HIDDEN))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_VERT, v) {
BM_ITER_ELEM (l, &liter, v, BM_LOOPS_OF_VERT) {
BMLoop *l2 = BM_face_other_edge_loop(l->f, l->e, v);
/* retrieve mapped coordinates */
@@ -176,7 +176,7 @@ void crazyspace_set_quats_editmesh(BMEditMesh *em, float *origcos, float *mapped
}
index = 0;
BM_ITER (v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
if (vert_table[index] != 0)
BM_elem_index_set(v, vert_table[index] - 1); /* set_dirty! */
else

8
source/blender/editors/uvedit/uvedit_buttons.c
View File

@@ -72,12 +72,12 @@ static int uvedit_center(Scene *scene, BMEditMesh *em, Image *ima, float center[
int tot = 0.0;
zero_v2(center);
BM_ITER (f, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, em->bm, BM_FACES_OF_MESH) {
tf = CustomData_bmesh_get(&em->bm->pdata, f->head.data, CD_MTEXPOLY);
if (!uvedit_face_visible(scene, ima, f, tf))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
if (uvedit_uv_selected(em, scene, l)) {
add_v2_v2(center, luv->uv);
@@ -101,8 +101,8 @@ static void uvedit_translate(Scene *scene, BMEditMesh *em, Image *UNUSED(ima), f
BMIter iter, liter;
MLoopUV *luv;
BM_ITER (f, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_MESH (f, &iter, em->bm, BM_FACES_OF_MESH) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
if (uvedit_uv_selected(em, scene, l)) {
add_v2_v2(luv->uv, delta);

76
source/blender/editors/uvedit/uvedit_draw.c
View File

@@ -136,9 +136,9 @@ static void draw_uvs_shadow(Object *obedit)
/* draws the grey mesh when painting */
glColor3ub(112, 112, 112);
BM_ITER (efa, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
glBegin(GL_LINE_LOOP);
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_MLOOPUV);
glVertex2fv(luv->uv);
@@ -181,7 +181,7 @@ static void draw_uvs_stretch(SpaceImage *sima, Scene *scene, BMEditMesh *em, MTe
{
float totarea = 0.0f, totuvarea = 0.0f, areadiff, uvarea, area;
BM_ITER (efa, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
tf = CustomData_bmesh_get(&bm->pdata, efa->head.data, CD_MTEXPOLY);
BLI_array_empty(tf_uv);
@@ -190,7 +190,7 @@ static void draw_uvs_stretch(SpaceImage *sima, Scene *scene, BMEditMesh *em, MTe
BLI_array_growitems(tf_uvorig, efa->len);
i = 0;
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_MLOOPUV);
copy_v2_v2(tf_uvorig[i], luv->uv);
@@ -218,10 +218,10 @@ static void draw_uvs_stretch(SpaceImage *sima, Scene *scene, BMEditMesh *em, MTe
col[0] = 1.0;
col[1] = col[2] = 0.0;
glColor3fv(col);
BM_ITER (efa, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
if (BM_elem_flag_test(efa, BM_ELEM_TAG)) {
glBegin(GL_POLYGON);
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_MLOOPUV);
glVertex2fv(luv->uv);
}
@@ -230,7 +230,7 @@ static void draw_uvs_stretch(SpaceImage *sima, Scene *scene, BMEditMesh *em, MTe
}
}
else {
BM_ITER (efa, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
if (BM_elem_flag_test(efa, BM_ELEM_TAG)) {
area = BM_face_area_calc(bm, efa) / totarea;
@@ -240,7 +240,7 @@ static void draw_uvs_stretch(SpaceImage *sima, Scene *scene, BMEditMesh *em, MTe
BLI_array_growitems(tf_uvorig, efa->len);
i = 0;
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_MLOOPUV);
copy_v2_v2(tf_uvorig[i], luv->uv);
@@ -264,7 +264,7 @@ static void draw_uvs_stretch(SpaceImage *sima, Scene *scene, BMEditMesh *em, MTe
glColor3fv(col);
glBegin(GL_POLYGON);
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_MLOOPUV);
glVertex2fv(luv->uv);
}
@@ -291,7 +291,7 @@ static void draw_uvs_stretch(SpaceImage *sima, Scene *scene, BMEditMesh *em, MTe
glShadeModel(GL_SMOOTH);
BM_ITER (efa, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
tf = CustomData_bmesh_get(&bm->pdata, efa->head.data, CD_MTEXPOLY);
if (uvedit_face_visible(scene, ima, efa, tf)) {
@@ -310,7 +310,7 @@ static void draw_uvs_stretch(SpaceImage *sima, Scene *scene, BMEditMesh *em, MTe
BLI_array_growitems(av, nverts);
BLI_array_growitems(auv, nverts);
BM_ITER_INDEX (l, &liter, bm, BM_LOOPS_OF_FACE, efa, i) {
BM_ITER_ELEM_INDEX (l, &liter, efa, BM_LOOPS_OF_FACE, i) {
luv = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_MLOOPUV);
copy_v2_v2(tf_uvorig[i], luv->uv);
}
@@ -318,7 +318,7 @@ static void draw_uvs_stretch(SpaceImage *sima, Scene *scene, BMEditMesh *em, MTe
poly_copy_aspect(tf_uvorig, tf_uv, aspx, aspy, nverts);
j = nverts - 1;
BM_ITER_INDEX (l, &liter, bm, BM_LOOPS_OF_FACE, efa, i) {
BM_ITER_ELEM_INDEX (l, &liter, efa, BM_LOOPS_OF_FACE, i) {
sub_v2_v2v2(auv[i], tf_uv[j], tf_uv[i]); normalize_v2(auv[i]);
sub_v3_v3v3(av[i], l->prev->v->co, l->v->co); normalize_v3(av[i]);
j = i;
@@ -336,7 +336,7 @@ static void draw_uvs_stretch(SpaceImage *sima, Scene *scene, BMEditMesh *em, MTe
}
glBegin(GL_POLYGON);
BM_ITER_INDEX (l, &liter, bm, BM_LOOPS_OF_FACE, efa, i) {
BM_ITER_ELEM_INDEX (l, &liter, efa, BM_LOOPS_OF_FACE, i) {
luv = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_MLOOPUV);
a = fabsf(uvang[i] - ang[i]) / (float)M_PI;
weight_to_rgb(col, 1.0f - powf((1.0f - a), 2.0f));
@@ -503,7 +503,7 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
BM_ITER (efa, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
tf = CustomData_bmesh_get(&bm->pdata, efa->head.data, CD_MTEXPOLY);
if (uvedit_face_visible(scene, ima, efa, tf)) {
@@ -516,7 +516,7 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit)
glColor4ubv((GLubyte *)col1);
glBegin(GL_POLYGON);
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_MLOOPUV);
glVertex2fv(luv->uv);
}
@@ -533,7 +533,7 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit)
else {
/* would be nice to do this within a draw loop but most below are optional, so it would involve too many checks */
BM_ITER (efa, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
tf = CustomData_bmesh_get(&bm->pdata, efa->head.data, CD_MTEXPOLY);
if (uvedit_face_visible(scene, ima, efa, tf)) {
@@ -561,7 +561,7 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit)
glPolygonStipple(stipple_quarttone);
glBegin(GL_POLYGON);
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, activef) {
BM_ITER_ELEM (l, &liter, activef, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_MLOOPUV);
glVertex2fv(luv->uv);
}
@@ -582,7 +582,7 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit)
switch (sima->dt_uv) {
case SI_UVDT_DASH:
BM_ITER (efa, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_TAG))
continue;
tf = CustomData_bmesh_get(&bm->pdata, efa->head.data, CD_MTEXPOLY);
@@ -591,7 +591,7 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit)
cpack(0x111111);
glBegin(GL_LINE_LOOP);
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_MLOOPUV);
glVertex2fv(luv->uv);
}
@@ -601,7 +601,7 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit)
cpack(0x909090);
glBegin(GL_LINE_LOOP);
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_MLOOPUV);
glVertex2fv(luv->uv);
}
@@ -625,12 +625,12 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit)
if (sima->dt_uv == SI_UVDT_WHITE) glColor3f(1.0f, 1.0f, 1.0f);
else glColor3f(0.0f, 0.0f, 0.0f);
BM_ITER (efa, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_TAG))
continue;
glBegin(GL_LINE_LOOP);
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_MLOOPUV);
glVertex2fv(luv->uv);
}
@@ -641,12 +641,12 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit)
glLineWidth(3);
cpack(0x0);
BM_ITER (efa, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_TAG))
continue;
glBegin(GL_LINE_LOOP);
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_MLOOPUV);
glVertex2fv(luv->uv);
}
@@ -664,12 +664,12 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit)
if (interpedges) {
glShadeModel(GL_SMOOTH);
BM_ITER (efa, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_TAG))
continue;
glBegin(GL_LINE_LOOP);
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
sel = (uvedit_uv_selected(em, scene, l) ? 1 : 0);
glColor4ubv(sel ? (GLubyte *)col1 : (GLubyte *)col2);
@@ -682,12 +682,12 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit)
glShadeModel(GL_FLAT);
}
else {
BM_ITER (efa, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_TAG))
continue;
glBegin(GL_LINES);
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
sel = (uvedit_edge_selected(em, scene, l) ? 1 : 0);
if (sel != lastsel) {
glColor4ubv(sel ? (GLubyte *)col1 : (GLubyte *)col2);
@@ -704,12 +704,12 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit)
}
else {
/* no nice edges */
BM_ITER (efa, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_TAG))
continue;
glBegin(GL_LINE_LOOP);
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_MLOOPUV);
glVertex2fv(luv->uv);
}
@@ -737,7 +737,7 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit)
UI_ThemeColor(TH_WIRE);
bglBegin(GL_POINTS);
BM_ITER (efa, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_TAG))
continue;
@@ -752,7 +752,7 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit)
UI_ThemeColor(TH_FACE_DOT);
bglBegin(GL_POINTS);
BM_ITER (efa, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_TAG))
continue;
@@ -773,11 +773,11 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit)
glPointSize(pointsize);
bglBegin(GL_POINTS);
BM_ITER (efa, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_TAG))
continue;
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_MLOOPUV);
if (!uvedit_uv_selected(em, scene, l))
bglVertex2fv(luv->uv);
@@ -791,11 +791,11 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit)
cpack(0xFF);
bglBegin(GL_POINTS);
BM_ITER (efa, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_TAG))
continue;
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_MLOOPUV);
if (luv->flag & MLOOPUV_PINNED)
@@ -809,11 +809,11 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit)
glPointSize(pointsize);
bglBegin(GL_POINTS);
BM_ITER (efa, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_TAG))
continue;
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_MLOOPUV);
if (uvedit_uv_selected(em, scene, l))

218
source/blender/editors/uvedit/uvedit_ops.c
View File

@@ -204,7 +204,7 @@ void ED_uvedit_assign_image(Main *bmain, Scene *scene, Object *obedit, Image *im
}
/* now assign to all visible faces */
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
if (uvedit_face_visible(scene, previma, efa, tf)) {
@@ -251,7 +251,7 @@ static int uvedit_set_tile(Object *obedit, Image *ima, int curtile)
em = BMEdit_FromObject(obedit);
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN) && BM_elem_flag_test(efa, BM_ELEM_SELECT))
@@ -314,7 +314,7 @@ int uvedit_face_selected(Scene *scene, BMEditMesh *em, BMFace *efa)
MLoopUV *luv;
BMIter liter;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
if (!(luv->flag & MLOOPUV_VERTSEL))
return 0;
@@ -335,7 +335,7 @@ int uvedit_face_select(Scene *scene, BMEditMesh *em, BMFace *efa)
MLoopUV *luv;
BMIter liter;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
luv->flag |= MLOOPUV_VERTSEL;
}
@@ -358,7 +358,7 @@ int uvedit_face_deselect(Scene *scene, BMEditMesh *em, BMFace *efa)
MLoopUV *luv;
BMIter liter;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
luv->flag &= ~MLOOPUV_VERTSEL;
}
@@ -518,7 +518,7 @@ void poly_uv_center(BMEditMesh *em, BMFace *f, float cent[2])
zero_v2(cent);
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
add_v2_v2(cent, luv->uv);
}
@@ -597,12 +597,12 @@ int ED_uvedit_minmax(Scene *scene, Image *ima, Object *obedit, float *min, float
INIT_MINMAX2(min, max);
sel = 0;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
if (!uvedit_face_visible(scene, ima, efa, tf))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
if (uvedit_uv_selected(em, scene, l)) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
DO_MINMAX2(luv->uv, min, max);
@@ -625,12 +625,12 @@ static int ED_uvedit_median(Scene *scene, Image *ima, Object *obedit, float co[2
unsigned int sel = 0;
zero_v2(co);
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
if (!uvedit_face_visible(scene, ima, efa, tf))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
if (uvedit_uv_selected(em, scene, l)) {
add_v2_v2(co, luv->uv);
@@ -681,13 +681,13 @@ void uv_find_nearest_edge(Scene *scene, Image *ima, BMEditMesh *em, float co[2],
BM_mesh_elem_index_ensure(em->bm, BM_VERT);
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
if (!uvedit_face_visible(scene, ima, efa, tf))
continue;
i = 0;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
nextluv = CustomData_bmesh_get(&em->bm->ldata, l->next->head.data, CD_MLOOPUV);
@@ -730,13 +730,13 @@ static void find_nearest_uv_face(Scene *scene, Image *ima, BMEditMesh *em, float
hit->l = hit->nextl = NULL;
hit->luv = hit->nextluv = NULL;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
if (!uvedit_face_visible(scene, ima, efa, tf))
continue;
cent[0] = cent[1] = 0.0f;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
add_v2_v2(cent, luv->uv);
@@ -770,7 +770,7 @@ static int nearest_uv_between(BMEditMesh *em, BMFace *efa, int UNUSED(nverts), i
m[1] = co[1] - uv[1];
i = 0;
BM_ITER (l, &iter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &iter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
if (i == id1)
@@ -821,13 +821,13 @@ void uv_find_nearest_vert(Scene *scene, Image *ima, BMEditMesh *em,
BM_mesh_elem_index_ensure(em->bm, BM_VERT);
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
if (!uvedit_face_visible(scene, ima, efa, tf))
continue;
i = 0;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
if (penalty && uvedit_uv_selected(em, scene, l))
@@ -874,12 +874,12 @@ int ED_uvedit_nearest_uv(Scene *scene, Object *obedit, Image *ima, float co[2],
uv[0] = co[0];
uv[1] = co[1];
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
if (!uvedit_face_visible(scene, ima, efa, tf))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
dist = fabs(co[0] - luv->uv[0]) + fabs(co[1] - luv->uv[1]);
@@ -1014,7 +1014,7 @@ static int select_edgeloop(Scene *scene, Image *ima, BMEditMesh *em, NearestHit
BM_mesh_elem_index_ensure(em->bm, BM_VERT);
count = 0;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (!extend) {
uvedit_face_deselect(scene, em, efa);
}
@@ -1047,7 +1047,7 @@ static int select_edgeloop(Scene *scene, Image *ima, BMEditMesh *em, NearestHit
/* find correct valence edges which are not tagged yet, but connect to tagged one */
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
if (!BMO_elem_flag_test(em->bm, efa, EFA_F1_FLAG) && uvedit_face_visible(scene, ima, efa, tf)) {
@@ -1092,9 +1092,9 @@ static int select_edgeloop(Scene *scene, Image *ima, BMEditMesh *em, NearestHit
else
select = 1;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
a = 0;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
iterv1 = uv_vertex_map_get(vmap, efa, a);
if (iterv1->flag) {
@@ -1138,11 +1138,11 @@ static void select_linked(Scene *scene, Image *ima, BMEditMesh *em, float limit[
flag = MEM_callocN(sizeof(*flag) * em->bm->totface, "UvLinkFlag");
if (!hit) {
BM_ITER_INDEX (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL, a) {
BM_ITER_MESH_INDEX (efa, &iter, em->bm, BM_FACES_OF_MESH, a) {
tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
if (uvedit_face_visible(scene, ima, efa, tf)) {
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
if (luv->flag & MLOOPUV_VERTSEL) {
@@ -1158,7 +1158,7 @@ static void select_linked(Scene *scene, Image *ima, BMEditMesh *em, float limit[
}
else {
a = 0;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (efa == hit->efa) {
stack[stacksize] = a;
stacksize++;
@@ -1177,7 +1177,7 @@ static void select_linked(Scene *scene, Image *ima, BMEditMesh *em, float limit[
a = stack[stacksize];
j = 0;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (j == a)
break;
@@ -1185,7 +1185,7 @@ static void select_linked(Scene *scene, Image *ima, BMEditMesh *em, float limit[
}
i = 0;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
/* make_uv_vert_map_EM sets verts tmp.l to the indices */
vlist = EDBM_uv_vert_map_at_index(vmap, BM_elem_index_get(l->v));
@@ -1215,8 +1215,8 @@ static void select_linked(Scene *scene, Image *ima, BMEditMesh *em, float limit[
if (!extend) {
a = 0;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
if (flag[a])
@@ -1229,13 +1229,13 @@ static void select_linked(Scene *scene, Image *ima, BMEditMesh *em, float limit[
}
else {
a = 0;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (!flag[a]) {
a++;
continue;
}
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
if (luv->flag & MLOOPUV_VERTSEL)
@@ -1250,13 +1250,13 @@ static void select_linked(Scene *scene, Image *ima, BMEditMesh *em, float limit[
if (efa) {
a = 0;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (!flag[a]) {
a++;
continue;
}
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
luv->flag &= ~MLOOPUV_VERTSEL;
@@ -1267,13 +1267,13 @@ static void select_linked(Scene *scene, Image *ima, BMEditMesh *em, float limit[
}
else {
a = 0;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (!flag[a]) {
a++;
continue;
}
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
luv->flag |= MLOOPUV_VERTSEL;
@@ -1297,7 +1297,7 @@ static float *uv_sel_co_from_eve(Scene *scene, Image *ima, BMEditMesh *em, BMVer
BMIter liter;
BMLoop *l;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_VERT, eve) {
BM_ITER_ELEM (l, &liter, eve, BM_LOOPS_OF_VERT) {
MTexPoly *tf = CustomData_bmesh_get(&em->bm->pdata, l->f->head.data, CD_MTEXPOLY);
if (!uvedit_face_visible(scene, ima, l->f, tf))
@@ -1338,13 +1338,13 @@ static void weld_align_uv(bContext *C, int tool)
BMFace *efa;
BMLoop *l;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
if (!uvedit_face_visible(scene, ima, efa, tf))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
if (uvedit_uv_selected(em, scene, l)) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
DO_MINMAX2(luv->uv, min, max);
@@ -1361,12 +1361,12 @@ static void weld_align_uv(bContext *C, int tool)
BMFace *efa;
BMLoop *l;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
if (!uvedit_face_visible(scene, ima, efa, tf))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
if (uvedit_uv_selected(em, scene, l)) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
luv->uv[0] = cent[0];
@@ -1380,12 +1380,12 @@ static void weld_align_uv(bContext *C, int tool)
BMFace *efa;
BMLoop *l;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
if (!uvedit_face_visible(scene, ima, efa, tf))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
if (uvedit_uv_selected(em, scene, l)) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
luv->uv[1] = cent[1];
@@ -1403,13 +1403,13 @@ static void weld_align_uv(bContext *C, int tool)
BMIter iter, liter, eiter;
/* clear tag */
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
BM_elem_flag_disable(eve, BM_ELEM_TAG);
}
/* tag verts with a selected UV */
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_VERT, eve) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
BM_ITER_ELEM (l, &liter, eve, BM_LOOPS_OF_VERT) {
tf = CustomData_bmesh_get(&em->bm->pdata, l->f->head.data, CD_MTEXPOLY);
if (!uvedit_face_visible(scene, ima, l->f, tf))
@@ -1423,16 +1423,16 @@ static void weld_align_uv(bContext *C, int tool)
}
/* flush vertex tags to edges */
BM_ITER (eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (eed, &iter, em->bm, BM_EDGES_OF_MESH) {
BM_elem_flag_set(eed, BM_ELEM_TAG, (BM_elem_flag_test(eed->v1, BM_ELEM_TAG) &&
BM_elem_flag_test(eed->v2, BM_ELEM_TAG)));
}
/* find a vertex with only one tagged edge */
eve_start = NULL;
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
int tot_eed_tag = 0;
BM_ITER (eed, &eiter, em->bm, BM_EDGES_OF_VERT, eve) {
BM_ITER_ELEM (eed, &eiter, eve, BM_EDGES_OF_VERT) {
if (BM_elem_flag_test(eed, BM_ELEM_TAG)) {
tot_eed_tag++;
}
@@ -1461,7 +1461,7 @@ static void weld_align_uv(bContext *C, int tool)
eve_next = NULL;
/* find next eve */
BM_ITER (eed, &eiter, em->bm, BM_EDGES_OF_VERT, eve) {
BM_ITER_ELEM (eed, &eiter, eve, BM_EDGES_OF_VERT) {
if (BM_elem_flag_test(eed, BM_ELEM_TAG)) {
BMVert *eve_other = BM_edge_other_vert(eed, eve);
if (BM_elem_flag_test(eve_other, BM_ELEM_TAG)) {
@@ -1499,7 +1499,7 @@ static void weld_align_uv(bContext *C, int tool)
/* go over all verts except for endpoints */
for (i = 0; i < BLI_array_count(eve_line); i++) {
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_VERT, eve_line[i]) {
BM_ITER_ELEM (l, &liter, eve_line[i], BM_LOOPS_OF_VERT) {
tf = CustomData_bmesh_get(&em->bm->pdata, l->f->head.data, CD_MTEXPOLY);
if (!uvedit_face_visible(scene, ima, l->f, tf))
@@ -1637,13 +1637,13 @@ static void select_all_perform(bContext *C, int action)
else {
if (action == SEL_TOGGLE) {
action = SEL_SELECT;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
if (!uvedit_face_visible(scene, ima, efa, tf))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
if (luv->flag & MLOOPUV_VERTSEL) {
@@ -1655,13 +1655,13 @@ static void select_all_perform(bContext *C, int action)
}
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
if (!uvedit_face_visible(scene, ima, efa, tf))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
switch (action) {
@@ -1856,7 +1856,7 @@ static int mouse_select(bContext *C, float co[2], int extend, int loop)
BLI_array_growitems(hitv, hit.efa->len);
BLI_array_growitems(hituv, hit.efa->len);
i = 0;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, hit.efa) {
BM_ITER_ELEM (l, &liter, hit.efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
hituv[i] = luv->uv;
hitv[i] = BM_elem_index_get(l->v);
@@ -1935,12 +1935,12 @@ static int mouse_select(bContext *C, float co[2], int extend, int loop)
/* deselect */
if (select == 0) {
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
if (!uvedit_face_visible(scene, ima, efa, tf))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
if (sticky_select(limit, hitv, BM_elem_index_get(l->v), hituv, luv->uv, sticky, hitlen))
uvedit_uv_deselect(em, scene, l);
@@ -1950,12 +1950,12 @@ static int mouse_select(bContext *C, float co[2], int extend, int loop)
}
/* select */
else {
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
if (!uvedit_face_visible(scene, ima, efa, tf))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
if (sticky_select(limit, hitv, BM_elem_index_get(l->v), hituv, luv->uv, sticky, hitlen))
uvedit_uv_select(em, scene, l);
@@ -1968,7 +1968,7 @@ static int mouse_select(bContext *C, float co[2], int extend, int loop)
}
else {
/* deselect all */
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
uvedit_face_deselect(scene, em, efa);
}
@@ -1989,12 +1989,12 @@ static int mouse_select(bContext *C, float co[2], int extend, int loop)
/* select sticky uvs */
if (sticky != SI_STICKY_DISABLE) {
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
if (!uvedit_face_visible(scene, ima, efa, tf))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
if (sticky == SI_STICKY_DISABLE) continue;
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
@@ -2241,14 +2241,14 @@ static int unlink_selection_exec(bContext *C, wmOperator *op)
return OPERATOR_CANCELLED;
}
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
int desel = 0;
tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
if (!uvedit_face_visible(scene, ima, efa, tf))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
if (!(luv->flag & MLOOPUV_VERTSEL)) {
@@ -2258,7 +2258,7 @@ static int unlink_selection_exec(bContext *C, wmOperator *op)
}
if (desel) {
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
luv->flag &= ~MLOOPUV_VERTSEL;
}
@@ -2313,23 +2313,23 @@ static void uv_faces_do_sticky(bContext *C, SpaceImage *sima, Scene *scene, Obje
* in the loop and select all MLoopUV's that use a touched vert. */
BMVert *eve;
BM_ITER (eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
BM_elem_flag_disable(eve, BM_ELEM_TAG);
}
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (BM_elem_flag_test(efa, BM_ELEM_TAG)) {
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
BM_elem_flag_enable(l->v, BM_ELEM_TAG);
}
}
}
/* now select tagged verts */
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
/* tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); */ /* UNUSED */
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
if (BM_elem_flag_test(l->v, BM_ELEM_TAG)) {
if (select)
uvedit_uv_select(em, scene, l);
@@ -2364,7 +2364,7 @@ static void uv_faces_do_sticky(bContext *C, SpaceImage *sima, Scene *scene, Obje
if (BM_elem_flag_test(efa, BM_ELEM_TAG)) {
/* tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); */ /* UNUSED */
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
if (select)
uvedit_uv_select(em, scene, l);
else
@@ -2407,7 +2407,7 @@ static void uv_faces_do_sticky(bContext *C, SpaceImage *sima, Scene *scene, Obje
}
else { /* SI_STICKY_DISABLE or ts->uv_flag & UV_SYNC_SELECTION */
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (BM_elem_flag_test(efa, BM_ELEM_TAG)) {
if (select)
uvedit_face_select(scene, em, efa);
@@ -2465,7 +2465,7 @@ static int border_select_exec(bContext *C, wmOperator *op)
change = 0;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
/* assume not touched */
BM_elem_flag_disable(efa, BM_ELEM_TAG);
@@ -2487,11 +2487,11 @@ static int border_select_exec(bContext *C, wmOperator *op)
/* other selection modes */
change = 1;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
if (!uvedit_face_visible(scene, ima, efa, tf))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
if (!pinned || (ts->uv_flag & UV_SYNC_SELECTION) ) {
@@ -2608,8 +2608,8 @@ static int circle_select_exec(bContext *C, wmOperator *op)
UI_view2d_region_to_view(&ar->v2d, x, y, &offset[0], &offset[1]);
/* do selection */
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
select_uv_inside_ellipse(em, sima, scene, select, offset, ellipse, l, luv);
}
@@ -2728,12 +2728,12 @@ static int snap_uvs_to_cursor(Scene *scene, Image *ima, Object *obedit, SpaceIma
MLoopUV *luv;
short change = 0;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
tface = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
if (!uvedit_face_visible(scene, ima, efa, tface))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
if (uvedit_uv_selected(em, scene, l)) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
copy_v2_v2(luv->uv, sima->cursor);
@@ -2758,11 +2758,11 @@ static int snap_uvs_to_adjacent_unselected(Scene *scene, Image *ima, Object *obe
/* index every vert that has a selected UV using it, but only once so as to
* get unique indices and to count how much to malloc */
BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
tface = CustomData_bmesh_get(&bm->pdata, f->head.data, CD_MTEXPOLY);
if (uvedit_face_visible(scene, ima, f, tface)) {
BM_elem_flag_enable(f, BM_ELEM_TAG);
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
BM_elem_flag_set(l, BM_ELEM_TAG, uvedit_uv_selected(em, scene, l));
}
}
@@ -2771,14 +2771,14 @@ static int snap_uvs_to_adjacent_unselected(Scene *scene, Image *ima, Object *obe
}
}
BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
if (BM_elem_flag_test(f, BM_ELEM_TAG)) { /* face: visible */
BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
if (BM_elem_flag_test(l, BM_ELEM_TAG)) { /* loop: selected*/
float uv[2] = {0.0f, 0.0f};
int uv_tot = 0;
BM_ITER (lsub, &lsubiter, bm, BM_LOOPS_OF_VERT, l->v) {
BM_ITER_ELEM (lsub, &lsubiter, l->v, BM_LOOPS_OF_VERT) {
if (BM_elem_flag_test(lsub->f, BM_ELEM_TAG) && /* face: visible */
!BM_elem_flag_test(lsub, BM_ELEM_TAG)) /* loop: unselected */
{
@@ -2819,12 +2819,12 @@ static int snap_uvs_to_pixels(SpaceImage *sima, Scene *scene, Object *obedit)
w = (float)width;
h = (float)height;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
tface = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
if (!uvedit_face_visible(scene, ima, efa, tface))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
if (uvedit_uv_selected(em, scene, l)) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
snap_uv_to_pixel(luv->uv, w, h);
@@ -2904,12 +2904,12 @@ static int pin_exec(bContext *C, wmOperator *op)
MLoopUV *luv;
int clear = RNA_boolean_get(op->ptr, "clear");
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
tface = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
if (!uvedit_face_visible(scene, ima, efa, tface))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
if (!clear) {
@@ -2958,12 +2958,12 @@ static int select_pinned_exec(bContext *C, wmOperator *UNUSED(op))
MTexPoly *tface;
MLoopUV *luv;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
tface = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
if (!uvedit_face_visible(scene, ima, efa, tface))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
if (luv->flag & MLOOPUV_PINNED)
@@ -3035,7 +3035,7 @@ static int hide_exec(bContext *C, wmOperator *op)
return OPERATOR_FINISHED;
}
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
int hide = 0;
tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
@@ -3044,7 +3044,7 @@ static int hide_exec(bContext *C, wmOperator *op)
continue;
}
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
if (UV_SEL_TEST(luv, !swap)) {
@@ -3066,7 +3066,7 @@ static int hide_exec(bContext *C, wmOperator *op)
}
else {
if (bm_face_is_all_uv_sel(em->bm, efa, TRUE) == !swap) {
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
if (UV_SEL_TEST(luv, !swap)) {
BM_elem_select_set(em->bm, l->v, FALSE);
@@ -3086,7 +3086,7 @@ static int hide_exec(bContext *C, wmOperator *op)
}
}
else {
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
if (UV_SEL_TEST(luv, !swap)) {
BM_elem_select_set(em->bm, l->v, FALSE);
@@ -3153,10 +3153,10 @@ static int reveal_exec(bContext *C, wmOperator *UNUSED(op))
}
if (facemode) {
if (em->selectmode == SCE_SELECT_FACE) {
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
BM_elem_flag_disable(efa, BM_ELEM_TAG);
if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN) && !BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
luv->flag |= MLOOPUV_VERTSEL;
}
@@ -3168,16 +3168,16 @@ static int reveal_exec(bContext *C, wmOperator *UNUSED(op))
else {
/* enable adjacent faces to have disconnected UV selections if sticky is disabled */
if (!stickymode) {
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
BM_elem_flag_disable(efa, BM_ELEM_TAG);
if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN) && !BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
int totsel = 0;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
totsel += BM_elem_flag_test(l->v, BM_ELEM_SELECT);
}
if (!totsel) {
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
luv->flag |= MLOOPUV_VERTSEL;
}
@@ -3188,10 +3188,10 @@ static int reveal_exec(bContext *C, wmOperator *UNUSED(op))
}
}
else {
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
BM_elem_flag_disable(efa, BM_ELEM_TAG);
if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN) && !BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
if (BM_elem_flag_test(l->v, BM_ELEM_SELECT) == 0) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
luv->flag |= MLOOPUV_VERTSEL;
@@ -3205,10 +3205,10 @@ static int reveal_exec(bContext *C, wmOperator *UNUSED(op))
}
}
else if (em->selectmode == SCE_SELECT_FACE) {
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
BM_elem_flag_disable(efa, BM_ELEM_TAG);
if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN) && !BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
luv->flag |= MLOOPUV_VERTSEL;
}
@@ -3218,10 +3218,10 @@ static int reveal_exec(bContext *C, wmOperator *UNUSED(op))
}
}
else {
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
BM_elem_flag_disable(efa, BM_ELEM_TAG);
if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN) && !BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
if (BM_elem_flag_test(l->v, BM_ELEM_SELECT) == 0) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
luv->flag |= MLOOPUV_VERTSEL;
@@ -3395,7 +3395,7 @@ static int seams_from_islands_exec(bContext *C, wmOperator *op)
EDBM_index_arrays_init(em, 0, 0, 1);
vmap = EDBM_uv_vert_map_create(em, 0, 0, limit);
BM_ITER (editedge, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (editedge, &iter, bm, BM_EDGES_OF_MESH) {
/* flags to determine if we uv is separated from first editface match */
char separated1 = 0, separated2;
/* set to denote edge must be flagged as seam */
@@ -3511,8 +3511,8 @@ static int mark_seam_exec(bContext *C, wmOperator *UNUSED(op))
BMIter iter, liter;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER (loop, &liter, bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
BM_ITER_ELEM (loop, &liter, efa, BM_LOOPS_OF_FACE) {
if (uvedit_edge_selected(em, scene, loop)) {
BM_elem_flag_enable(loop->e, BM_ELEM_SEAM);
}

16
source/blender/editors/uvedit/uvedit_smart_stitch.c
View File

@@ -686,7 +686,7 @@ static int stitch_process_data(StitchState *state, Scene *scene, int final)
}
/* copy data from MTFaces to the preview display buffers */
BM_ITER (efa, &iter, state->em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, state->em->bm, BM_FACES_OF_MESH) {
/* just to test if face was added for processing. uvs of inselected vertices will return NULL */
UvElement *element = ED_uv_element_get(state->element_map, efa, BM_FACE_FIRST_LOOP(efa));
@@ -696,7 +696,7 @@ static int stitch_process_data(StitchState *state, Scene *scene, int final)
int face_preview_pos = preview_position[index].data_position;
if (face_preview_pos != STITCH_NO_PREVIEW) {
preview->uvs_per_polygon[preview_position[index].polycount_position] = efa->len;
BM_ITER_INDEX (l, &liter, state->em->bm, BM_LOOPS_OF_FACE, efa, i) {
BM_ITER_ELEM_INDEX (l, &liter, efa, BM_LOOPS_OF_FACE, i) {
luv = CustomData_bmesh_get(&state->em->bm->ldata, l->head.data, CD_MLOOPUV);
copy_v2_v2(preview->preview_polys + face_preview_pos + i * 2, luv->uv);
}
@@ -706,7 +706,7 @@ static int stitch_process_data(StitchState *state, Scene *scene, int final)
BMLoop *fl = BM_FACE_FIRST_LOOP(efa);
MLoopUV *fuv = CustomData_bmesh_get(&state->em->bm->ldata, fl->head.data, CD_MLOOPUV);
BM_ITER_INDEX (l, &liter, state->em->bm, BM_LOOPS_OF_FACE, efa, i) {
BM_ITER_ELEM_INDEX (l, &liter, efa, BM_LOOPS_OF_FACE, i) {
if (i < numoftris) {
/* using next since the first uv is already accounted for */
BMLoop *lnext = l->next;
@@ -1061,11 +1061,11 @@ static int stitch_init(bContext *C, wmOperator *op)
counter = 0;
/* Now, on to generate our uv connectivity data */
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (!(ts->uv_flag & UV_SYNC_SELECTION) && ((BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) || !BM_elem_flag_test(efa, BM_ELEM_SELECT)))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
UvElement *element = ED_uv_element_get(state->element_map, efa, l);
int offset1, itmp1 = element - state->element_map->buf;
int offset2, itmp2 = ED_uv_element_get(state->element_map, efa, l->next) - state->element_map->buf;
@@ -1177,9 +1177,9 @@ static int stitch_init(bContext *C, wmOperator *op)
}
else {
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
i = 0;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
if (uvedit_uv_selected(em, scene, l)) {
UvElement *element = ED_uv_element_get(state->element_map, efa, l);
stitch_select_uv(element, state, 1);
@@ -1197,7 +1197,7 @@ static int stitch_init(bContext *C, wmOperator *op)
state->tris_per_island[i] = 0;
}
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
UvElement *element = ED_uv_element_get(state->element_map, efa, BM_FACE_FIRST_LOOP(efa));
if (element) {

68
source/blender/editors/uvedit/uvedit_unwrap_ops.c
View File

@@ -138,7 +138,7 @@ static int ED_uvedit_ensure_uvs(bContext *C, Scene *scene, Object *obedit)
ED_uvedit_assign_image(bmain, scene, obedit, ima, NULL);
/* select new UV's */
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
uvedit_face_select(scene, em, efa);
}
@@ -156,7 +156,7 @@ static int uvedit_have_selection(Scene *scene, BMEditMesh *em, short implicit)
/* verify if we have any selected uv's before unwrapping,
* so we can cancel the operator early */
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (scene->toolsettings->uv_flag & UV_SYNC_SELECTION) {
if (BM_elem_flag_test(efa, BM_ELEM_HIDDEN))
continue;
@@ -164,7 +164,7 @@ static int uvedit_have_selection(Scene *scene, BMEditMesh *em, short implicit)
else if (BM_elem_flag_test(efa, BM_ELEM_HIDDEN) || !BM_elem_flag_test(efa, BM_ELEM_SELECT))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
if (!luv)
return 1;
@@ -215,7 +215,7 @@ static ParamHandle *construct_param_handle(Scene *scene, BMEditMesh *em,
BLI_srand(0);
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
ScanFillVert *v, *lastv, *firstv;
ScanFillFace *sefa;
ParamKey key, vkeys[4];
@@ -230,7 +230,7 @@ static ParamHandle *construct_param_handle(Scene *scene, BMEditMesh *em,
lsel = 0;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
if (uvedit_uv_selected(em, scene, l)) {
lsel = 1;
break;
@@ -247,7 +247,7 @@ static ParamHandle *construct_param_handle(Scene *scene, BMEditMesh *em,
/* for quads let parametrize split, it can make better decisions
about which split is best for unwrapping than scanfill */
i = 0;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
MLoopUV *luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
vkeys[i] = (ParamKey)BM_elem_index_get(l->v);
co[i] = l->v->co;
@@ -265,7 +265,7 @@ static ParamHandle *construct_param_handle(Scene *scene, BMEditMesh *em,
BLI_begin_edgefill(&sf_ctx);
firstv = lastv = NULL;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
int i;
v = BLI_addfillvert(&sf_ctx, l->v->co);
@@ -311,7 +311,7 @@ static ParamHandle *construct_param_handle(Scene *scene, BMEditMesh *em,
}
if (!implicit) {
BM_ITER (eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (eed, &iter, em->bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(eed, BM_ELEM_SEAM)) {
ParamKey vkeys[2];
vkeys[0] = (ParamKey)BM_elem_index_get(eed->v1);
@@ -340,7 +340,7 @@ static void texface_from_original_index(BMFace *efa, int index, float **uv, Para
if (index == ORIGINDEX_NONE)
return;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
if (BM_elem_index_get(l->v) == index) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
*uv = luv->uv;
@@ -868,9 +868,9 @@ static void uv_map_transform_center(Scene *scene, View3D *v3d, float *result,
min[0] = min[1] = min[2] = 1e20f;
max[0] = max[1] = max[2] = -1e20f;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
DO_MINMAX(l->v->co, min, max);
}
}
@@ -1020,11 +1020,11 @@ static void correct_uv_aspect(BMEditMesh *em)
if (aspx > aspy) {
scale = aspy / aspx;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_SELECT) || BM_elem_flag_test(efa, BM_ELEM_HIDDEN))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
luv->uv[0] = ((luv->uv[0] - 0.5) * scale) + 0.5;
}
@@ -1033,11 +1033,11 @@ static void correct_uv_aspect(BMEditMesh *em)
else {
scale = aspx / aspy;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_SELECT) || BM_elem_flag_test(efa, BM_ELEM_HIDDEN))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
luv->uv[1] = ((luv->uv[1] - 0.5) * scale) + 0.5;
}
@@ -1075,11 +1075,11 @@ static void uv_map_clip_correct(BMEditMesh *em, wmOperator *op)
if (scale_to_bounds) {
INIT_MINMAX2(min, max);
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_SELECT))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
DO_MINMAX2(luv->uv, min, max);
}
@@ -1094,11 +1094,11 @@ static void uv_map_clip_correct(BMEditMesh *em, wmOperator *op)
if (dy > 0.0f)
dy = 1.0f / dy;
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_SELECT))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
luv->uv[0] = (luv->uv[0] - min[0]) * dx;
@@ -1108,11 +1108,11 @@ static void uv_map_clip_correct(BMEditMesh *em, wmOperator *op)
}
else if (clip_to_bounds) {
/* clipping and wrapping */
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_SELECT))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
CLAMP(luv->uv[0], 0.0f, 1.0f);
CLAMP(luv->uv[1], 0.0f, 1.0f);
@@ -1257,11 +1257,11 @@ static int uv_from_view_exec(bContext *C, wmOperator *op)
if (RNA_boolean_get(op->ptr, "orthographic")) {
uv_map_rotation_matrix(rotmat, rv3d, obedit, 90.0f, 0.0f, 1.0f);
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_SELECT))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
project_from_view_ortho(luv->uv, l->v->co, rotmat);
}
@@ -1271,11 +1271,11 @@ static int uv_from_view_exec(bContext *C, wmOperator *op)
struct UvCameraInfo *uci = project_camera_info(v3d->camera, obedit->obmat, scene->r.xsch, scene->r.ysch);
if (uci) {
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_SELECT))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
project_from_camera(luv->uv, l->v->co, uci);
}
@@ -1287,11 +1287,11 @@ static int uv_from_view_exec(bContext *C, wmOperator *op)
else {
copy_m4_m4(rotmat, obedit->obmat);
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_SELECT))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
project_from_view(luv->uv, l->v->co, rv3d->persmat, rotmat, ar->winx, ar->winy);
}
@@ -1394,7 +1394,7 @@ static void uv_map_mirror(BMEditMesh *em, BMFace *efa, MTexPoly *UNUSED(tf))
int i, mi;
i = 0;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
uvs[i] = luv->uv;
i++;
@@ -1434,11 +1434,11 @@ static int sphere_project_exec(bContext *C, wmOperator *op)
uv_map_transform(C, op, center, rotmat);
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_SELECT))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
uv_sphere_project(luv->uv, l->v->co, center, rotmat);
@@ -1507,12 +1507,12 @@ static int cylinder_project_exec(bContext *C, wmOperator *op)
uv_map_transform(C, op, center, rotmat);
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
if (!BM_elem_flag_test(efa, BM_ELEM_SELECT))
continue;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
uv_cylinder_project(luv->uv, l->v->co, center, rotmat);
@@ -1571,7 +1571,7 @@ static int cube_project_exec(bContext *C, wmOperator *op)
/* choose x,y,z axis for projection depending on the largest normal
* component, but clusters all together around the center of map. */
BM_ITER (efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
int first = 1;
/* tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); */ /* UNUSED */
@@ -1581,7 +1581,7 @@ static int cube_project_exec(bContext *C, wmOperator *op)
axis_dominant_v3(&cox, &coy, efa->no);
dx = dy = 0;
BM_ITER (l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
luv->uv[0] = 0.5f + 0.5f * cube_size * (loc[cox] + l->v->co[cox]);

4
source/blender/modifiers/intern/MOD_array.c
View File

@@ -240,7 +240,7 @@ static void bm_merge_dm_transform(BMesh* bm, DerivedMesh *dm, float mat[4][4],
BMO_slot_buffer_append(&find_op, "verts", dupe_op, dupe_slot_name);
/* transform and tag verts */
BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
if (!BM_elem_flag_test(v, BM_ELEM_TAG)) {
mul_m4_v3(mat, v->co);
BM_elem_flag_enable(v, BM_ELEM_TAG);
@@ -259,7 +259,7 @@ static void bm_merge_dm_transform(BMesh* bm, DerivedMesh *dm, float mat[4][4],
}
else {
/* transform and tag verts */
BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
if (!BM_elem_flag_test(v, BM_ELEM_TAG)) {
mul_m4_v3(mat, v->co);
BM_elem_flag_enable(v, BM_ELEM_TAG);

4
source/blender/modifiers/intern/MOD_bevel.c
View File

@@ -125,7 +125,7 @@ static DerivedMesh *applyModifier(ModifierData *md, struct Object *UNUSED(ob),
BMO_push(bm, NULL);
if (bmd->lim_flags & BME_BEVEL_ANGLE) {
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
/* check for 1 edge having 2 face users */
BMLoop *l1, *l2;
if ( (l1= e->l) &&
@@ -139,7 +139,7 @@ static DerivedMesh *applyModifier(ModifierData *md, struct Object *UNUSED(ob),
}
else {
/* crummy, is there a way just to operator on all? - campbell */
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
BMO_elem_flag_enable(bm, e, EDGE_MARK);
}
}

4
source/blender/modifiers/intern/MOD_edgesplit.c
View File

@@ -73,7 +73,7 @@ static DerivedMesh *doEdgeSplit(DerivedMesh *dm, EdgeSplitModifierData *emd, Obj
BMO_push(bm, NULL);
if (emd->flags & MOD_EDGESPLIT_FROMANGLE) {
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
/* check for 1 edge having 2 face users */
BMLoop *l1, *l2;
if ( (l1= e->l) &&
@@ -87,7 +87,7 @@ static DerivedMesh *doEdgeSplit(DerivedMesh *dm, EdgeSplitModifierData *emd, Obj
}
if (emd->flags & MOD_EDGESPLIT_FROMFLAG) {
BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
/* check for 2 or more edge users */
if ((e->l) &&
(e->l->next != e->l))

4
source/blender/python/bmesh/bmesh_py_types.c
View File

@@ -998,13 +998,13 @@ static PyObject *bpy_bmesh_transform(BPy_BMElem *self, PyObject *args, PyObject
mat_ptr = mat->matrix;
if (!filter_flags) {
BM_ITER (eve, &iter, self->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, self->bm, BM_VERTS_OF_MESH) {
mul_m4_v3((float (*)[4])mat_ptr, eve->co);
}
}
else {
char filter_flags_ch = (char)filter_flags;
BM_ITER (eve, &iter, self->bm, BM_VERTS_OF_MESH, NULL) {
BM_ITER_MESH (eve, &iter, self->bm, BM_VERTS_OF_MESH) {
if (eve->head.hflag & filter_flags_ch) {
mul_m4_v3((float (*)[4])mat_ptr, eve->co);
}

17
source/blender/python/bmesh/bmesh_py_types.h
View File

@@ -138,8 +138,8 @@ void BPy_BM_init_types(void);
PyObject *BPyInit_bmesh_types(void);
enum {
BPY_BMFLAG_NOP = 0, /* do nothing */
BPY_BMFLAG_IS_WRAPPED = 1 /* the mesh is owned by editmode */
BPY_BMFLAG_NOP = 0, /* do nothing */
BPY_BMFLAG_IS_WRAPPED = 1 /* the mesh is owned by editmode */
};
PyObject *BPy_BMesh_CreatePyObject(BMesh *bm, int flag);
@@ -175,8 +175,15 @@ char *BPy_BMElem_StringFromHType(const char htype);
#define BPY_BM_IS_VALID(obj) (LIKELY((obj)->bm != NULL))
#define BM_ITER_BPY_BM_SEQ(ele, iter, bpy_bmelemseq) \
BM_ITER (ele, iter, (bpy_bmelemseq)->bm, (bpy_bmelemseq)->itype, \
(bpy_bmelemseq)->py_ele ? ((BPy_BMElem *)(bpy_bmelemseq)->py_ele)->ele : NULL)
#define BM_ITER_BPY_BM_SEQ(ele, iter, bpy_bmelemseq) \
for (ele = BM_iter_new(iter, \
(bpy_bmelemseq)->bm, \
(bpy_bmelemseq)->itype, \
(bpy_bmelemseq)->py_ele ? \
((BPy_BMElem *)(bpy_bmelemseq)->py_ele)->ele : \
NULL \
); \
ele; \
ele = BM_iter_step(iter))
#endif /* __BMESH_TYPES_H__ */