diff options
83 files changed, 3629 insertions, 3728 deletions
diff --git a/source/blender/blenkernel/intern/DerivedMesh.c b/source/blender/blenkernel/intern/DerivedMesh.c index 825c2219cd1..0697951cc13 100644 --- a/source/blender/blenkernel/intern/DerivedMesh.c +++ b/source/blender/blenkernel/intern/DerivedMesh.c @@ -763,8 +763,8 @@ static float *get_editbmesh_orco_verts(BMEditMesh *em) orco = MEM_mallocN(sizeof(float)*3*totvert, "EditMesh Orco"); - eve = BMIter_New(&iter, em->bm, BM_VERTS_OF_MESH, NULL); - for (a=0; eve; eve=BMIter_Step(&iter), a+=3) { + eve = BM_iter_new(&iter, em->bm, BM_VERTS_OF_MESH, NULL); + for (a=0; eve; eve=BM_iter_step(&iter), a+=3) { copy_v3_v3(orco+a, eve->co); } @@ -1709,8 +1709,8 @@ float (*editbmesh_get_vertex_cos(BMEditMesh *em, int *numVerts_r))[3] cos = MEM_mallocN(sizeof(float)*3*numVerts, "vertexcos"); - eve = BMIter_New(&iter, em->bm, BM_VERTS_OF_MESH, NULL); - for (i=0; eve; eve=BMIter_Step(&iter), i++) { + eve = BM_iter_new(&iter, em->bm, BM_VERTS_OF_MESH, NULL); + for (i=0; eve; eve=BM_iter_step(&iter), i++) { copy_v3_v3(cos[i], eve->co); } diff --git a/source/blender/blenkernel/intern/bvhutils.c b/source/blender/blenkernel/intern/bvhutils.c index 5d2392b790d..5c50c14f1a8 100644 --- a/source/blender/blenkernel/intern/bvhutils.c +++ b/source/blender/blenkernel/intern/bvhutils.c @@ -619,14 +619,14 @@ BVHTree* bvhtree_from_mesh_faces(BVHTreeFromMesh *data, DerivedMesh *mesh, float /*Start with the assumption the triangle should be included for snapping.*/ insert = 1; - if (BM_TestHFlag(f, BM_ELEM_SELECT) || BM_TestHFlag(f, BM_ELEM_HIDDEN)) { + if (BM_elem_flag_test(f, BM_ELEM_SELECT) || BM_elem_flag_test(f, BM_ELEM_HIDDEN)) { /*Don't insert triangles tesselated from faces that are hidden or selected*/ insert = 0; } else { BM_ITER(v, &iter, em->bm, BM_VERTS_OF_FACE, f) { - if (BM_TestHFlag(v, BM_ELEM_SELECT)) { + if (BM_elem_flag_test(v, BM_ELEM_SELECT)) { /*Don't insert triangles tesselated from faces that have any selected verts.*/ insert = 0; diff --git a/source/blender/blenkernel/intern/cdderivedmesh.c b/source/blender/blenkernel/intern/cdderivedmesh.c index 00d7f6e2a1f..97340ff8572 100644 --- a/source/blender/blenkernel/intern/cdderivedmesh.c +++ b/source/blender/blenkernel/intern/cdderivedmesh.c @@ -2042,20 +2042,20 @@ DerivedMesh *CDDM_from_BMEditMesh(BMEditMesh *em, Mesh *UNUSED(me), int use_mdis index = dm->getVertDataArray(dm, CD_ORIGINDEX); - eve = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL); - for (i=0; eve; eve=BMIter_Step(&iter), i++, index++) { + eve = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL); + for (i=0; eve; eve=BM_iter_step(&iter), i++, index++) { MVert *mv = &mvert[i]; copy_v3_v3(mv->co, eve->co); - BM_SetIndex(eve, i); /* set_inline */ + BM_elem_index_set(eve, i); /* set_inline */ normal_float_to_short_v3(mv->no, eve->no); - mv->flag = BM_Vert_Flag_To_MEFlag(eve); + mv->flag = BM_vert_flag_to_mflag(eve); if (has_vert_bweight) - mv->bweight = (unsigned char)(BM_GetCDf(&bm->vdata, eve, CD_BWEIGHT)*255.0f); + mv->bweight = (unsigned char)(BM_elem_float_data_get(&bm->vdata, eve, CD_BWEIGHT)*255.0f); if (add_orig) *index = i; @@ -2064,21 +2064,21 @@ DerivedMesh *CDDM_from_BMEditMesh(BMEditMesh *em, Mesh *UNUSED(me), int use_mdis bm->elem_index_dirty &= ~BM_VERT; index = dm->getEdgeDataArray(dm, CD_ORIGINDEX); - eed = BMIter_New(&iter, bm, BM_EDGES_OF_MESH, NULL); - for (i=0; eed; eed=BMIter_Step(&iter), i++, index++) { + eed = BM_iter_new(&iter, bm, BM_EDGES_OF_MESH, NULL); + for (i=0; eed; eed=BM_iter_step(&iter), i++, index++) { MEdge *med = &medge[i]; - BM_SetIndex(eed, i); /* set_inline */ + BM_elem_index_set(eed, i); /* set_inline */ - med->v1 = BM_GetIndex(eed->v1); - med->v2 = BM_GetIndex(eed->v2); + med->v1 = BM_elem_index_get(eed->v1); + med->v2 = BM_elem_index_get(eed->v2); if (has_crease) - med->crease = (unsigned char)(BM_GetCDf(&bm->edata, eed, CD_CREASE)*255.0f); + med->crease = (unsigned char)(BM_elem_float_data_get(&bm->edata, eed, CD_CREASE)*255.0f); if (has_edge_bweight) - med->bweight = (unsigned char)(BM_GetCDf(&bm->edata, eed, CD_BWEIGHT)*255.0f); + med->bweight = (unsigned char)(BM_elem_float_data_get(&bm->edata, eed, CD_BWEIGHT)*255.0f); - med->flag = BM_Edge_Flag_To_MEFlag(eed); + med->flag = BM_edge_flag_to_mflag(eed); CustomData_from_bmesh_block(&bm->edata, &dm->edgeData, eed->head.data, i); if (add_orig) *index = i; @@ -2089,7 +2089,7 @@ DerivedMesh *CDDM_from_BMEditMesh(BMEditMesh *em, Mesh *UNUSED(me), int use_mdis if (use_tessface) { int *polyindex; - BM_ElemIndex_Ensure(bm, BM_FACE); + BM_mesh_elem_index_ensure(bm, BM_FACE); polyindex = dm->getTessFaceDataArray(dm, CD_POLYINDEX); index = dm->getTessFaceDataArray(dm, CD_ORIGINDEX); @@ -2098,15 +2098,15 @@ DerivedMesh *CDDM_from_BMEditMesh(BMEditMesh *em, Mesh *UNUSED(me), int use_mdis BMLoop **l = em->looptris[i]; efa = l[0]->f; - mf->v1 = BM_GetIndex(l[0]->v); - mf->v2 = BM_GetIndex(l[1]->v); - mf->v3 = BM_GetIndex(l[2]->v); + mf->v1 = BM_elem_index_get(l[0]->v); + mf->v2 = BM_elem_index_get(l[1]->v); + mf->v3 = BM_elem_index_get(l[2]->v); mf->v4 = 0; mf->mat_nr = efa->mat_nr; - mf->flag = BM_Face_Flag_To_MEFlag(efa); + mf->flag = BM_face_flag_to_mflag(efa); - *index = add_orig ? BM_GetIndex(efa) : *(int*)CustomData_bmesh_get(&bm->pdata, efa->head.data, CD_ORIGINDEX); - *polyindex = BM_GetIndex(efa); + *index = add_orig ? BM_elem_index_get(efa) : *(int*)CustomData_bmesh_get(&bm->pdata, efa->head.data, CD_ORIGINDEX); + *polyindex = BM_elem_index_get(efa); loops_to_customdata_corners(bm, &dm->faceData, i, l, numCol, numTex); test_index_face(mf, &dm->faceData, i, 3); @@ -2115,21 +2115,21 @@ DerivedMesh *CDDM_from_BMEditMesh(BMEditMesh *em, Mesh *UNUSED(me), int use_mdis index = CustomData_get_layer(&dm->polyData, CD_ORIGINDEX); j = 0; - efa = BMIter_New(&iter, bm, BM_FACES_OF_MESH, NULL); - for (i=0; efa; i++, efa=BMIter_Step(&iter), index++) { + efa = BM_iter_new(&iter, bm, BM_FACES_OF_MESH, NULL); + for (i=0; efa; i++, efa=BM_iter_step(&iter), index++) { BMLoop *l; MPoly *mp = &mpoly[i]; - BM_SetIndex(efa, i); /* set_inline */ + BM_elem_index_set(efa, i); /* set_inline */ mp->totloop = efa->len; - mp->flag = BM_Face_Flag_To_MEFlag(efa); + mp->flag = BM_face_flag_to_mflag(efa); mp->loopstart = j; mp->mat_nr = efa->mat_nr; BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, efa) { - mloop->v = BM_GetIndex(l->v); - mloop->e = BM_GetIndex(l->e); + 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); j++; diff --git a/source/blender/blenkernel/intern/editderivedmesh.c b/source/blender/blenkernel/intern/editderivedmesh.c index 253d215ac58..a200c3b20e8 100644 --- a/source/blender/blenkernel/intern/editderivedmesh.c +++ b/source/blender/blenkernel/intern/editderivedmesh.c @@ -89,7 +89,7 @@ BMEditMesh *BMEdit_Copy(BMEditMesh *tm) tm2->derivedCage = tm2->derivedFinal = NULL; - tm2->bm = BM_Copy_Mesh(tm->bm); + tm2->bm = BM_mesh_copy(tm->bm); /*The tesselation is NOT calculated on the copy here, because currently all the callers of this function use @@ -149,8 +149,8 @@ static void BMEdit_RecalcTesselation_intern(BMEditMesh *tm) #endif - f = BMIter_New(&iter, bm, BM_FACES_OF_MESH, NULL); - for ( ; f; f=BMIter_Step(&iter)) { + f = BM_iter_new(&iter, bm, BM_FACES_OF_MESH, NULL); + for ( ; f; f=BM_iter_step(&iter)) { /*don't consider two-edged faces*/ if (f->len < 3) { /* do nothing */ @@ -162,8 +162,8 @@ static void BMEdit_RecalcTesselation_intern(BMEditMesh *tm) else if (f->len == 3) { BLI_array_growone(looptris); - l = BMIter_New(&liter, bm, BM_LOOPS_OF_FACE, f); - for (j=0; l; l=BMIter_Step(&liter), j++) { + l = BM_iter_new(&liter, bm, BM_LOOPS_OF_FACE, f); + for (j=0; l; l=BM_iter_step(&liter), j++) { looptris[i][j] = l; } i += 1; @@ -172,8 +172,8 @@ static void BMEdit_RecalcTesselation_intern(BMEditMesh *tm) BMLoop *ltmp[4]; BLI_array_growitems(looptris, 2); - l = BMIter_New(&liter, bm, BM_LOOPS_OF_FACE, f); - for (j=0; l; l=BMIter_Step(&liter), j++) { + l = BM_iter_new(&liter, bm, BM_LOOPS_OF_FACE, f); + for (j=0; l; l=BM_iter_step(&liter), j++) { ltmp[j] = l; } @@ -198,10 +198,10 @@ static void BMEdit_RecalcTesselation_intern(BMEditMesh *tm) BLI_begin_edgefill(); /*scanfill time*/ - l = BMIter_New(&liter, bm, BM_LOOPS_OF_FACE, f); - for (j=0; l; l=BMIter_Step(&liter), j++) { + l = BM_iter_new(&liter, bm, BM_LOOPS_OF_FACE, f); + for (j=0; l; l=BM_iter_step(&liter), j++) { /*mark order*/ - BM_SetIndex(l, j); /* set_loop */ + BM_elem_index_set(l, j); /* set_loop */ v = BLI_addfillvert(l->v->co); v->tmp.p = l; @@ -225,9 +225,9 @@ static void BMEdit_RecalcTesselation_intern(BMEditMesh *tm) BMLoop *l2= efa->v2->tmp.p; BMLoop *l3= efa->v3->tmp.p; - if (BM_GetIndex(l1) > BM_GetIndex(l2)) { SWAP(BMLoop*, l1, l2); } - if (BM_GetIndex(l2) > BM_GetIndex(l3)) { SWAP(BMLoop*, l2, l3); } - if (BM_GetIndex(l1) > BM_GetIndex(l2)) { SWAP(BMLoop*, l1, l2); } + if (BM_elem_index_get(l1) > BM_elem_index_get(l2)) { SWAP(BMLoop*, l1, l2); } + if (BM_elem_index_get(l2) > BM_elem_index_get(l3)) { SWAP(BMLoop*, l2, l3); } + if (BM_elem_index_get(l1) > BM_elem_index_get(l2)) { SWAP(BMLoop*, l1, l2); } looptris[i][0] = l1; looptris[i][1] = l2; @@ -308,7 +308,7 @@ void BMEdit_Free(BMEditMesh *em) if (em->face_index) MEM_freeN(em->face_index); if (em->bm) - BM_Free_Mesh(em->bm); + BM_mesh_free(em->bm); } /* @@ -384,10 +384,10 @@ static void UNUSED_FUNCTION(bmdm_recalc_lookups)(EditDerivedBMesh *bmdm) BMHeader **table = iters_table[a]; BMHeader *ele; - ele = BMIter_New(&iter, bmdm->tc->bm, iter_types[a], NULL); - for (i=0; ele; ele=BMIter_Step(&iter), i++) { + ele = BM_iter_new(&iter, bmdm->tc->bm, iter_types[a], NULL); + for (i=0; ele; ele=BM_iter_step(&iter), i++) { table[i] = ele; - BM_SetIndex(ele, i); /* set_ok */ + BM_elem_index_set(ele, i); /* set_ok */ } } bmdm->tc->bm->elem_index_dirty &= ~(BM_VERT|BM_EDGE|BM_FACE); @@ -417,8 +417,8 @@ static void emDM_foreachMappedVert( BMIter iter; int i; - eve = BMIter_New(&iter, bmdm->tc->bm, BM_VERTS_OF_MESH, NULL); - for (i=0; eve; i++, eve=BMIter_Step(&iter)) { + eve = BM_iter_new(&iter, bmdm->tc->bm, BM_VERTS_OF_MESH, NULL); + for (i=0; eve; i++, eve=BM_iter_step(&iter)) { if (bmdm->vertexCos) { func(userData, i, bmdm->vertexCos[i], bmdm->vertexNos[i], NULL); } @@ -439,17 +439,17 @@ static void emDM_foreachMappedEdge( if (bmdm->vertexCos) { - BM_ElemIndex_Ensure(bmdm->tc->bm, BM_VERT); + BM_mesh_elem_index_ensure(bmdm->tc->bm, BM_VERT); - eed = BMIter_New(&iter, bmdm->tc->bm, BM_EDGES_OF_MESH, NULL); - for (i=0; eed; i++,eed=BMIter_Step(&iter)) + eed = BM_iter_new(&iter, bmdm->tc->bm, BM_EDGES_OF_MESH, NULL); + for (i=0; eed; i++,eed=BM_iter_step(&iter)) func(userData, i, - bmdm->vertexCos[BM_GetIndex(eed->v1)], - bmdm->vertexCos[BM_GetIndex(eed->v2)]); + bmdm->vertexCos[BM_elem_index_get(eed->v1)], + bmdm->vertexCos[BM_elem_index_get(eed->v2)]); } else { - eed = BMIter_New(&iter, bmdm->tc->bm, BM_EDGES_OF_MESH, NULL); - for (i=0; eed; i++,eed=BMIter_Step(&iter)) + eed = BM_iter_new(&iter, bmdm->tc->bm, BM_EDGES_OF_MESH, NULL); + for (i=0; eed; i++,eed=BM_iter_step(&iter)) func(userData, i, eed->v1->co, eed->v2->co); } } @@ -466,22 +466,22 @@ static void emDM_drawMappedEdges( if (bmdm->vertexCos) { - BM_ElemIndex_Ensure(bmdm->tc->bm, BM_VERT); + BM_mesh_elem_index_ensure(bmdm->tc->bm, BM_VERT); glBegin(GL_LINES); - eed = BMIter_New(&iter, bmdm->tc->bm, BM_EDGES_OF_MESH, NULL); - for (i=0; eed; i++,eed=BMIter_Step(&iter)) { + eed = BM_iter_new(&iter, bmdm->tc->bm, BM_EDGES_OF_MESH, NULL); + for (i=0; eed; i++,eed=BM_iter_step(&iter)) { if (!setDrawOptions || setDrawOptions(userData, i)) { - glVertex3fv(bmdm->vertexCos[BM_GetIndex(eed->v1)]); - glVertex3fv(bmdm->vertexCos[BM_GetIndex(eed->v2)]); + glVertex3fv(bmdm->vertexCos[BM_elem_index_get(eed->v1)]); + glVertex3fv(bmdm->vertexCos[BM_elem_index_get(eed->v2)]); } } glEnd(); } else { glBegin(GL_LINES); - eed = BMIter_New(&iter, bmdm->tc->bm, BM_EDGES_OF_MESH, NULL); - for (i=0; eed; i++,eed=BMIter_Step(&iter)) { + eed = BM_iter_new(&iter, bmdm->tc->bm, BM_EDGES_OF_MESH, NULL); + for (i=0; eed; i++,eed=BM_iter_step(&iter)) { if (!setDrawOptions || setDrawOptions(userData, i)) { glVertex3fv(eed->v1->co); glVertex3fv(eed->v2->co); @@ -511,24 +511,24 @@ static void emDM_drawMappedEdgesInterp( if (bmdm->vertexCos) { - BM_ElemIndex_Ensure(bmdm->tc->bm, BM_VERT); + BM_mesh_elem_index_ensure(bmdm->tc->bm, BM_VERT); glBegin(GL_LINES); - eed = BMIter_New(&iter, bmdm->tc->bm, BM_EDGES_OF_MESH, NULL); - for (i=0; eed; i++,eed=BMIter_Step(&iter)) { + eed = BM_iter_new(&iter, bmdm->tc->bm, BM_EDGES_OF_MESH, NULL); + for (i=0; eed; i++,eed=BM_iter_step(&iter)) { if (!setDrawOptions || setDrawOptions(userData, i)) { setDrawInterpOptions(userData, i, 0.0); - glVertex3fv(bmdm->vertexCos[BM_GetIndex(eed->v1)]); + glVertex3fv(bmdm->vertexCos[BM_elem_index_get(eed->v1)]); setDrawInterpOptions(userData, i, 1.0); - glVertex3fv(bmdm->vertexCos[BM_GetIndex(eed->v2)]); + glVertex3fv(bmdm->vertexCos[BM_elem_index_get(eed->v2)]); } } glEnd(); } else { glBegin(GL_LINES); - eed = BMIter_New(&iter, bmdm->tc->bm, BM_EDGES_OF_MESH, NULL); - for (i=0; eed; i++,eed=BMIter_Step(&iter)) { + eed = BM_iter_new(&iter, bmdm->tc->bm, BM_EDGES_OF_MESH, NULL); + for (i=0; eed; i++,eed=BM_iter_step(&iter)) { if (!setDrawOptions || setDrawOptions(userData, i)) { setDrawInterpOptions(userData, i, 0.0); glVertex3fv(eed->v1->co); @@ -553,7 +553,7 @@ static void emDM_drawUVEdges(DerivedMesh *dm) BMLoop *l; MLoopUV *lastluv = NULL, *firstluv = NULL; - if (BM_TestHFlag(efa, BM_ELEM_HIDDEN)) + if (BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) continue; BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { @@ -589,15 +589,15 @@ static void emDM__calcFaceCent(BMesh *bm, BMFace *efa, float cent[3], float (*ve /*simple (and stupid) median (average) based method :/ */ if (vertexCos) { - l = BMIter_New(&iter, bm, BM_LOOPS_OF_FACE, efa); - for (; l; l=BMIter_Step(&iter)) { - add_v3_v3(cent, vertexCos[BM_GetIndex(l->v)]); + l = BM_iter_new(&iter, bm, BM_LOOPS_OF_FACE, efa); + for (; l; l=BM_iter_step(&iter)) { + add_v3_v3(cent, vertexCos[BM_elem_index_get(l->v)]); tot++; } } else { - l = BMIter_New(&iter, bm, BM_LOOPS_OF_FACE, efa); - for (; l; l=BMIter_Step(&iter)) { + l = BM_iter_new(&iter, bm, BM_LOOPS_OF_FACE, efa); + for (; l; l=BM_iter_step(&iter)) { add_v3_v3(cent, l->v->co); tot++; } @@ -621,14 +621,14 @@ static void emDM_foreachMappedFaceCenter( /* ensure for face center calculation */ if (bmdm->vertexCos) { - BM_ElemIndex_Ensure(bmdm->tc->bm, BM_VERT); + BM_mesh_elem_index_ensure(bmdm->tc->bm, BM_VERT); polyNos = bmdm->polyNos; BLI_assert(polyNos != NULL); } - efa = BMIter_New(&iter, bmdm->tc->bm, BM_FACES_OF_MESH, NULL); - for (i=0; efa; efa=BMIter_Step(&iter), i++) { + efa = BM_iter_new(&iter, bmdm->tc->bm, BM_FACES_OF_MESH, NULL); + for (i=0; efa; efa=BM_iter_step(&iter), i++) { emDM__calcFaceCent(bmdm->tc->bm, efa, cent, bmdm->vertexCos); func(userData, i, cent, polyNos ? polyNos[i] : efa->no); } @@ -665,16 +665,16 @@ static void emDM_drawMappedFaces( float (*polyNos)[3]= bmdm->polyNos; // int *triPolyMap= bmdm->triPolyMap; - BM_ElemIndex_Ensure(bmdm->tc->bm, BM_VERT | BM_FACE); + BM_mesh_elem_index_ensure(bmdm->tc->bm, BM_VERT | BM_FACE); for (i=0; i < tottri; i++) { BMLoop **l = looptris[i]; int drawSmooth; efa = l[0]->f; - drawSmooth= BM_TestHFlag(efa, BM_ELEM_SMOOTH); + drawSmooth= BM_elem_flag_test(efa, BM_ELEM_SMOOTH); - draw = setDrawOptions==NULL ? 1 : setDrawOptions(userData, BM_GetIndex(efa), &drawSmooth); + draw = setDrawOptions==NULL ? 1 : setDrawOptions(userData, BM_elem_index_get(efa), &drawSmooth); if (draw) { const GLenum poly_type= GL_TRIANGLES; /* BMESH NOTE, this is odd but keep it for now to match trunk */ if (draw==2) { /* enabled with stipple */ @@ -691,9 +691,9 @@ static void emDM_drawMappedFaces( if (poly_prev != GL_ZERO) glEnd(); glBegin((poly_prev= poly_type)); /* BMesh: will always be GL_TRIANGLES */ } - glVertex3fv(vertexCos[BM_GetIndex(l[0]->v)]); - glVertex3fv(vertexCos[BM_GetIndex(l[1]->v)]); - glVertex3fv(vertexCos[BM_GetIndex(l[2]->v)]); + glVertex3fv(vertexCos[BM_elem_index_get(l[0]->v)]); + glVertex3fv(vertexCos[BM_elem_index_get(l[1]->v)]); + glVertex3fv(vertexCos[BM_elem_index_get(l[2]->v)]); } else { const GLenum shade_type= drawSmooth ? GL_SMOOTH : GL_FLAT; @@ -708,18 +708,18 @@ static void emDM_drawMappedFaces( } if (!drawSmooth) { - glNormal3fv(polyNos[BM_GetIndex(efa)]); - glVertex3fv(vertexCos[BM_GetIndex(l[0]->v)]); - glVertex3fv(vertexCos[BM_GetIndex(l[1]->v)]); - glVertex3fv(vertexCos[BM_GetIndex(l[2]->v)]); + glNormal3fv(polyNos[BM_elem_index_get(efa)]); + glVertex3fv(vertexCos[BM_elem_index_get(l[0]->v)]); + glVertex3fv(vertexCos[BM_elem_index_get(l[1]->v)]); + glVertex3fv(vertexCos[BM_elem_index_get(l[2]->v)]); } else { - glNormal3fv(vertexNos[BM_GetIndex(l[0]->v)]); - glVertex3fv(vertexCos[BM_GetIndex(l[0]->v)]); - glNormal3fv(vertexNos[BM_GetIndex(l[1]->v)]); - glVertex3fv(vertexCos[BM_GetIndex(l[1]->v)]); - glNormal3fv(vertexNos[BM_GetIndex(l[2]->v)]); - glVertex3fv(vertexCos[BM_GetIndex(l[2]->v)]); + glNormal3fv(vertexNos[BM_elem_index_get(l[0]->v)]); + glVertex3fv(vertexCos[BM_elem_index_get(l[0]->v)]); + glNormal3fv(vertexNos[BM_elem_index_get(l[1]->v)]); + glVertex3fv(vertexCos[BM_elem_index_get(l[1]->v)]); + glNormal3fv(vertexNos[BM_elem_index_get(l[2]->v)]); + glVertex3fv(vertexCos[BM_elem_index_get(l[2]->v)]); } } @@ -737,16 +737,16 @@ static void emDM_drawMappedFaces( } } else { - BM_ElemIndex_Ensure(bmdm->tc->bm, BM_FACE); + BM_mesh_elem_index_ensure(bmdm->tc->bm, BM_FACE); for (i=0; i < tottri; i++) { BMLoop **l = looptris[i]; int drawSmooth; efa = l[0]->f; - drawSmooth= BM_TestHFlag(efa, BM_ELEM_SMOOTH); + drawSmooth= BM_elem_flag_test(efa, BM_ELEM_SMOOTH); - draw = setDrawOptions==NULL ? 1 : setDrawOptions(userData, BM_GetIndex(efa), &drawSmooth); + draw = setDrawOptions==NULL ? 1 : setDrawOptions(userData, BM_elem_index_get(efa), &drawSmooth); if (draw) { const GLenum poly_type= GL_TRIANGLES; /* BMESH NOTE, this is odd but keep it for now to match trunk */ if (draw==2) { /* enabled with stipple */ @@ -860,10 +860,10 @@ static void emDM_drawFacesTex_common( /* always use smooth shading even for flat faces, else vertex colors wont interpolate */ glShadeModel(GL_SMOOTH); - BM_ElemIndex_Ensure(bm, BM_FACE); + BM_mesh_elem_index_ensure(bm, BM_FACE); if (vertexCos) { - BM_ElemIndex_Ensure(bm, BM_VERT); + BM_mesh_elem_index_ensure(bm, BM_VERT); glBegin(GL_TRIANGLES); for (i=0; i<em->tottri; i++) { @@ -871,7 +871,7 @@ static void emDM_drawFacesTex_common( MTexPoly *tp= CustomData_bmesh_get(&bm->pdata, ls[0]->f->head.data, CD_MTEXPOLY); MTFace mtf = {{{0}}}; /*unsigned char *cp= NULL;*/ /*UNUSED*/ - int drawSmooth= BM_TestHFlag(ls[0]->f, BM_ELEM_SMOOTH); + int drawSmooth= BM_elem_flag_test(ls[0]->f, BM_ELEM_SMOOTH); int flag; efa = ls[0]->f; @@ -883,7 +883,7 @@ static void emDM_drawFacesTex_common( if (drawParams) flag= drawParams(&mtf, has_vcol, efa->mat_nr); else if (drawParamsMapped) - flag= drawParamsMapped(userData, BM_GetIndex(efa)); + flag= drawParamsMapped(userData, BM_elem_index_get(efa)); else flag= 1; @@ -895,53 +895,53 @@ static void emDM_drawFacesTex_common( } if (!drawSmooth) { - glNormal3fv(bmdm->polyNos[BM_GetIndex(efa)]); + glNormal3fv(bmdm->polyNos[BM_elem_index_get(efa)]); bmdm_get_tri_tex(bm, ls, luv, lcol, has_uv, has_vcol); glTexCoord2fv(luv[0]->uv); glColor3ub(lcol[0]->b, lcol[0]->g, lcol[0]->r); - glVertex3fv(vertexCos[BM_GetIndex(ls[0]->v)]); + glVertex3fv(vertexCos[BM_elem_index_get(ls[0]->v)]); glTexCoord2fv(luv[1]->uv); glColor3ub(lcol[1]->b, lcol[1]->g, lcol[1]->r); - glVertex3fv(vertexCos[BM_GetIndex(ls[1]->v)]); + glVertex3fv(vertexCos[BM_elem_index_get(ls[1]->v)]); glTexCoord2fv(luv[2]->uv); glColor3ub(lcol[2]->b, lcol[2]->g, lcol[2]->r); - glVertex3fv(vertexCos[BM_GetIndex(ls[2]->v)]); + glVertex3fv(vertexCos[BM_elem_index_get(ls[2]->v)]); } else { bmdm_get_tri_tex(bm, ls, luv, lcol, has_uv, has_vcol); glTexCoord2fv(luv[0]->uv); glColor3ub(lcol[0]->b, lcol[0]->g, lcol[0]->r); - glNormal3fv(vertexNos[BM_GetIndex(ls[0]->v)]); - glVertex3fv(vertexCos[BM_GetIndex(ls[0]->v)]); + glNormal3fv(vertexNos[BM_elem_index_get(ls[0]->v)]); + glVertex3fv(vertexCos[BM_elem_index_get(ls[0]->v)]); glTexCoord2fv(luv[1]->uv); glColor3ub(lcol[1]->b, lcol[1]->g, lcol[1]->r); - glNormal3fv(vertexNos[BM_GetIndex(ls[1]->v)]); - glVertex3fv(vertexCos[BM_GetIndex(ls[1]->v)]); + glNormal3fv(vertexNos[BM_elem_index_get(ls[1]->v)]); + glVertex3fv(vertexCos[BM_elem_index_get(ls[1]->v)]); glTexCoord2fv(luv[2]->uv); glColor3ub(lcol[2]->b, lcol[2]->g, lcol[2]->r); - glNormal3fv(vertexNos[BM_GetIndex(ls[2]->v)]); - glVertex3fv(vertexCos[BM_GetIndex(ls[2]->v)]); + glNormal3fv(vertexNos[BM_elem_index_get(ls[2]->v)]); + glVertex3fv(vertexCos[BM_elem_index_get(ls[2]->v)]); } } } glEnd(); } else { - BM_ElemIndex_Ensure(bm, BM_VERT); + BM_mesh_elem_index_ensure(bm, BM_VERT); for (i=0; i<em->tottri; i++) { BMLoop **ls = em->looptris[i]; MTexPoly *tp= CustomData_bmesh_get(&bm->pdata, ls[0]->f->head.data, CD_MTEXPOLY); MTFace mtf = {{{0}}}; /*unsigned char *cp= NULL;*/ /*UNUSED*/ - int drawSmooth= BM_TestHFlag(ls[0]->f, BM_ELEM_SMOOTH); + int drawSmooth= BM_elem_flag_test(ls[0]->f, BM_ELEM_SMOOTH); int flag; efa = ls[0]->f; @@ -953,7 +953,7 @@ static void emDM_drawFacesTex_common( if (drawParams) flag= drawParams(&mtf, has_vcol, efa->mat_nr); else if (drawParamsMapped) - flag= drawParamsMapped(userData, BM_GetIndex(efa)); + flag= drawParamsMapped(userData, BM_elem_index_get(efa)); else flag= 1; @@ -1067,11 +1067,11 @@ static void emDM_drawMappedFacesGLSL( /* always use smooth shading even for flat faces, else vertex colors wont interpolate */ glShadeModel(GL_SMOOTH); - BM_ElemIndex_Ensure(bm, BM_VERT | BM_FACE); + BM_mesh_elem_index_ensure(bm, BM_VERT | BM_FACE); #define PASSATTRIB(loop, eve, vert) { \ if (attribs.totorco) { \ - float *orco = attribs.orco.array[BM_GetIndex(eve)]; \ + float *orco = attribs.orco.array[BM_elem_index_get(eve)]; \ glVertexAttrib3fvARB(attribs.orco.glIndex, orco); \ } \ for (b = 0; b < attribs.tottface; b++) { \ @@ -1095,9 +1095,9 @@ static void emDM_drawMappedFacesGLSL( int drawSmooth; efa = ltri[0]->f; - drawSmooth= BM_TestHFlag(efa, BM_ELEM_SMOOTH); + drawSmooth= BM_elem_flag_test(efa, BM_ELEM_SMOOTH); - if (setDrawOptions && !setDrawOptions(userData, BM_GetIndex(efa))) + if (setDrawOptions && !setDrawOptions(userData, BM_elem_index_get(efa))) continue; new_matnr = efa->mat_nr + 1; @@ -1110,26 +1110,26 @@ static void emDM_drawMappedFacesGLSL( if (dodraw) { glBegin(GL_TRIANGLES); if (!drawSmooth) { - if (vertexCos) glNormal3fv(bmdm->polyNos[BM_GetIndex(efa)]); + if (vertexCos) glNormal3fv(bmdm->polyNos[BM_elem_index_get(efa)]); else glNormal3fv(efa->no); PASSATTRIB(ltri[0], ltri[0]->v, 0); - if (vertexCos) glVertex3fv(vertexCos[BM_GetIndex(ltri[0]->v)]); + if (vertexCos) glVertex3fv(vertexCos[BM_elem_index_get(ltri[0]->v)]); else glVertex3fv(ltri[0]->v->co); PASSATTRIB(ltri[1], ltri[1]->v, 1); - if (vertexCos) glVertex3fv(vertexCos[BM_GetIndex(ltri[1]->v)]); + if (vertexCos) glVertex3fv(vertexCos[BM_elem_index_get(ltri[1]->v)]); else glVertex3fv(ltri[1]->v->co); PASSATTRIB(ltri[2], ltri[2]->v, 2); - if (vertexCos) glVertex3fv(vertexCos[BM_GetIndex(ltri[2]->v)]); + if (vertexCos) glVertex3fv(vertexCos[BM_elem_index_get(ltri[2]->v)]); else glVertex3fv(ltri[2]->v->co); } else { PASSATTRIB(ltri[0], ltri[0]->v, 0); if (vertexCos) { - glNormal3fv(vertexNos[BM_GetIndex(ltri[0]->v)]); - glVertex3fv(vertexCos[BM_GetIndex(ltri[0]->v)]); + glNormal3fv(vertexNos[BM_elem_index_get(ltri[0]->v)]); + glVertex3fv(vertexCos[BM_elem_index_get(ltri[0]->v)]); } else { glNormal3fv(ltri[0]->v->no); @@ -1138,8 +1138,8 @@ static void emDM_drawMappedFacesGLSL( PASSATTRIB(ltri[1], ltri[1]->v, 1); if (vertexCos) { - glNormal3fv(vertexNos[BM_GetIndex(ltri[1]->v)]); - glVertex3fv(vertexCos[BM_GetIndex(ltri[1]->v)]); + glNormal3fv(vertexNos[BM_elem_index_get(ltri[1]->v)]); + glVertex3fv(vertexCos[BM_elem_index_get(ltri[1]->v)]); } else { glNormal3fv(ltri[1]->v->no); @@ -1148,8 +1148,8 @@ static void emDM_drawMappedFacesGLSL( PASSATTRIB(ltri[2], ltri[2]->v, 2); if (vertexCos) { - glNormal3fv(vertexNos[BM_GetIndex(ltri[2]->v)]); - glVertex3fv(vertexCos[BM_GetIndex(ltri[2]->v)]); + glNormal3fv(vertexNos[BM_elem_index_get(ltri[2]->v)]); + glVertex3fv(vertexCos[BM_elem_index_get(ltri[2]->v)]); } else { glNormal3fv(ltri[2]->v->no); @@ -1190,11 +1190,11 @@ static void emDM_drawMappedFacesMat( /* always use smooth shading even for flat faces, else vertex colors wont interpolate */ glShadeModel(GL_SMOOTH); - BM_ElemIndex_Ensure(bm, BM_VERT); + BM_mesh_elem_index_ensure(bm, BM_VERT); #define PASSATTRIB(loop, eve, vert) { \ if (attribs.totorco) { \ - float *orco = attribs.orco.array[BM_GetIndex(eve)]; \ + float *orco = attribs.orco.array[BM_elem_index_get(eve)]; \ glVertexAttrib3fvARB(attribs.orco.glIndex, orco); \ } \ for (b = 0; b < attribs.tottface; b++) { \ @@ -1217,10 +1217,10 @@ static void emDM_drawMappedFacesMat( int drawSmooth; efa = ltri[0]->f; - drawSmooth = BM_TestHFlag(efa, BM_ELEM_SMOOTH); + drawSmooth = BM_elem_flag_test(efa, BM_ELEM_SMOOTH); /* face hiding */ - if (setFace && !setFace(userData, BM_GetIndex(efa))) + if (setFace && !setFace(userData, BM_elem_index_get(efa))) continue; /* material */ @@ -1233,27 +1233,27 @@ static void emDM_drawMappedFacesMat( /* face */ glBegin(GL_TRIANGLES); if (!drawSmooth) { - if (vertexCos) glNormal3fv(bmdm->polyNos[BM_GetIndex(efa)]); + if (vertexCos) glNormal3fv(bmdm->polyNos[BM_elem_index_get(efa)]); else glNormal3fv(efa->no); PASSATTRIB(ltri[0], ltri[0]->v, 0); - if (vertexCos) glVertex3fv(vertexCos[BM_GetIndex(ltri[0]->v)]); + if (vertexCos) glVertex3fv(vertexCos[BM_elem_index_get(ltri[0]->v)]); else glVertex3fv(ltri[0]->v->co); PASSATTRIB(ltri[1], ltri[1]->v, 1); - if (vertexCos) glVertex3fv(vertexCos[BM_GetIndex(ltri[1]->v)]); + if (vertexCos) glVertex3fv(vertexCos[BM_elem_index_get(ltri[1]->v)]); else glVertex3fv(ltri[1]->v->co); PASSATTRIB(ltri[2], ltri[2]->v, 2); - if (vertexCos) glVertex3fv(vertexCos[BM_GetIndex(ltri[2]->v)]); + if (vertexCos) glVertex3fv(vertexCos[BM_elem_index_get(ltri[2]->v)]); else glVertex3fv(ltri[2]->v->co); } else { PASSATTRIB(ltri[0], ltri[0]->v, 0); if (vertexCos) { - glNormal3fv(vertexNos[BM_GetIndex(ltri[0]->v)]); - glVertex3fv(vertexCos[BM_GetIndex(ltri[0]->v)]); + glNormal3fv(vertexNos[BM_elem_index_get(ltri[0]->v)]); + glVertex3fv(vertexCos[BM_elem_index_get(ltri[0]->v)]); } else { glNormal3fv(ltri[0]->v->no); @@ -1262,8 +1262,8 @@ static void emDM_drawMappedFacesMat( PASSATTRIB(ltri[1], ltri[1]->v, 1); if (vertexCos) { - glNormal3fv(vertexNos[BM_GetIndex(ltri[1]->v)]); - glVertex3fv(vertexCos[BM_GetIndex(ltri[1]->v)]); + glNormal3fv(vertexNos[BM_elem_index_get(ltri[1]->v)]); + glVertex3fv(vertexCos[BM_elem_index_get(ltri[1]->v)]); } else { glNormal3fv(ltri[1]->v->no); @@ -1272,8 +1272,8 @@ static void emDM_drawMappedFacesMat( PASSATTRIB(ltri[2], ltri[2]->v, 2); if (vertexCos) { - glNormal3fv(vertexNos[BM_GetIndex(ltri[2]->v)]); - glVertex3fv(vertexCos[BM_GetIndex(ltri[2]->v)]); + glNormal3fv(vertexNos[BM_elem_index_get(ltri[2]->v)]); + glVertex3fv(vertexCos[BM_elem_index_get(ltri[2]->v)]); } else { glNormal3fv(ltri[2]->v->no); @@ -1293,8 +1293,8 @@ static void emDM_getMinMax(DerivedMesh *dm, float min_r[3], float max_r[3]) int i; if (bmdm->tc->bm->totvert) { - eve = BMIter_New(&iter, bmdm->tc->bm, BM_VERTS_OF_MESH, NULL); - for (i=0; eve; eve=BMIter_Step(&iter), i++) { + eve = BM_iter_new(&iter, bmdm->tc->bm, BM_VERTS_OF_MESH, NULL); + for (i=0; eve; eve=BM_iter_step(&iter), i++) { if (bmdm->vertexCos) { DO_MINMAX(bmdm->vertexCos[i], min_r, max_r); } @@ -1348,10 +1348,10 @@ static int bmvert_to_mvert(BMesh *bm, BMVert *ev, MVert *vert_r) normal_float_to_short_v3(vert_r->no, ev->no); - vert_r->flag = BM_Vert_Flag_To_MEFlag(ev); + vert_r->flag = BM_vert_flag_to_mflag(ev); if (CustomData_has_layer(&bm->vdata, CD_BWEIGHT)) { - vert_r->bweight = (unsigned char) (BM_GetCDf(&bm->vdata, ev, CD_BWEIGHT)*255.0f); + vert_r->bweight = (unsigned char) (BM_elem_float_data_get(&bm->vdata, ev, CD_BWEIGHT)*255.0f); } return 1; @@ -1384,17 +1384,17 @@ static void emDM_getEdge(DerivedMesh *dm, int index, MEdge *edge_r) e = bmdm->etable[index]; if (CustomData_has_layer(&bm->edata, CD_BWEIGHT)) { - edge_r->bweight = (unsigned char) (BM_GetCDf(&bm->edata, e, CD_BWEIGHT)*255.0f); + edge_r->bweight = (unsigned char) (BM_elem_float_data_get(&bm->edata, e, CD_BWEIGHT)*255.0f); } if (CustomData_has_layer(&bm->edata, CD_CREASE)) { - edge_r->crease = (unsigned char) (BM_GetCDf(&bm->edata, e, CD_CREASE)*255.0f); + edge_r->crease = (unsigned char) (BM_elem_float_data_get(&bm->edata, e, CD_CREASE)*255.0f); } - edge_r->flag = BM_Edge_Flag_To_MEFlag(e); + edge_r->flag = BM_edge_flag_to_mflag(e); - edge_r->v1 = BM_GetIndex(e->v1); - edge_r->v2 = BM_GetIndex(e->v2); + edge_r->v1 = BM_elem_index_get(e->v1); + edge_r->v2 = BM_elem_index_get(e->v2); } static void emDM_getTessFace(DerivedMesh *dm, int index, MFace *face_r) @@ -1413,11 +1413,11 @@ static void emDM_getTessFace(DerivedMesh *dm, int index, MFace *face_r) ef = l[0]->f; face_r->mat_nr = (unsigned char) ef->mat_nr; - face_r->flag = BM_Face_Flag_To_MEFlag(ef); + face_r->flag = BM_face_flag_to_mflag(ef); - face_r->v1 = BM_GetIndex(l[0]->v); - face_r->v2 = BM_GetIndex(l[1]->v); - face_r->v3 = BM_GetIndex(l[2]->v); + face_r->v1 = BM_elem_index_get(l[0]->v); + face_r->v2 = BM_elem_index_get(l[1]->v); + face_r->v3 = BM_elem_index_get(l[2]->v); face_r->v4 = 0; test_index_face(face_r, NULL, 0, 3); @@ -1429,16 +1429,16 @@ static void emDM_copyVertArray(DerivedMesh *dm, MVert *vert_r) BMVert *ev; BMIter iter; - ev = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL); - for ( ; ev; ev = BMIter_Step(&iter), ++vert_r) { + ev = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL); + for ( ; ev; ev = BM_iter_step(&iter), ++vert_r) { copy_v3_v3(vert_r->co, ev->co); normal_float_to_short_v3(vert_r->no, ev->no); - vert_r->flag = BM_Vert_Flag_To_MEFlag(ev); + vert_r->flag = BM_vert_flag_to_mflag(ev); if (CustomData_has_layer(&bm->vdata, CD_BWEIGHT)) { - vert_r->bweight = (unsigned char) (BM_GetCDf(&bm->vdata, ev, CD_BWEIGHT)*255.0f); + vert_r->bweight = (unsigned char) (BM_elem_float_data_get(&bm->vdata, ev, CD_BWEIGHT)*255.0f); } } } @@ -1451,22 +1451,22 @@ static void emDM_copyEdgeArray(DerivedMesh *dm, MEdge *edge_r) int has_bweight = CustomData_has_layer(&bm->edata, CD_BWEIGHT); int has_crease = CustomData_has_layer(&bm->edata, CD_CREASE); - BM_ElemIndex_Ensure(bm, BM_VERT); + BM_mesh_elem_index_ensure(bm, BM_VERT); - ee = BMIter_New(&iter, bm, BM_EDGES_OF_MESH, NULL); - for ( ; ee; ee=BMIter_Step(&iter), edge_r++) { + ee = BM_iter_new(&iter, bm, BM_EDGES_OF_MESH, NULL); + for ( ; ee; ee=BM_iter_step(&iter), edge_r++) { if (has_bweight) { - edge_r->bweight = (unsigned char) (BM_GetCDf(&bm->edata, ee, CD_BWEIGHT)*255.0f); + edge_r->bweight = (unsigned char) (BM_elem_float_data_get(&bm->edata, ee, CD_BWEIGHT)*255.0f); } if (has_crease) { - edge_r->crease = (unsigned char) (BM_GetCDf(&bm->edata, ee, CD_CREASE)*255.0f); + edge_r->crease = (unsigned char) (BM_elem_float_data_get(&bm->edata, ee, CD_CREASE)*255.0f); } - edge_r->flag = BM_Edge_Flag_To_MEFlag(ee); + edge_r->flag = BM_edge_flag_to_mflag(ee); - edge_r->v1 = BM_GetIndex(ee->v1); - edge_r->v2 = BM_GetIndex(ee->v2); + edge_r->v1 = BM_elem_index_get(ee->v1); + edge_r->v2 = BM_elem_index_get(ee->v2); } } @@ -1478,7 +1478,7 @@ static void emDM_copyTessFaceArray(DerivedMesh *dm, MFace *face_r) BMLoop **l; int i; - BM_ElemIndex_Ensure(bm, BM_VERT); + BM_mesh_elem_index_ensure(bm, BM_VERT); for (i=0; i<bmdm->tc->tottri; i++, face_r++) { l = bmdm->tc->looptris[i]; @@ -1486,11 +1486,11 @@ static void emDM_copyTessFaceArray(DerivedMesh *dm, MFace *face_r) face_r->mat_nr = (unsigned char) ef->mat_nr; - face_r->flag = BM_Face_Flag_To_MEFlag(ef); + face_r->flag = BM_face_flag_to_mflag(ef); - face_r->v1 = BM_GetIndex(l[0]->v); - face_r->v2 = BM_GetIndex(l[1]->v); - face_r->v3 = BM_GetIndex(l[2]->v); + face_r->v1 = BM_elem_index_get(l[0]->v); + face_r->v2 = BM_elem_index_get(l[1]->v); + face_r->v3 = BM_elem_index_get(l[2]->v); face_r->v4 = 0; test_index_face(face_r, NULL, 0, 3); @@ -1506,12 +1506,12 @@ static void emDM_copyLoopArray(DerivedMesh *dm, MLoop *loop_r) BMFace *f; BMLoop *l; - BM_ElemIndex_Ensure(bm, BM_VERT | BM_EDGE); + 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) { - loop_r->v = BM_GetIndex(l->v); - loop_r->e = BM_GetIndex(l->e); + loop_r->v = BM_elem_index_get(l->v); + loop_r->e = BM_elem_index_get(l->e); loop_r++; } } @@ -1527,7 +1527,7 @@ static void emDM_copyPolyArray(DerivedMesh *dm, MPoly *poly_r) i = 0; BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) { - poly_r->flag = BM_Face_Flag_To_MEFlag(f); + poly_r->flag = BM_face_flag_to_mflag(f); poly_r->loopstart = i; poly_r->totloop = f->len; poly_r->mat_nr = f->mat_nr; @@ -1722,8 +1722,8 @@ DerivedMesh *getEditDerivedBMesh( DM_add_vert_layer(&bmdm->dm, CD_MDEFORMVERT, CD_CALLOC, NULL); - eve = BMIter_New(&iter, bmdm->tc->bm, BM_VERTS_OF_MESH, NULL); - for (i=0; eve; eve=BMIter_Step(&iter), i++) + eve = BM_iter_new(&iter, bmdm->tc->bm, BM_VERTS_OF_MESH, NULL); + for (i=0; eve; eve=BM_iter_step(&iter), i++) DM_set_vert_data(&bmdm->dm, i, CD_MDEFORMVERT, CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_MDEFORMVERT)); } @@ -1735,24 +1735,24 @@ DerivedMesh *getEditDerivedBMesh( BMIter viter; int i; - BM_ElemIndex_Ensure(bm, BM_VERT); + BM_mesh_elem_index_ensure(bm, BM_VERT); bmdm->vertexNos = MEM_callocN(sizeof(*bmdm->vertexNos) * bm->totvert, "bmdm_vno"); bmdm->polyNos = MEM_mallocN(sizeof(*bmdm->polyNos)*bm->totface, "bmdm_pno"); i = 0; BM_ITER(efa, &fiter, bm, BM_FACES_OF_MESH, NULL) { - BM_SetIndex(efa, i); /* set_inline */ - BM_Face_UpdateNormal_VertexCos(bm, efa, bmdm->polyNos[i], vertexCos); + BM_elem_index_set(efa, i); /* set_inline */ + BM_face_normal_update_vcos(bm, efa, bmdm->polyNos[i], vertexCos); i++; } bm->elem_index_dirty &= ~BM_FACE; - eve=BMIter_New(&viter, bm, BM_VERTS_OF_MESH, NULL); - for (i=0; eve; eve=BMIter_Step(&viter), i++) { + 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) { - add_v3_v3(no, bmdm->polyNos[BM_GetIndex(efa)]); + add_v3_v3(no, bmdm->polyNos[BM_elem_index_get(efa)]); } /* following Mesh convention; we use vertex coordinate itself diff --git a/source/blender/blenkernel/intern/key.c b/source/blender/blenkernel/intern/key.c index 2f05d14bdd5..84af6200f94 100644 --- a/source/blender/blenkernel/intern/key.c +++ b/source/blender/blenkernel/intern/key.c @@ -1082,8 +1082,8 @@ static float *get_weights_array(Object *ob, char *vgroup) weights= MEM_callocN(totvert*sizeof(float), "weights"); if(em) { - eve = BMIter_New(&iter, em->bm, BM_VERTS_OF_MESH, NULL); - for (i=0; eve; eve=BMIter_Step(&iter), i++) { + eve = BM_iter_new(&iter, em->bm, BM_VERTS_OF_MESH, NULL); + for (i=0; eve; eve=BM_iter_step(&iter), i++) { dvert= CustomData_bmesh_get(&em->bm->vdata, eve->head.data, CD_MDEFORMVERT); if(dvert) { diff --git a/source/blender/blenkernel/intern/mesh.c b/source/blender/blenkernel/intern/mesh.c index a0419ee6343..b907fd1cbae 100644 --- a/source/blender/blenkernel/intern/mesh.c +++ b/source/blender/blenkernel/intern/mesh.c @@ -528,9 +528,9 @@ BMesh *BKE_mesh_to_bmesh(Mesh *me, Object *ob) BMesh *bm; int allocsize[4] = {512,512,2048,512}; - bm = BM_Make_Mesh(ob, allocsize); + bm = BM_mesh_create(ob, allocsize); - BMO_CallOpf(bm, "mesh_to_bmesh mesh=%p object=%p set_shapekey=%i", me, ob, 1); + BMO_op_callf(bm, "mesh_to_bmesh mesh=%p object=%p set_shapekey=%i", me, ob, 1); return bm; } diff --git a/source/blender/blenkernel/intern/modifiers_bmesh.c b/source/blender/blenkernel/intern/modifiers_bmesh.c index e46d8dd8bce..466b493098d 100644 --- a/source/blender/blenkernel/intern/modifiers_bmesh.c +++ b/source/blender/blenkernel/intern/modifiers_bmesh.c @@ -61,7 +61,7 @@ BMEditMesh *CDDM_To_BMesh(Object *ob, DerivedMesh *dm, BMEditMesh *existing, int int i, j, k, totvert, totedge, totface; if (em) bm = em->bm; - else bm = BM_Make_Mesh(ob, allocsize); + else bm = BM_mesh_create(ob, allocsize); bmold = *bm; @@ -81,9 +81,9 @@ BMEditMesh *CDDM_To_BMesh(Object *ob, DerivedMesh *dm, BMEditMesh *existing, int /*do verts*/ mv = mvert = dm->dupVertArray(dm); for (i = 0; i < totvert; i++, mv++) { - v = BM_Make_Vert(bm, mv->co, NULL); + v = BM_vert_create(bm, mv->co, NULL); normal_short_to_float_v3(v->no, mv->no); - v->head.hflag = BM_Vert_Flag_From_MEFlag(mv->flag); + v->head.hflag = BM_vert_flag_from_mflag(mv->flag); CustomData_to_bmesh_block(&dm->vertData, &bm->vdata, i, &v->head.data); vtable[i] = v; @@ -93,9 +93,9 @@ BMEditMesh *CDDM_To_BMesh(Object *ob, DerivedMesh *dm, BMEditMesh *existing, int /*do edges*/ me = medge = dm->dupEdgeArray(dm); for (i = 0; i < totedge; i++, me++) { - e = BM_Make_Edge(bm, vtable[me->v1], vtable[me->v2], NULL, FALSE); + e = BM_edge_create(bm, vtable[me->v1], vtable[me->v2], NULL, FALSE); - e->head.hflag = BM_Edge_Flag_From_MEFlag(me->flag); + e->head.hflag = BM_edge_flag_from_mflag(me->flag); CustomData_to_bmesh_block(&dm->edgeData, &bm->edata, i, &e->head.data); etable[i] = e; @@ -121,18 +121,18 @@ BMEditMesh *CDDM_To_BMesh(Object *ob, DerivedMesh *dm, BMEditMesh *existing, int edges[j] = etable[ml->e]; } - f = BM_Make_Ngon(bm, verts[0], verts[1], edges, mp->totloop, FALSE); + f = BM_face_create_ngon(bm, verts[0], verts[1], edges, mp->totloop, FALSE); if (!f) continue; - f->head.hflag = BM_Face_Flag_From_MEFlag(mp->flag); + f->head.hflag = BM_face_flag_from_mflag(mp->flag); f->mat_nr = mp->mat_nr; - l = BMIter_New(&liter, bm, BM_LOOPS_OF_FACE, f); + l = BM_iter_new(&liter, bm, BM_LOOPS_OF_FACE, f); k = mp->loopstart; - for (j = 0; l; l = BMIter_Step(&liter), k++) { + for (j = 0; l; l = BM_iter_step(&liter), k++) { CustomData_to_bmesh_block(&dm->loopData, &bm->ldata, k, &l->head.data); } diff --git a/source/blender/bmesh/bmesh.h b/source/blender/bmesh/bmesh.h index 4d760fb49a3..0e0546f4875 100644 --- a/source/blender/bmesh/bmesh.h +++ b/source/blender/bmesh/bmesh.h @@ -112,56 +112,56 @@ void bmesh_error(void); /* Mesh Level Ops */ /* ob is needed by multires */ -BMesh *BM_Make_Mesh(struct Object *ob, int allocsize[4]); -BMesh *BM_Copy_Mesh(BMesh *bmold); -void BM_Free_Mesh(BMesh *bm); +BMesh *BM_mesh_create(struct Object *ob, int allocsize[4]); +BMesh *BM_mesh_copy(BMesh *bmold); +void BM_mesh_free(BMesh *bm); /* frees mesh, but not actual BMesh struct */ -void BM_Free_Mesh_Data(BMesh *bm); -void BM_Compute_Normals(BMesh *bm); +void BM_mesh_data_free(BMesh *bm); +void BM_mesh_normals_update(BMesh *bm); /* Construction */ -BMVert *BM_Make_Vert(BMesh *bm, const float co[3], const BMVert *example); -BMEdge *BM_Make_Edge(BMesh *bm, BMVert *v1, BMVert *v2, const BMEdge *example, int nodouble); -BMFace *BM_Make_Face(BMesh *bm, BMVert **verts, BMEdge **edges, const int len, int nodouble); +BMVert *BM_vert_create(BMesh *bm, const float co[3], const BMVert *example); +BMEdge *BM_edge_create(BMesh *bm, BMVert *v1, BMVert *v2, const BMEdge *example, int nodouble); +BMFace *BM_face_create(BMesh *bm, BMVert **verts, BMEdge **edges, const int len, int nodouble); -BMFace *BM_Make_Face_QuadTri_v(BMesh *bm, - BMVert **verts, int len, - const BMFace *example, const int nodouble); +BMFace *BM_face_create_quad_tri_v(BMesh *bm, + BMVert **verts, int len, + const BMFace *example, const int nodouble); -/* easier to use version of BM_Make_Face_QuadTri_v. +/* easier to use version of BM_face_create_quad_tri_v. * creates edges if necassary. */ -BMFace *BM_Make_Face_QuadTri(BMesh *bm, BMVert *v1, BMVert *v2, BMVert *v3, BMVert *v4, - const BMFace *example, const int nodouble); +BMFace *BM_face_create_quad_tri(BMesh *bm, BMVert *v1, BMVert *v2, BMVert *v3, BMVert *v4, + const BMFace *example, const int nodouble); /* makes an ngon from an unordered list of edges. v1 and v2 must be the verts * defining edges[0], and define the winding of the new face. */ -BMFace *BM_Make_Ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, int len, int nodouble); +BMFace *BM_face_create_ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, int len, int nodouble); /* stuff for dealing with header flags */ -BM_INLINE char BM_TestHFlag(const void *element, const char hflag); +BM_INLINE char BM_elem_flag_test(const void *element, const char hflag); /* stuff for dealing with header flags */ -BM_INLINE void BM_SetHFlag(void *element, const char hflag); +BM_INLINE void BM_elem_flag_set(void *element, const char hflag); /* stuff for dealing with header flags */ -BM_INLINE void BM_ClearHFlag(void *element, const char hflag); +BM_INLINE void BM_elem_flag_clear(void *element, const char hflag); -/* stuff for dealing BM_ToggleHFlag header flags */ -BM_INLINE void BM_ToggleHFlag(void *element, const char hflag); -BM_INLINE void BM_MergeHFlag(void *element_a, void *element_b); +/* stuff for dealing BM_elem_flag_toggle header flags */ +BM_INLINE void BM_elem_flag_toggle(void *element, const char hflag); +BM_INLINE void BM_elem_flag_merge(void *element_a, void *element_b); -/* notes on BM_SetIndex(...) usage, +/* notes on BM_elem_index_set(...) usage, * Set index is sometimes abused as temp storage, other times we cant be * sure if the index values are valid because certain operations have modified * the mesh structure. * - * To set the elements to valid indicies 'BM_ElemIndex_Ensure' should be used + * To set the elements to valid indicies 'BM_mesh_elem_index_ensure' should be used * rather then adding inline loops, however there are cases where we still * set the index directly * * In an attempt to manage this, here are 3 tags Im adding to uses of - * 'BM_SetIndex' + * 'BM_elem_index_set' * * - 'set_inline' -- since the data is already being looped over set to a * valid value inline. @@ -180,79 +180,82 @@ BM_INLINE void BM_MergeHFlag(void *element_a, void *element_b); * assume each case they are dirty. * - campbell */ -BM_INLINE void BM_SetIndex(void *element, const int index); -BM_INLINE int BM_GetIndex(const void *element); +BM_INLINE void BM_elem_index_set(void *element, const int index); +BM_INLINE int BM_elem_index_get(const void *element); + +/* todo */ +BMFace *BM_face_copy(BMesh *bm, BMFace *f, int copyedges, int copyverts); /* copies loop data from adjacent faces */ -void BM_Face_CopyShared(BMesh *bm, BMFace *f); +void BM_face_copy_shared(BMesh *bm, BMFace *f); /* copies attributes, e.g. customdata, header flags, etc, from one element * to another of the same type.*/ -void BM_Copy_Attributes(BMesh *source_mesh, BMesh *target_mesh, const void *source, void *target); +void BM_elem_copy_attrs(BMesh *source_mesh, BMesh *target_mesh, const void *source, void *target); /* Modification */ /* join two adjacent faces together along an edge. note that * the faces must only be joined by on edge. e is the edge you * wish to dissolve.*/ -BMFace *BM_Join_TwoFaces(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e); +BMFace *BM_faces_join_pair(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e); /* generic, flexible join faces function; note that most everything uses - * this, including BM_Join_TwoFaces*/ -BMFace *BM_Join_Faces(BMesh *bm, BMFace **faces, int totface); + * this, including BM_faces_join_pair */ +BMFace *BM_faces_join(BMesh *bm, BMFace **faces, int totface); /* split a face along two vertices. returns the newly made face, and sets * the nl member to a loop in the newly created edge.*/ -BMFace *BM_Split_Face(BMesh *bm, BMFace *f, +BMFace *BM_face_split(BMesh *bm, BMFace *f, BMVert *v1, BMVert *v2, struct BMLoop **nl, BMEdge *example); /* these 2 functions are very similar */ -BMEdge* BM_Collapse_Vert_Faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac, const int join_faces); -BMEdge* BM_Collapse_Vert_Edges(BMesh *bm, BMEdge *ke, BMVert *kv); +BMEdge* BM_vert_collapse_faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac, const int join_faces); +BMEdge* BM_vert_collapse_edges(BMesh *bm, BMEdge *ke, BMVert *kv); /* splits an edge. ne is set to the new edge created. */ -BMVert *BM_Split_Edge(BMesh *bm, BMVert *v, BMEdge *e, BMEdge **ne, float percent); +BMVert *BM_edge_split(BMesh *bm, BMVert *v, BMEdge *e, BMEdge **ne, float percent); -/* split an edge multiple times evenly*/ -BMVert *BM_Split_Edge_Multi(BMesh *bm, BMEdge *e, int numcuts); +/* split an edge multiple times evenly */ +BMVert *BM_edge_split_n(BMesh *bm, BMEdge *e, int numcuts); /* connect two verts together, through a face they share. this function may * be removed in the future. */ -BMEdge *BM_Connect_Verts(BMesh *bm, BMVert *v1, BMVert *v2, BMFace **nf); +BMEdge *BM_verts_connect(BMesh *bm, BMVert *v1, BMVert *v2, BMFace **nf); /* rotates an edge topologically, either clockwise (if ccw=0) or counterclockwise * (if ccw is 1). */ -BMEdge *BM_Rotate_Edge(BMesh *bm, BMEdge *e, int ccw); +BMEdge *BM_edge_rotate(BMesh *bm, BMEdge *e, int ccw); /* Rip a single face from a vertex fan */ -BMVert *BM_Rip_Vertex(BMesh *bm, BMFace *sf, BMVert *sv); +BMVert *BM_vert_rip(BMesh *bm, BMFace *sf, BMVert *sv); /*updates a face normal*/ -void BM_Face_UpdateNormal(BMesh *bm, BMFace *f); -void BM_Face_UpdateNormal_VertexCos(BMesh *bm, BMFace *f, float no[3], float (*vertexCos)[3]); +void BM_face_normal_update(BMesh *bm, BMFace *f); +void BM_face_normal_update_vcos(BMesh *bm, BMFace *f, float no[3], float (*vertexCos)[3]); /*updates face and vertex normals incident on an edge*/ -void BM_Edge_UpdateNormals(BMesh *bm, BMEdge *e); +void BM_edge_normals_update(BMesh *bm, BMEdge *e); /*update a vert normal (but not the faces incident on it)*/ -void BM_Vert_UpdateNormal(BMesh *bm, BMVert *v); -void BM_Vert_UpdateAllNormals(BMesh *bm, BMVert *v); +void BM_vert_normal_update(BMesh *bm, BMVert *v); +void BM_vert_normal_update_all(BMesh *bm, BMVert *v); -void BM_flip_normal(BMesh *bm, BMFace *f); +void BM_face_normal_flip(BMesh *bm, BMFace *f); /*dissolves all faces around a vert, and removes it.*/ -int BM_Dissolve_Disk(BMesh *bm, BMVert *v); +int BM_disk_dissolve(BMesh *bm, BMVert *v); -/*dissolves vert, in more situations then BM_Dissolve_Disk - (e.g. if the vert is part of a wire edge, etc).*/ -int BM_Dissolve_Vert(BMesh *bm, BMVert *v); +/* dissolves vert, in more situations then BM_disk_dissolve + * (e.g. if the vert is part of a wire edge, etc).*/ +int BM_vert_dissolve(BMesh *bm, BMVert *v); /* Projects co onto face f, and returns true if it is inside * the face bounds. Note that this uses a best-axis projection * test, instead of projecting co directly into f's orientation * space, so there might be accuracy issues.*/ -int BM_Point_In_Face(BMesh *bm, BMFace *f, const float co[3]); +int BM_face_point_inside_test(BMesh *bm, BMFace *f, const float co[3]); /* Interpolation */ @@ -266,68 +269,42 @@ void BM_loop_interp_from_face(BMesh *bm, BMLoop *target, BMFace *source, int do_vertex, int do_multires); /* smoothes boundaries between multires grids, including some borders in adjacent faces */ -void BM_multires_smooth_bounds(BMesh *bm, BMFace *f); +void BM_face_multires_bounds_smooth(BMesh *bm, BMFace *f); /* project the multires grid in target onto source's set of multires grids */ void BM_loop_interp_multires(BMesh *bm, BMLoop *target, BMFace *source); void BM_vert_interp_from_face(BMesh *bm, BMVert *v, BMFace *source); -void BM_Data_Interp_From_Verts (BMesh *bm, BMVert *v1, BMVert *v2, BMVert *v, float fac); -void BM_Data_Facevert_Edgeinterp (BMesh *bm, BMVert *v1, BMVert *v2, BMVert *v, struct BMEdge *e1, float fac); -void BM_add_data_layer (BMesh *em, CustomData *data, int type); -void BM_add_data_layer_named (BMesh *bm, CustomData *data, int type, const char *name); -void BM_free_data_layer (BMesh *em, CustomData *data, int type); -void BM_free_data_layer_n(BMesh *bm, CustomData *data, int type, int n); -float BM_GetCDf(struct CustomData *cd, void *element, int type); -void BM_SetCDf(struct CustomData *cd, void *element, int type, float val); +void BM_data_interp_from_verts(BMesh *bm, BMVert *v1, BMVert *v2, BMVert *v, float fac); +void BM_data_interp_face_vert_edge(BMesh *bm, BMVert *v1, BMVert *v2, BMVert *v, struct BMEdge *e1, float fac); +void BM_data_layer_add(BMesh *em, CustomData *data, int type); +void BM_data_layer_add_named(BMesh *bm, CustomData *data, int type, const char *name); +void BM_data_layer_free(BMesh *em, CustomData *data, int type); +void BM_data_layer_free_n(BMesh *bm, CustomData *data, int type, int n); +float BM_elem_float_data_get(struct CustomData *cd, void *element, int type); +void BM_elem_float_data_set(struct CustomData *cd, void *element, int type, const float val); /* get the area of the face */ -float BM_Compute_Face_Area(BMesh *bm, BMFace *f); +float BM_face_area_calc(BMesh *bm, BMFace *f); /* computes the centroid of a face, using the center of the bounding box */ -void BM_Compute_Face_CenterBounds(BMesh *bm, BMFace *f, float center[3]); +void BM_face_center_bounds_calc(BMesh *bm, BMFace *f, float center[3]); /* computes the centroid of a face, using the mean average */ -void BM_Compute_Face_CenterMean(BMesh *bm, BMFace *f, float center[3]); +void BM_face_center_mean_calc(BMesh *bm, BMFace *f, float center[3]); -void BM_SelectMode_Flush(BMesh *bm); +void BM_mesh_select_mode_flush(BMesh *bm); /* mode independant flushing up/down */ -void BM_DeSelect_Flush(BMesh *bm); -void BM_Select_Flush(BMesh *bm); - -/*convert an editmesh to a bmesh*/ -BMesh *editmesh_to_bmesh(struct EditMesh *em); - -/* initializes editmesh to bmesh operator, but doesn't execute. - * this is used in situations where you need to get access to the - * conversion operator's editmesh->bmesh mapping slot (e.g. if you - * need to find the bmesh edge that corrusponds to a specific editmesh - * edge).*/ -BMesh *init_editmesh_to_bmesh(struct EditMesh *em, struct BMOperator *op); - -/* converts a bmesh to an editmesh */ -struct EditMesh *bmesh_to_editmesh(BMesh *bm); - -/* unused, type spesific functions below */ -#if 0 -/*convert between bmesh and Mesh flags*/ -short BMFlags_To_MEFlags(void *element); - -/* convert between Mesh and bmesh flags - * type must be BM_VERT/BM_EDGE/BM_FACE, - * and represents the type of the element - * parameter (the three defines map to - * MVert, MEdge, and MPoly, respectively). */ -char MEFlags_To_BMFlags(const short hflag, const char htype); -#endif +void BM_mesh_deselect_flush(BMesh *bm); +void BM_mesh_select_flush(BMesh *bm); /* flag conversion funcs */ -char BM_Face_Flag_From_MEFlag(const char mflag); -char BM_Edge_Flag_From_MEFlag(const short mflag); -char BM_Vert_Flag_From_MEFlag(const char mflag); +char BM_face_flag_from_mflag(const char mflag); +char BM_edge_flag_from_mflag(const short mflag); +char BM_vert_flag_from_mflag(const char mflag); /* reverse */ -char BM_Face_Flag_To_MEFlag(BMFace *f); -short BM_Edge_Flag_To_MEFlag(BMEdge *e); -char BM_Vert_Flag_To_MEFlag(BMVert *v); +char BM_face_flag_to_mflag(BMFace *f); +short BM_edge_flag_to_mflag(BMEdge *e); +char BM_vert_flag_to_mflag(BMVert *v); /* convert MLoop*** in a bmface to mtface and mcol in @@ -335,30 +312,30 @@ char BM_Vert_Flag_To_MEFlag(BMVert *v); void BM_loops_to_corners(BMesh *bm, struct Mesh *me, int findex, BMFace *f, int numTex, int numCol); -void BM_Kill_Loop(BMesh *bm, BMLoop *l); -void BM_Kill_Face(BMesh *bm, BMFace *f); -void BM_Kill_Edge(BMesh *bm, BMEdge *e); -void BM_Kill_Vert(BMesh *bm, BMVert *v); +void BM_loop_kill(BMesh *bm, BMLoop *l); +void BM_face_kill(BMesh *bm, BMFace *f); +void BM_edge_kill(BMesh *bm, BMEdge *e); +void BM_vert_kill(BMesh *bm, BMVert *v); /* kills all edges associated with f, along with any other faces containing * those edges*/ -void BM_Kill_Face_Edges(BMesh *bm, BMFace *f); +void BM_face_edges_kill(BMesh *bm, BMFace *f); /* kills all verts associated with f, along with any other faces containing * those vertices*/ -void BM_Kill_Face_Verts(BMesh *bm, BMFace *f); +void BM_face_verts_kill(BMesh *bm, BMFace *f); /*clear all data in bm*/ -void BM_Clear_Mesh(BMesh *bm); +void BM_mesh_clear(BMesh *bm); -void BM_ElemIndex_Ensure(BMesh *bm, const char hflag); +void BM_mesh_elem_index_ensure(BMesh *bm, const char hflag); -void BM_ElemIndex_Validate(BMesh *bm, const char *location, const char *func, - const char *msg_a, const char *msg_b); +void BM_mesh_elem_index_validate(BMesh *bm, const char *location, const char *func, + const char *msg_a, const char *msg_b); -BMVert *BM_Vert_AtIndex(BMesh *bm, const int index); -BMEdge *BM_Edge_AtIndex(BMesh *bm, const int index); -BMFace *BM_Face_AtIndex(BMesh *bm, const int index); +BMVert *BM_vert_at_index(BMesh *bm, const int index); +BMEdge *BM_edge_at_index(BMesh *bm, const int index); +BMFace *BM_face_at_index(BMesh *bm, const int index); /*start/stop edit*/ void bmesh_begin_edit(BMesh *bm, int flag); diff --git a/source/blender/bmesh/bmesh_class.h b/source/blender/bmesh/bmesh_class.h index 4fd0b99efe8..462e39921dd 100644 --- a/source/blender/bmesh/bmesh_class.h +++ b/source/blender/bmesh/bmesh_class.h @@ -45,7 +45,7 @@ typedef struct BMHeader { void *data; /* customdata layers */ struct BMFlagLayer *flags; int index; /* notes: - * - Use BM_GetIndex/SetIndex macros for index + * - Use BM_elem_index_get/SetIndex macros for index * - Unitialized to -1 so we can easily tell its not set. * - Used for edge/vert/face, check BMesh.elem_index_dirty for valid index values, * this is abused by various tools which set it dirty. @@ -153,8 +153,6 @@ typedef struct BMesh { int opflag; /* current operator flag */ } BMesh; -BMFace *BM_Copy_Face(BMesh *bm, BMFace *f, int copyedges, int copyverts); - #define BM_VERT 1 #define BM_EDGE 2 #define BM_LOOP 4 diff --git a/source/blender/bmesh/bmesh_error.h b/source/blender/bmesh/bmesh_error.h index 74597ee6154..50be73ee80d 100644 --- a/source/blender/bmesh/bmesh_error.h +++ b/source/blender/bmesh/bmesh_error.h @@ -27,16 +27,16 @@ /* pushes an error onto the bmesh error stack. * if msg is null, then the default message for the errorcode is used.*/ -void BMO_RaiseError(BMesh *bm, BMOperator *owner, int errcode, const char *msg); +void BMO_error_raise(BMesh *bm, BMOperator *owner, int errcode, const char *msg); /* gets the topmost error from the stack. * returns error code or 0 if no error.*/ -int BMO_GetError(BMesh *bm, const char **msg, BMOperator **op); -int BMO_HasError(BMesh *bm); +int BMO_error_get(BMesh *bm, const char **msg, BMOperator **op); +int BMO_error_occurred(BMesh *bm); /* same as geterror, only pops the error off the stack as well */ -int BMO_PopError(BMesh *bm, const char **msg, BMOperator **op); -void BMO_ClearStack(BMesh *bm); +int BMO_error_pop(BMesh *bm, const char **msg, BMOperator **op); +void BMO_error_clear(BMesh *bm); #if 0 //this is meant for handling errors, like self-intersection test failures. @@ -45,11 +45,11 @@ void BMO_ClearStack(BMesh *bm); /* catches an error raised by the op pointed to by catchop. * errorcode is either the errorcode, or BMERR_ALL for any * error.*/ -int BMO_CatchOpError(BMesh *bm, BMOperator *catchop, int errorcode, char **msg); +int BMO_error_catch_op(BMesh *bm, BMOperator *catchop, int errorcode, char **msg); #endif #define BM_ELEM_INDEX_VALIDATE(_bm, _msg_a, _msg_b) \ - BM_ElemIndex_Validate(_bm, __FILE__ ":" STRINGIFY(__LINE__), __func__, _msg_a, _msg_b) + BM_mesh_elem_index_validate(_bm, __FILE__ ":" STRINGIFY(__LINE__), __func__, _msg_a, _msg_b) /*------ error code defines -------*/ diff --git a/source/blender/bmesh/bmesh_iterators.h b/source/blender/bmesh/bmesh_iterators.h index e7cdcb4fc68..ee7c23da31c 100644 --- a/source/blender/bmesh/bmesh_iterators.h +++ b/source/blender/bmesh/bmesh_iterators.h @@ -37,7 +37,7 @@ #include "BLI_mempool.h" -/* Defines for passing to BMIter_New. +/* Defines for passing to BM_iter_new. * * "OF" can be substituted for "around" * so BM_VERTS_OF_FACE means "vertices @@ -70,12 +70,12 @@ #define BM_LOOPS_OF_EDGE 13 #define BM_ITER(ele, iter, bm, itype, data) \ - ele = BMIter_New(iter, bm, itype, data); \ - for ( ; ele; ele=BMIter_Step(iter)) + ele = BM_iter_new(iter, bm, itype, data); \ + for ( ; ele; ele=BM_iter_step(iter)) #define BM_ITER_INDEX(ele, iter, bm, itype, data, indexvar) \ - ele = BMIter_New(iter, bm, itype, data); \ - for (indexvar=0; ele; indexvar++, ele=BMIter_Step(iter)) + ele = BM_iter_new(iter, bm, itype, data); \ + for (indexvar=0; ele; indexvar++, ele=BM_iter_step(iter)) /*Iterator Structure*/ typedef struct BMIter { @@ -98,8 +98,8 @@ typedef struct BMIter { char itype; } BMIter; -void *BMIter_AtIndex(struct BMesh *bm, const char htype, void *data, int index); -int BMIter_AsArray(struct BMesh *bm, const char htype, void *data, void **array, const int len); +void *BM_iter_at_index(struct BMesh *bm, const char htype, void *data, int index); +int BM_iter_as_array(struct BMesh *bm, const char htype, void *data, void **array, const int len); /* private for bmesh_iterators_inline.c */ void bmiter__vert_of_mesh_begin(struct BMIter *iter); diff --git a/source/blender/bmesh/bmesh_marking.h b/source/blender/bmesh/bmesh_marking.h index 9eba18ce5ab..c2fffb58c40 100644 --- a/source/blender/bmesh/bmesh_marking.h +++ b/source/blender/bmesh/bmesh_marking.h @@ -30,47 +30,43 @@ typedef struct BMEditSelection char htype; } BMEditSelection; -/* pinning code */ -void BM_Pin(BMesh *bm, void *element, int pin); -void BM_Pin_Vert(BMesh *bm, BMVert *v, int pin); -void BM_Pin_Edge(BMesh *bm, BMEdge *e, int pin); -void BM_Pin_Face(BMesh *bm, BMFace *f, int pin); - /* geometry hiding code */ -void BM_Hide(BMesh *bm, void *element, int hide); -void BM_Hide_Vert(BMesh *bm, BMVert *v, int hide); -void BM_Hide_Edge(BMesh *bm, BMEdge *e, int hide); -void BM_Hide_Face(BMesh *bm, BMFace *f, int hide); +void BM_elem_hide_set(BMesh *bm, void *element, int hide); +void BM_vert_hide_set(BMesh *bm, BMVert *v, int hide); +void BM_edge_hide_set(BMesh *bm, BMEdge *e, int hide); +void BM_face_hide_set(BMesh *bm, BMFace *f, int hide); /* Selection code */ -void BM_Select(struct BMesh *bm, void *element, int select); -/* I don't use this function anywhere, been using BM_TestHFlag instead. +void BM_elem_select_set(struct BMesh *bm, void *element, int select); +/* I don't use this function anywhere, been using BM_elem_flag_test instead. * Need to decide either to keep it and convert everything over, or * chuck it.*/ -int BM_Selected(BMesh *bm, const void *element); +int BM_elem_select_test(BMesh *bm, const void *element); void BM_clear_flag_all(BMesh *bm, const char hflag); -/* individual element select functions, BM_Select is a shortcut for these +/* individual element select functions, BM_elem_select_set is a shortcut for these * that automatically detects which one to use*/ -void BM_Select_Vert(struct BMesh *bm, struct BMVert *v, int select); -void BM_Select_Edge(struct BMesh *bm, struct BMEdge *e, int select); -void BM_Select_Face(struct BMesh *bm, struct BMFace *f, int select); +void BM_vert_select(struct BMesh *bm, struct BMVert *v, int select); +void BM_edge_select(struct BMesh *bm, struct BMEdge *e, int select); +void BM_face_select(struct BMesh *bm, struct BMFace *f, int select); -void BM_Selectmode_Set(struct BMesh *bm, int selectmode); +void BM_select_mode_set(struct BMesh *bm, int selectmode); /* counts number of elements with flag set */ -int BM_CountFlag(struct BMesh *bm, const char htype, const char hflag, int respecthide); +int BM_mesh_count_flag(struct BMesh *bm, const char htype, const char hflag, int respecthide); /* edit selection stuff */ -void BM_set_actFace(BMesh *em, BMFace *f); -BMFace *BM_get_actFace(BMesh *bm, int sloppy); +void BM_active_face_set(BMesh *em, BMFace *f); +BMFace *BM_active_face_get(BMesh *bm, int sloppy); void BM_editselection_center(BMesh *bm, float r_center[3], BMEditSelection *ese); void BM_editselection_normal(float r_normal[3], BMEditSelection *ese); void BM_editselection_plane(BMesh *bm, float r_plane[3], BMEditSelection *ese); -void BM_remove_selection(BMesh *bm, void *data); -void BM_store_selection(BMesh *bm, void *data); -void BM_validate_selections(BMesh *bm); -void BM_clear_selection_history(BMesh *em); + +int BM_select_history_check(BMesh *bm, void *data); +void BM_select_history_remove(BMesh *bm, void *data); +void BM_select_history_store(BMesh *bm, void *data); +void BM_select_history_validate(BMesh *bm); +void BM_select_history_clear(BMesh *em); #endif diff --git a/source/blender/bmesh/bmesh_operator_api.h b/source/blender/bmesh/bmesh_operator_api.h index 52aa4ee38ec..2dfbacbf6d2 100644 --- a/source/blender/bmesh/bmesh_operator_api.h +++ b/source/blender/bmesh/bmesh_operator_api.h @@ -56,7 +56,7 @@ extern "C" { * * in general, operators are fed arrays of elements, created using either * BM_HeaderFlag_To_Slot or BM_Flag_To_Slot (or through one of the format - * specifyers in BMO_CallOpf or BMO_InitOpf). Note that multiple element + * specifyers in BMO_op_callf or BMO_op_initf). Note that multiple element * types (e.g. faces and edges) can be fed to the same slot array. Operators * act on this data, and possibly spit out data into output slots. * @@ -152,18 +152,18 @@ typedef struct BMOpDefine { /*------------- Operator API --------------*/ /* data types that use pointers (arrays, etc) should never - * have it set directly. and never use BMO_Set_Pnt to + * have it set directly. and never use BMO_slot_ptr_set to * pass in a list of edges or any arrays, really.*/ -void BMO_Init_Op(struct BMesh *bm, struct BMOperator *op, const char *opname); +void BMO_op_init(struct BMesh *bm, struct BMOperator *op, const char *opname); /* executes an operator, pushing and popping a new tool flag * layer as appropriate.*/ -void BMO_Exec_Op(struct BMesh *bm, struct BMOperator *op); +void BMO_op_exec(struct BMesh *bm, struct BMOperator *op); /* finishes an operator (though note the operator's tool flag is removed - * after it finishes executing in BMO_Exec_Op).*/ -void BMO_Finish_Op(struct BMesh *bm, struct BMOperator *op); + * after it finishes executing in BMO_op_exec).*/ +void BMO_op_finish(struct BMesh *bm, struct BMOperator *op); /* tool flag API. never, ever ever should tool code put junk in @@ -175,26 +175,26 @@ void BMO_Finish_Op(struct BMesh *bm, struct BMOperator *op); * ghash or a mapping slot to do it. */ /* flags 15 and 16 (1<<14 and 1<<15) are reserved for bmesh api use */ -#define BMO_TestFlag(bm, element, oflag) (((BMHeader*)(element))->flags[bm->stackdepth-1].f & (oflag)) -#define BMO_SetFlag(bm, element, oflag) (((BMHeader*)(element))->flags[bm->stackdepth-1].f |= (oflag)) -#define BMO_ClearFlag(bm, element, oflag) (((BMHeader*)(element))->flags[bm->stackdepth-1].f &= ~(oflag)) -#define BMO_ToggleFlag(bm, element, oflag) (((BMHeader*)(element))->flags[bm->stackdepth-1].f ^= (oflag)) +#define BMO_elem_flag_test(bm, element, oflag) (((BMHeader*)(element))->flags[bm->stackdepth-1].f & (oflag)) +#define BMO_elem_flag_set(bm, element, oflag) (((BMHeader*)(element))->flags[bm->stackdepth-1].f |= (oflag)) +#define BMO_elem_flag_clear(bm, element, oflag) (((BMHeader*)(element))->flags[bm->stackdepth-1].f &= ~(oflag)) +#define BMO_elem_flag_toggle(bm, element, oflag) (((BMHeader*)(element))->flags[bm->stackdepth-1].f ^= (oflag)) -/*profiling showed a significant amount of time spent in BMO_TestFlag -void BMO_SetFlag(struct BMesh *bm, void *element, const short oflag); -void BMO_ClearFlag(struct BMesh *bm, void *element, const short oflag); -int BMO_TestFlag(struct BMesh *bm, void *element, const short oflag);*/ +/*profiling showed a significant amount of time spent in BMO_elem_flag_test +void BMO_elem_flag_set(struct BMesh *bm, void *element, const short oflag); +void BMO_elem_flag_clear(struct BMesh *bm, void *element, const short oflag); +int BMO_elem_flag_test(struct BMesh *bm, void *element, const short oflag);*/ /* count the number of elements with a specific flag. * type can be a bitmask of BM_FACE, BM_EDGE, or BM_FACE. */ -int BMO_CountFlag(struct BMesh *bm, const short oflag, const char htype); +int BMO_mesh_flag_count(struct BMesh *bm, const short oflag, const char htype); /*---------formatted operator initialization/execution-----------*/ /* * this system is used to execute or initialize an operator, * using a formatted-string system. * - * for example, BMO_CallOpf(bm, "del geom=%hf context=%d", BM_ELEM_SELECT, DEL_FACES); + * for example, BMO_op_callf(bm, "del geom=%hf context=%d", BM_ELEM_SELECT, DEL_FACES); * . . .will execute the delete operator, feeding in selected faces, deleting them. * * the basic format for the format string is: @@ -229,26 +229,26 @@ void BMO_push(BMesh *bm, BMOperator *op); void BMO_pop(BMesh *bm); /*executes an operator*/ -int BMO_CallOpf(BMesh *bm, const char *fmt, ...); +int BMO_op_callf(BMesh *bm, const char *fmt, ...); /* initializes, but doesn't execute an operator. this is so you can * gain access to the outputs of the operator. note that you have - * to execute/finitsh (BMO_Exec_Op and BMO_Finish_Op) yourself. */ -int BMO_InitOpf(BMesh *bm, BMOperator *op, const char *fmt, ...); + * to execute/finitsh (BMO_op_exec and BMO_op_finish) yourself. */ +int BMO_op_initf(BMesh *bm, BMOperator *op, const char *fmt, ...); /* va_list version, used to implement the above two functions, * plus EDBM_CallOpf in bmeshutils.c. */ -int BMO_VInitOpf(BMesh *bm, BMOperator *op, const char *fmt, va_list vlist); +int BMO_op_vinitf(BMesh *bm, BMOperator *op, const char *fmt, va_list vlist); /* test whether a named slot exists */ -int BMO_HasSlot(struct BMOperator *op, const char *slotname); +int BMO_slot_exists(struct BMOperator *op, const char *slotname); /* get a pointer to a slot. this may be removed layer on from the public API. */ -BMOpSlot *BMO_GetSlot(struct BMOperator *op, const char *slotname); +BMOpSlot *BMO_slot_get(struct BMOperator *op, const char *slotname); /* copies the data of a slot from one operator to another. src and dst are the * source/destination slot codes, respectively. */ -void BMO_CopySlot(struct BMOperator *source_op, struct BMOperator *dest_op, +void BMO_slot_copy(struct BMOperator *source_op, struct BMOperator *dest_op, const char *src, const char *dst); /* remove tool flagged elements */ @@ -270,103 +270,103 @@ enum { DEL_ONLYTAGGED }; -void BMO_Set_OpFlag(struct BMesh *bm, struct BMOperator *op, const int op_flag); -void BMO_Clear_OpFlag(struct BMesh *bm, struct BMOperator *op, const int op_flag); +void BMO_op_flag_set(struct BMesh *bm, struct BMOperator *op, const int op_flag); +void BMO_op_flag_clear(struct BMesh *bm, struct BMOperator *op, const int op_flag); -void BMO_Set_Float(struct BMOperator *op, const char *slotname, float f); -float BMO_Get_Float(BMOperator *op, const char *slotname); -void BMO_Set_Int(struct BMOperator *op, const char *slotname, int i); -int BMO_Get_Int(BMOperator *op, const char *slotname); +void BMO_slot_float_set(struct BMOperator *op, const char *slotname, float f); +float BMO_slot_float_get(BMOperator *op, const char *slotname); +void BMO_slot_int_set(struct BMOperator *op, const char *slotname, int i); +int BMO_slot_int_get(BMOperator *op, const char *slotname); /* don't pass in arrays that are supposed to map to elements this way. * * so, e.g. passing in list of floats per element in another slot is bad. * passing in, e.g. pointer to an editmesh for the conversion operator is fine * though. */ -void BMO_Set_Pnt(struct BMOperator *op, const char *slotname, void *p); -void *BMO_Get_Pnt(BMOperator *op, const char *slotname); -void BMO_Set_Vec(struct BMOperator *op, const char *slotname, const float vec[3]); -void BMO_Get_Vec(BMOperator *op, const char *slotname, float r_vec[3]); +void BMO_slot_ptr_set(struct BMOperator *op, const char *slotname, void *p); +void *BMO_slot_ptr_get(BMOperator *op, const char *slotname); +void BMO_slot_vec_set(struct BMOperator *op, const char *slotname, const float vec[3]); +void BMO_slot_vec_get(BMOperator *op, const char *slotname, float r_vec[3]); /* only supports square mats */ /* size must be 3 or 4; this api is meant only for transformation matrices. * note that internally the matrix is stored in 4x4 form, and it's safe to * call whichever BMO_Get_Mat* function you want. */ -void BMO_Set_Mat(struct BMOperator *op, const char *slotname, float *mat, int size); -void BMO_Get_Mat4(struct BMOperator *op, const char *slotname, float mat[4][4]); -void BMO_Get_Mat3(struct BMOperator *op, const char *slotname, float mat[3][3]); +void BMO_slot_mat_set(struct BMOperator *op, const char *slotname, float *mat, int size); +void BMO_slot_mat4_set(struct BMOperator *op, const char *slotname, float mat[4][4]); +void BMO_slot_mat3_set(struct BMOperator *op, const char *slotname, float mat[3][3]); -void BMO_Clear_Flag_All(BMesh *bm, BMOperator *op, const char htype, const short oflag); +void BMO_mesh_flag_clear_all(BMesh *bm, BMOperator *op, const char htype, const short oflag); /* puts every element of type type (which is a bitmask) with tool flag flag, * into a slot. */ -void BMO_Flag_To_Slot(struct BMesh *bm, struct BMOperator *op, const char *slotname, - const short oflag, const char htype); +void BMO_slot_from_flag(struct BMesh *bm, struct BMOperator *op, const char *slotname, + const short oflag, const char htype); /* tool-flags all elements inside an element slot array with flag flag. */ -void BMO_Flag_Buffer(struct BMesh *bm, struct BMOperator *op, const char *slotname, - const short oflag, const char htype); +void BMO_slot_buffer_flag(struct BMesh *bm, struct BMOperator *op, const char *slotname, + const short oflag, const char htype); /* clears tool-flag flag from all elements inside a slot array. */ -void BMO_Unflag_Buffer(struct BMesh *bm, struct BMOperator *op, const char *slotname, - const short oflag, const char htype); +void BMO_slot_buffer_flag_clear(struct BMesh *bm, struct BMOperator *op, const char *slotname, + const short oflag, const char htype); /* tool-flags all elements inside an element slot array with flag flag. */ -void BMO_HeaderFlag_Buffer(struct BMesh *bm, struct BMOperator *op, const char *slotname, +void BMO_slot_buffer_hflag(struct BMesh *bm, struct BMOperator *op, const char *slotname, const char hflag, const char htype); /* clears tool-flag flag from all elements inside a slot array. */ -void BMO_UnHeaderFlag_Buffer(struct BMesh *bm, struct BMOperator *op, const char *slotname, - const char hflag, const char htype); +void BMO_slot_buffer_hflag_clear(struct BMesh *bm, struct BMOperator *op, const char *slotname, + const char hflag, const char htype); /* puts every element of type type (which is a bitmask) with header flag * flag, into a slot. note: ignores hidden elements (e.g. elements with * header flag BM_ELEM_HIDDEN set).*/ -void BMO_HeaderFlag_To_Slot(struct BMesh *bm, struct BMOperator *op, const char *slotname, - const char hflag, const char htype); +void BMO_slot_from_hflag(struct BMesh *bm, struct BMOperator *op, const char *slotname, + const char hflag, const char htype); /* counts number of elements inside a slot array. */ -int BMO_CountSlotBuf(struct BMesh *bm, struct BMOperator *op, const char *slotname); -int BMO_CountSlotMap(struct BMesh *bm, struct BMOperator *op, const char *slotname); +int BMO_slot_buf_count(struct BMesh *bm, struct BMOperator *op, const char *slotname); +int BMO_slot_map_count(struct BMesh *bm, struct BMOperator *op, const char *slotname); /* Counts the number of edges with tool flag toolflag around */ -int BMO_Vert_CountEdgeFlags(BMesh *bm, BMVert *v, const short oflag); +int BMO_vert_edge_flags_count(BMesh *bm, BMVert *v, const short oflag); /* inserts a key/value mapping into a mapping slot. note that it copies the * value, it doesn't store a reference to it. */ #if 0 -BM_INLINE void BMO_Insert_Mapping(BMesh *bm, BMOperator *op, const char *slotname, +BM_INLINE void BMO_slot_map_insert(BMesh *bm, BMOperator *op, const char *slotname, void *element, void *data, int len); /* inserts a key/float mapping pair into a mapping slot. */ -BM_INLINE void BMO_Insert_MapFloat(BMesh *bm, BMOperator *op, const char *slotname, +BM_INLINE void BMO_slot_map_float_insert(BMesh *bm, BMOperator *op, const char *slotname, void *element, float val); /* returns 1 if the specified pointer is in the map. */ -BM_INLINE int BMO_InMap(BMesh *bm, BMOperator *op, const char *slotname, void *element); +BM_INLINE int BMO_slot_map_contains(BMesh *bm, BMOperator *op, const char *slotname, void *element); /* returns a point to the value of a specific key. */ -BM_INLINE void *BMO_Get_MapData(BMesh *bm, BMOperator *op, const char *slotname, void *element); +BM_INLINE void *BMO_slot_map_data_get(BMesh *bm, BMOperator *op, const char *slotname, void *element); /* returns the float part of a key/float pair. */ -BM_INLINE float BMO_Get_MapFloat(BMesh *bm, BMOperator *op, const char *slotname, void *element); +BM_INLINE float BMO_slot_map_float_get(BMesh *bm, BMOperator *op, const char *slotname, void *element); #endif /* flags all elements in a mapping. note that the mapping must only have * bmesh elements in it.*/ -void BMO_Mapping_To_Flag(struct BMesh *bm, struct BMOperator *op, - const char *slotname, const short oflag); +void BMO_slot_map_to_flag(struct BMesh *bm, struct BMOperator *op, + const char *slotname, const short oflag); -/* pointer versoins of BMO_Get_MapFloat and BMO_Insert_MapFloat. +/* pointer versoins of BMO_slot_map_float_get and BMO_slot_map_float_insert. * * do NOT use these for non-operator-api-allocated memory! instead - * use BMO_Get_MapData and BMO_Insert_Mapping, which copies the data. */ + * use BMO_slot_map_data_get and BMO_slot_map_insert, which copies the data. */ #if 0 -BM_INLINE void BMO_Insert_MapPointer(BMesh *bm, BMOperator *op, const char *slotname, void *key, void *val); -BM_INLINE void *BMO_Get_MapPointer(BMesh *bm, BMOperator *op, const char *slotname, void *key); +BM_INLINE void BMO_slot_map_ptr_insert(BMesh *bm, BMOperator *op, const char *slotname, void *key, void *val); +BM_INLINE void *BMO_slot_map_ptr_get(BMesh *bm, BMOperator *op, const char *slotname, void *key); #endif /* this part of the API is used to iterate over element buffer or @@ -377,8 +377,8 @@ BM_INLINE void *BMO_Get_MapPointer(BMesh *bm, BMOperator *op, const char *slotna * BMOIter oiter; * BMFace *f; * - * f = BMO_IterNew(&oiter, bm, some_operator, "slotname", BM_FACE); - * for (; f; f=BMO_IterStep(&oiter)) { + * f = BMO_iter_new(&oiter, bm, some_operator, "slotname", BM_FACE); + * for (; f; f=BMO_iter_step(&oiter)) { * /do something with the face * } * @@ -387,15 +387,15 @@ BM_INLINE void *BMO_Get_MapPointer(BMesh *bm, BMOperator *op, const char *slotna * void *key; * void *val; * - * key = BMO_IterNew(&oiter, bm, some_operator, "slotname", 0); - * for (; key; key=BMO_IterStep(&oiter)) { - * val = BMO_IterMapVal(&oiter); + * key = BMO_iter_new(&oiter, bm, some_operator, "slotname", 0); + * for (; key; key=BMO_iter_step(&oiter)) { + * val = BMO_iter_map_value(&oiter); * //do something with the key/val pair * //note that val is a pointer to the val data, * //whether it's a float, pointer, whatever. * // * // so to get a pointer, for example, use: - * // *((void**)BMO_IterMapVal(&oiter)); + * // *((void**)BMO_iter_map_value(&oiter)); * //or something like that. * } */ @@ -410,28 +410,28 @@ typedef struct BMOIter { char restrictmask; /* bitwise '&' with BMHeader.htype */ } BMOIter; -void *BMO_FirstElem(BMOperator *op, const char *slotname); +void *BMO_slot_elem_first(BMOperator *op, const char *slotname); /* restrictmask restricts the iteration to certain element types * (e.g. combination of BM_VERT, BM_EDGE, BM_FACE), if iterating * over an element buffer (not a mapping).*/ -void *BMO_IterNew(BMOIter *iter, BMesh *bm, BMOperator *op, +void *BMO_iter_new(BMOIter *iter, BMesh *bm, BMOperator *op, const char *slotname, const char restrictmask); -void *BMO_IterStep(BMOIter *iter); +void *BMO_iter_step(BMOIter *iter); /* returns a pointer to the key value when iterating over mappings. * remember for pointer maps this will be a pointer to a pointer.*/ -void *BMO_IterMapVal(BMOIter *iter); +void *BMO_iter_map_value(BMOIter *iter); /* use this for pointer mappings */ -void *BMO_IterMapValp(BMOIter *iter); +void *BMO_iter_map_value_p(BMOIter *iter); /* use this for float mappings */ -float BMO_IterMapValf(BMOIter *iter); +float BMO_iter_map_value_f(BMOIter *iter); #define BMO_ITER(ele, iter, bm, op, slotname, restrict) \ - ele = BMO_IterNew(iter, bm, op, slotname, restrict); \ - for ( ; ele; ele=BMO_IterStep(iter)) + ele = BMO_iter_new(iter, bm, op, slotname, restrict); \ + for ( ; ele; ele=BMO_iter_step(iter)) /******************* Inlined Functions********************/ typedef void (*opexec)(struct BMesh *bm, struct BMOperator *op); @@ -445,10 +445,11 @@ typedef struct BMOElemMapping { extern const int BMOP_OPSLOT_TYPEINFO[]; -BM_INLINE void BMO_Insert_Mapping(BMesh *UNUSED(bm), BMOperator *op, const char *slotname, - void *element, void *data, int len) { +BM_INLINE void BMO_slot_map_insert(BMesh *UNUSED(bm), BMOperator *op, const char *slotname, + void *element, void *data, int len) +{ BMOElemMapping *mapping; - BMOpSlot *slot = BMO_GetSlot(op, slotname); + BMOpSlot *slot = BMO_slot_get(op, slotname); /*sanity check*/ if (slot->slottype != BMOP_OPSLOT_MAPPING) return; @@ -467,27 +468,27 @@ BM_INLINE void BMO_Insert_Mapping(BMesh *UNUSED(bm), BMOperator *op, const char BLI_ghash_insert(slot->data.ghash, element, mapping); } -BM_INLINE void BMO_Insert_MapInt(BMesh *bm, BMOperator *op, const char *slotname, - void *element, int val) +BM_INLINE void BMO_slot_map_int_insert(BMesh *bm, BMOperator *op, const char *slotname, + void *element, int val) { - BMO_Insert_Mapping(bm, op, slotname, element, &val, sizeof(int)); + BMO_slot_map_insert(bm, op, slotname, element, &val, sizeof(int)); } -BM_INLINE void BMO_Insert_MapFloat(BMesh *bm, BMOperator *op, const char *slotname, - void *element, float val) +BM_INLINE void BMO_slot_map_float_insert(BMesh *bm, BMOperator *op, const char *slotname, + void *element, float val) { - BMO_Insert_Mapping(bm, op, slotname, element, &val, sizeof(float)); + BMO_slot_map_insert(bm, op, slotname, element, &val, sizeof(float)); } -BM_INLINE void BMO_Insert_MapPointer(BMesh *bm, BMOperator *op, const char *slotname, - void *element, void *val) +BM_INLINE void BMO_slot_map_ptr_insert(BMesh *bm, BMOperator *op, const char *slotname, + void *element, void *val) { - BMO_Insert_Mapping(bm, op, slotname, element, &val, sizeof(void*)); + BMO_slot_map_insert(bm, op, slotname, element, &val, sizeof(void*)); } -BM_INLINE int BMO_InMap(BMesh *UNUSED(bm), BMOperator *op, const char *slotname, void *element) +BM_INLINE int BMO_slot_map_contains(BMesh *UNUSED(bm), BMOperator *op, const char *slotname, void *element) { - BMOpSlot *slot = BMO_GetSlot(op, slotname); + BMOpSlot *slot = BMO_slot_get(op, slotname); /*sanity check*/ if (slot->slottype != BMOP_OPSLOT_MAPPING) return 0; @@ -496,11 +497,11 @@ BM_INLINE int BMO_InMap(BMesh *UNUSED(bm), BMOperator *op, const char *slotname, return BLI_ghash_haskey(slot->data.ghash, element); } -BM_INLINE void *BMO_Get_MapData(BMesh *UNUSED(bm), BMOperator *op, const char *slotname, - void *element) +BM_INLINE void *BMO_slot_map_data_get(BMesh *UNUSED(bm), BMOperator *op, const char *slotname, + void *element) { BMOElemMapping *mapping; - BMOpSlot *slot = BMO_GetSlot(op, slotname); + BMOpSlot *slot = BMO_slot_get(op, slotname); /*sanity check*/ if (slot->slottype != BMOP_OPSLOT_MAPPING) return NULL; @@ -513,47 +514,33 @@ BM_INLINE void *BMO_Get_MapData(BMesh *UNUSED(bm), BMOperator *op, const char *s return mapping + 1; } -BM_INLINE float BMO_Get_MapFloat(BMesh *bm, BMOperator *op, const char *slotname, - void *element) +BM_INLINE float BMO_slot_map_float_get(BMesh *bm, BMOperator *op, const char *slotname, + void *element) { - float *val = (float*) BMO_Get_MapData(bm, op, slotname, element); + float *val = (float*) BMO_slot_map_data_get(bm, op, slotname, element); if (val) return *val; return 0.0f; } -BM_INLINE int BMO_Get_MapInt(BMesh *bm, BMOperator *op, const char *slotname, - void *element) +BM_INLINE int BMO_slot_map_int_get(BMesh *bm, BMOperator *op, const char *slotname, + void *element) { - int *val = (int*) BMO_Get_MapData(bm, op, slotname, element); + int *val = (int*) BMO_slot_map_data_get(bm, op, slotname, element); if (val) return *val; return 0; } -BM_INLINE void *BMO_Get_MapPointer(BMesh *bm, BMOperator *op, const char *slotname, +BM_INLINE void *BMO_slot_map_ptr_get(BMesh *bm, BMOperator *op, const char *slotname, void *element) { - void **val = (void**) BMO_Get_MapData(bm, op, slotname, element); + void **val = (void**) BMO_slot_map_data_get(bm, op, slotname, element); if (val) return *val; return NULL; } -#if 0 /* UNUSED */ -BM_INLINE void BMO_SetIndex(BMesh *bm, const void *element, int index) -{ - BMHeader *header = (BMHeader *)element; - header->flags[bm->stackdepth-1].index = index; -} - -BM_INLINE int BMO_GetIndex(BMesh *bm, void *element) -{ - BMHeader *header = (BMHeader *)element; - return header->flags[bm->stackdepth-1].index; -} -#endif - #ifdef __cplusplus } #endif diff --git a/source/blender/bmesh/bmesh_operators.h b/source/blender/bmesh/bmesh_operators.h index 4fefa04ca0f..22a841c1b61 100644 --- a/source/blender/bmesh/bmesh_operators.h +++ b/source/blender/bmesh/bmesh_operators.h @@ -91,17 +91,11 @@ extern int bmesh_total_ops; struct Object; struct EditMesh; -void BMOP_DupeFromFlag(struct BMesh *bm, int etypeflag, const char hflag); +#if 0 +void BMO_dupe_from_flag(struct BMesh *bm, int etypeflag, const char hflag); +#endif void BM_esubdivideflag(struct Object *obedit, BMesh *bm, int flag, float smooth, float fractal, int beauty, int numcuts, int seltype, int cornertype, int singleedge, int gridfill, int seed); -void BM_extrudefaceflag(BMesh *bm, int flag); - -/* this next one return 1 if they did anything, or zero otherwise. - * they're kindof a hackish way to integrate with fkey, until - * such time as fkey is completely bmeshafied.*/ - -/* this doesn't display errors to the user, btw */ -int BM_ConnectVerts(struct EditMesh *em, int flag); #endif diff --git a/source/blender/bmesh/bmesh_queries.h b/source/blender/bmesh/bmesh_queries.h index dcf70357ccb..5fd7c533d20 100644 --- a/source/blender/bmesh/bmesh_queries.h +++ b/source/blender/bmesh/bmesh_queries.h @@ -24,93 +24,93 @@ #define BMESH_QUERIES_H #include <stdio.h> -/*Queries*/ +/* Queries */ -/*counts number of elements of type type are in the mesh.*/ -int BM_Count_Element(struct BMesh *bm, const char htype); +/* counts number of elements of type type are in the mesh. */ +int BM_mesh_elem_count(struct BMesh *bm, const char htype); /*returns true if v is in f*/ -int BM_Vert_In_Face(struct BMFace *f, struct BMVert *v); +int BM_vert_in_face(struct BMFace *f, struct BMVert *v); -// int BM_Verts_In_Face(struct BMFace *f, struct BMVert **varr, int len); -int BM_Verts_In_Face(struct BMesh *bm, struct BMFace *f, struct BMVert **varr, int len); +// int BM_verts_in_face(struct BMFace *f, struct BMVert **varr, int len); +int BM_verts_in_face(struct BMesh *bm, struct BMFace *f, struct BMVert **varr, int len); -int BM_Edge_In_Face(struct BMFace *f, struct BMEdge *e); +int BM_edge_in_face(struct BMFace *f, struct BMEdge *e); -int BM_Vert_In_Edge(struct BMEdge *e, struct BMVert *v); +int BM_vert_in_edge(struct BMEdge *e, struct BMVert *v); -int BM_Verts_In_Edge(struct BMVert *v1, struct BMVert *v2, struct BMEdge *e); +int BM_verts_in_edge(struct BMVert *v1, struct BMVert *v2, struct BMEdge *e); /*get opposing vert from v in edge e.*/ -struct BMVert *BM_OtherEdgeVert(struct BMEdge *e, struct BMVert *v); +struct BMVert *BM_edge_other_vert(struct BMEdge *e, struct BMVert *v); /*finds other loop that shares v with e's loop in f.*/ -struct BMLoop *BM_OtherFaceLoop(BMEdge *e, BMFace *f, BMVert *v); +struct BMLoop *BM_face_other_loop(BMEdge *e, BMFace *f, BMVert *v); -//#define BM_OtherEdgeVert(e, v) (v==e->v1?e->v2:e->v1) +//#define BM_edge_other_vert(e, v) (v==e->v1?e->v2:e->v1) /*returns the edge existing between v1 and v2, or NULL if there isn't one.*/ -struct BMEdge *BM_Edge_Exist(struct BMVert *v1, struct BMVert *v2); +struct BMEdge *BM_edge_exists(struct BMVert *v1, struct BMVert *v2); /*returns number of edges aroudn a vert*/ -int BM_Vert_EdgeCount(struct BMVert *v); +int BM_vert_edge_count(struct BMVert *v); /*returns number of faces around an edge*/ -int BM_Edge_FaceCount(struct BMEdge *e); +int BM_edge_face_count(struct BMEdge *e); /*returns number of faces around a vert.*/ -int BM_Vert_FaceCount(struct BMVert *v); +int BM_vert_face_count(struct BMVert *v); /*returns true if v is a wire vert*/ -int BM_Wire_Vert(struct BMesh *bm, struct BMVert *v); +int BM_vert_is_wire(struct BMesh *bm, struct BMVert *v); /*returns true if e is a wire edge*/ -int BM_Wire_Edge(struct BMesh *bm, struct BMEdge *e); +int BM_edge_is_wire(struct BMesh *bm, struct BMEdge *e); /* returns true if v is part of a non-manifold edge in the mesh, * I believe this includes if it's part of both a wire edge and * a face.*/ -int BM_Nonmanifold_Vert(struct BMesh *bm, struct BMVert *v); +int BM_vert_is_nonmanifold(struct BMesh *bm, struct BMVert *v); /* returns true if e is shared by more then two faces. */ -int BM_Nonmanifold_Edge(struct BMesh *bm, struct BMEdge *e); +int BM_edge_is_nonmanifold(struct BMesh *bm, struct BMEdge *e); /* returns true if e is a boundary edge, e.g. has only 1 face bordering it. */ -int BM_Boundary_Edge(struct BMEdge *e); +int BM_edge_is_boundry(struct BMEdge *e); /* returns angle of two faces surrounding an edge. note there must be * exactly two faces sharing the edge.*/ -float BM_Face_Angle(struct BMesh *bm, struct BMEdge *e); +float BM_edge_face_angle(struct BMesh *bm, struct BMEdge *e); /* checks overlapping of existing faces with the verts in varr. */ -int BM_Exist_Face_Overlaps(struct BMesh *bm, struct BMVert **varr, int len, struct BMFace **existface); +int BM_face_exists_overlap(struct BMesh *bm, struct BMVert **varr, int len, struct BMFace **existface); /* checks if a face defined by varr already exists. */ -int BM_Face_Exists(BMesh *bm, BMVert **varr, int len, BMFace **existface); +int BM_face_exists(BMesh *bm, BMVert **varr, int len, BMFace **existface); /* returns number of edges f1 and f2 share. */ -int BM_Face_Share_Edges(struct BMFace *f1, struct BMFace *f2); +int BM_face_share_edges(struct BMFace *f1, struct BMFace *f2); /* returns number of faces e1 and e2 share. */ -int BM_Edge_Share_Faces(struct BMEdge *e1, struct BMEdge *e2); +int BM_edge_share_faces(struct BMEdge *e1, struct BMEdge *e2); /* returns bool 1/0 if the edges share a vertex */ -int BM_Edge_Share_Vert(struct BMEdge *e1, struct BMEdge *e2); +int BM_edge_share_vert(struct BMEdge *e1, struct BMEdge *e2); /* edge verts in winding order from face */ -void BM_Edge_OrderedVerts(struct BMEdge *edge, struct BMVert **r_v1, struct BMVert **r_v2); +void BM_edge_ordered_verts(struct BMEdge *edge, struct BMVert **r_v1, struct BMVert **r_v2); /* checks if a face is valid in the data structure */ -int BM_Validate_Face(BMesh *bm, BMFace *face, FILE *err); +int BM_face_validate(BMesh *bm, BMFace *face, FILE *err); /* each pair of loops defines a new edge, a split. this function goes * through and sets pairs that are geometrically invalid to null. a * split is invalid, if it forms a concave angle or it intersects other * edges in the face.*/ -void BM_LegalSplits(BMesh *bm, BMFace *f, BMLoop *(*loops)[2], int len); +void BM_face_legal_splits(BMesh *bm, BMFace *f, BMLoop *(*loops)[2], int len); #endif diff --git a/source/blender/bmesh/bmesh_walkers.h b/source/blender/bmesh/bmesh_walkers.h index 587e49a16a6..b5e9f68f2f3 100644 --- a/source/blender/bmesh/bmesh_walkers.h +++ b/source/blender/bmesh/bmesh_walkers.h @@ -59,25 +59,25 @@ typedef struct BMWalker { int depth; } BMWalker; -/* define to make BMW_Init more clear */ +/* define to make BMW_init more clear */ #define BMW_MASK_NOP 0 /* initialize a walker. searchmask restricts some (not all) walkers to * elements with a specific tool flag set. flags is specific to each walker.*/ -void BMW_Init(struct BMWalker *walker, BMesh *bm, int type, +void BMW_init(struct BMWalker *walker, BMesh *bm, int type, short mask_vert, short mask_edge, short mask_loop, short mask_face, int layer); -void *BMW_Begin(BMWalker *walker, void *start); -void *BMW_Step(struct BMWalker *walker); -void BMW_End(struct BMWalker *walker); -int BMW_CurrentDepth(BMWalker *walker); +void *BMW_begin(BMWalker *walker, void *start); +void *BMW_step(struct BMWalker *walker); +void BMW_end(struct BMWalker *walker); +int BMW_current_depth(BMWalker *walker); /*these are used by custom walkers*/ -void *BMW_currentstate(BMWalker *walker); -void *BMW_addstate(BMWalker *walker); -void BMW_removestate(BMWalker *walker); +void *BMW_current_state(BMWalker *walker); +void *BMW_state_add(BMWalker *walker); +void BMW_state_remove(BMWalker *walker); void *BMW_walk(BMWalker *walker); -void BMW_reset(BMWalker *walker); +void BMW_reset(BMWalker *walker); /* example of usage, walking over an island of tool flagged faces: @@ -85,12 +85,12 @@ example of usage, walking over an island of tool flagged faces: BMWalker walker; BMFace *f; -BMW_Init(&walker, bm, BMW_ISLAND, SOME_OP_FLAG); -f = BMW_Begin(&walker, some_start_face); -for (; f; f=BMW_Step(&walker)) { +BMW_init(&walker, bm, BMW_ISLAND, SOME_OP_FLAG); +f = BMW_begin(&walker, some_start_face); +for (; f; f=BMW_step(&walker)) { //do something with f } -BMW_End(&walker); +BMW_end(&walker); */ enum { @@ -109,7 +109,7 @@ enum { * restricts the walking to loops whose vert has restrict flag set as a * tool flag. * - * the flag parameter to BMW_Init maps to a loop customdata layer index. + * the flag parameter to BMW_init maps to a loop customdata layer index. */ BMW_LOOPDATA_ISLAND, /* walk over an island of flagged faces. note, that this doesn't work on @@ -124,12 +124,12 @@ enum { BMW_CONNECTED_VERTEX, /* end of array index enum vals */ - /* do not intitialze function pointers and struct size in BMW_Init */ + /* do not intitialze function pointers and struct size in BMW_init */ BMW_CUSTOM, BMW_MAXWALKERS }; -/* use with BMW_Init, so as not to confuse with restrict flags */ +/* use with BMW_init, so as not to confuse with restrict flags */ #define BMW_NIL_LAY 0 #endif diff --git a/source/blender/bmesh/intern/bmesh_construct.c b/source/blender/bmesh/intern/bmesh_construct.c index 6b2a81e9767..11a8caef6e1 100644 --- a/source/blender/bmesh/intern/bmesh_construct.c +++ b/source/blender/bmesh/intern/bmesh_construct.c @@ -68,7 +68,7 @@ static void bm_copy_loop_attributes(BMesh *source_mesh, BMesh *target_mesh, * */ -BMVert *BM_Make_Vert(BMesh *bm, float co[3], BMVert *example) +BMVert *BM_vert_create(BMesh *bm, float co[3], BMVert *example) { BMVert *v = NULL; v = bmesh_mv(bm, co); @@ -92,12 +92,12 @@ BMVert *BM_Make_Vert(BMesh *bm, float co[3], BMVert *example) * */ -BMEdge *BM_Make_Edge(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge *example, int nodouble) +BMEdge *BM_edge_create(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge *example, int nodouble) { BMEdge *e = NULL; if (nodouble) /* test if edge already exists. */ - e = BM_Edge_Exist(v1, v2); + e = BM_edge_exists(v1, v2); if (!e) { e = bmesh_me(bm, v1, v2); @@ -127,57 +127,57 @@ BMEdge *BM_Make_Edge(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge *example, int nod * by the order of the vertices in the vertex array */ -BMFace *BM_Make_Face_QuadTri(BMesh *bm, +BMFace *BM_face_create_quad_tri(BMesh *bm, BMVert *v1, BMVert *v2, BMVert *v3, BMVert *v4, const BMFace *example, const int nodouble) { BMVert *vtar[4] = {v1, v2, v3, v4}; - return BM_Make_Face_QuadTri_v(bm, vtar, v4 ? 4 : 3, example, nodouble); + return BM_face_create_quad_tri_v(bm, vtar, v4 ? 4 : 3, example, nodouble); } /* remove the edge array bits from this. Its not really needed? */ -BMFace *BM_Make_Face_QuadTri_v(BMesh *bm, BMVert **verts, int len, const BMFace *example, const int nodouble) +BMFace *BM_face_create_quad_tri_v(BMesh *bm, BMVert **verts, int len, const BMFace *example, const int nodouble) { BMEdge *edar[4] = {NULL}; BMFace *f = NULL; int overlap = 0; - edar[0] = BM_Edge_Exist(verts[0], verts[1]); - edar[1] = BM_Edge_Exist(verts[1], verts[2]); + edar[0] = BM_edge_exists(verts[0], verts[1]); + edar[1] = BM_edge_exists(verts[1], verts[2]); if (len == 4) { - edar[2] = BM_Edge_Exist(verts[2], verts[3]); - edar[3] = BM_Edge_Exist(verts[3], verts[0]); + edar[2] = BM_edge_exists(verts[2], verts[3]); + edar[3] = BM_edge_exists(verts[3], verts[0]); } else { - edar[2] = BM_Edge_Exist(verts[2], verts[0]); + edar[2] = BM_edge_exists(verts[2], verts[0]); } if (nodouble) { /* check if face exists or overlaps */ if (len == 4) { - overlap = BM_Exist_Face_Overlaps(bm, verts, len, &f); + overlap = BM_face_exists_overlap(bm, verts, len, &f); } else { - overlap = BM_Exist_Face_Overlaps(bm, verts, len, &f); + overlap = BM_face_exists_overlap(bm, verts, len, &f); } } /* make new face */ if ((!f) && (!overlap)) { - if (!edar[0]) edar[0] = BM_Make_Edge(bm, verts[0], verts[1], NULL, FALSE); - if (!edar[1]) edar[1] = BM_Make_Edge(bm, verts[1], verts[2], NULL, FALSE); + if (!edar[0]) edar[0] = BM_edge_create(bm, verts[0], verts[1], NULL, FALSE); + if (!edar[1]) edar[1] = BM_edge_create(bm, verts[1], verts[2], NULL, FALSE); if (len == 4) { - if (!edar[2]) edar[2] = BM_Make_Edge(bm, verts[2], verts[3], NULL, FALSE); - if (!edar[3]) edar[3] = BM_Make_Edge(bm, verts[3], verts[0], NULL, FALSE); + if (!edar[2]) edar[2] = BM_edge_create(bm, verts[2], verts[3], NULL, FALSE); + if (!edar[3]) edar[3] = BM_edge_create(bm, verts[3], verts[0], NULL, FALSE); } else { - if (!edar[2]) edar[2] = BM_Make_Edge(bm, verts[2], verts[0], NULL, FALSE); + if (!edar[2]) edar[2] = BM_edge_create(bm, verts[2], verts[0], NULL, FALSE); } - f = BM_Make_Face(bm, verts, edar, len, FALSE); + f = BM_face_create(bm, verts, edar, len, FALSE); if (example && f) { - BM_Copy_Attributes(bm, bm, example, f); + BM_elem_copy_attrs(bm, bm, example, f); } } @@ -186,15 +186,15 @@ BMFace *BM_Make_Face_QuadTri_v(BMesh *bm, BMVert **verts, int len, const BMFace /* copies face data from shared adjacent faces */ -void BM_Face_CopyShared(BMesh *bm, BMFace *f) +void BM_face_copy_shared(BMesh *bm, BMFace *f) { BMIter iter; BMLoop *l, *l2; if (!f) return; - l = BMIter_New(&iter, bm, BM_LOOPS_OF_FACE, f); - for ( ; l; l = BMIter_Step(&iter)) { + l = BM_iter_new(&iter, bm, BM_LOOPS_OF_FACE, f); + for ( ; l; l = BM_iter_step(&iter)) { l2 = l->radial_next; if (l2 && l2 != l) { @@ -220,10 +220,10 @@ void BM_Face_CopyShared(BMesh *bm, BMFace *f) * * Note that while this function will work fine when the edges * are already sorted, if the edges are always going to be sorted, - * BM_Make_Face should be considered over this function as it + * BM_face_create should be considered over this function as it * avoids some unnecessary work. */ -BMFace *BM_Make_Ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, int len, int nodouble) +BMFace *BM_face_create_ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, int len, int nodouble) { BMEdge **edges2 = NULL; BLI_array_staticdeclare(edges2, BM_NGON_STACK_SIZE); @@ -235,7 +235,7 @@ BMFace *BM_Make_Ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, int len, int i, /* j, */ v1found, reverse; /* this code is hideous, yeek. I'll have to think about ways of - * cleaning it up. basically, it now combines the old BM_Make_Ngon + * cleaning it up. basically, it now combines the old BM_face_create_ngon * _and_ the old bmesh_mf functions, so its kindof smashed together * - joeedh */ @@ -269,7 +269,7 @@ BMFace *BM_Make_Ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, int len, do { e2 = bmesh_disk_nextedge(e2, v); if (e2 != e && bmesh_api_getflag(e2, _FLAG_MF)) { - v = BM_OtherEdgeVert(e2, v); + v = BM_edge_other_vert(e2, v); break; } } while (e2 != e); @@ -288,12 +288,12 @@ BMFace *BM_Make_Ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, int len, * in the correct direction */ v1found = reverse = FALSE; for (i = 0; i < len; i++) { - if (BM_Vert_In_Edge(edges2[i], v1)) { + if (BM_vert_in_edge(edges2[i], v1)) { /* see if v1 and v2 are in the same edge */ - if (BM_Vert_In_Edge(edges2[i], v2)) { + if (BM_vert_in_edge(edges2[i], v2)) { /* if v1 is shared by the *next* edge, then the winding * is incorrect */ - if (BM_Vert_In_Edge(edges2[(i + 1) % len], v1)) { + if (BM_vert_in_edge(edges2[(i + 1) % len], v1)) { reverse = TRUE; break; } @@ -302,7 +302,7 @@ BMFace *BM_Make_Ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, int len, v1found = TRUE; } - if ((v1found == FALSE) && BM_Vert_In_Edge(edges2[i], v2)) { + if ((v1found == FALSE) && BM_vert_in_edge(edges2[i], v2)) { reverse = TRUE; break; } @@ -317,13 +317,13 @@ BMFace *BM_Make_Ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, int len, } for (i = 0; i < len; i++) { - edges2[i] = BM_Edge_Exist(verts[i], verts[(i + 1) % len]); + edges2[i] = BM_edge_exists(verts[i], verts[(i + 1) % len]); if (!edges2[i]) { goto err; } } - f = BM_Make_Face(bm, verts, edges2, len, nodouble); + f = BM_face_create(bm, verts, edges2, len, nodouble); /* clean up flags */ for (i = 0; i < len; i++) { @@ -364,8 +364,8 @@ void BMO_remove_tagged_faces(BMesh *bm, const short oflag) BMIter iter; BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) { - if (BMO_TestFlag(bm, f, oflag)) { - BM_Kill_Face(bm, f); + if (BMO_elem_flag_test(bm, f, oflag)) { + BM_face_kill(bm, f); } } } @@ -376,8 +376,8 @@ void BMO_remove_tagged_edges(BMesh *bm, const short oflag) BMIter iter; BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) { - if (BMO_TestFlag(bm, e, oflag)) { - BM_Kill_Edge(bm, e); + if (BMO_elem_flag_test(bm, e, oflag)) { + BM_edge_kill(bm, e); } } } @@ -388,8 +388,8 @@ void BMO_remove_tagged_verts(BMesh *bm, const short oflag) BMIter iter; BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) { - if (BMO_TestFlag(bm, v, oflag)) { - BM_Kill_Vert(bm, v); + if (BMO_elem_flag_test(bm, v, oflag)) { + BM_vert_kill(bm, v); } } } @@ -414,14 +414,14 @@ static void bmo_remove_tagged_context_verts(BMesh *bm, const short oflag) BMIter edges; BMIter faces; - for (v = BMIter_New(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BMIter_Step(&verts)) { - if (BMO_TestFlag(bm, (BMHeader *)v, oflag)) { + for (v = BM_iter_new(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BM_iter_step(&verts)) { + if (BMO_elem_flag_test(bm, (BMHeader *)v, oflag)) { /* Visit edge */ - for (e = BMIter_New(&edges, bm, BM_EDGES_OF_VERT, v); e; e = BMIter_Step(&edges)) - BMO_SetFlag(bm, (BMHeader *)e, oflag); + for (e = BM_iter_new(&edges, bm, BM_EDGES_OF_VERT, v); e; e = BM_iter_step(&edges)) + BMO_elem_flag_set(bm, (BMHeader *)e, oflag); /* Visit face */ - for (f = BMIter_New(&faces, bm, BM_FACES_OF_VERT, v); f; f = BMIter_Step(&faces)) - BMO_SetFlag(bm, (BMHeader *)f, oflag); + for (f = BM_iter_new(&faces, bm, BM_FACES_OF_VERT, v); f; f = BM_iter_step(&faces)) + BMO_elem_flag_set(bm, (BMHeader *)f, oflag); } } @@ -438,10 +438,10 @@ static void bmo_remove_tagged_context_edges(BMesh *bm, const short oflag) BMIter edges; BMIter faces; - for (e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)) { - if (BMO_TestFlag(bm, (BMHeader *)e, oflag)) { - for (f = BMIter_New(&faces, bm, BM_FACES_OF_EDGE, e); f; f = BMIter_Step(&faces)) { - BMO_SetFlag(bm, (BMHeader *)f, oflag); + for (e = BM_iter_new(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BM_iter_step(&edges)) { + if (BMO_elem_flag_test(bm, (BMHeader *)e, oflag)) { + for (f = BM_iter_new(&faces, bm, BM_FACES_OF_EDGE, e); f; f = BM_iter_step(&faces)) { + BMO_elem_flag_set(bm, (BMHeader *)f, oflag); } } } @@ -473,17 +473,17 @@ void BMO_remove_tagged_context(BMesh *bm, const short oflag, const int type) case DEL_EDGES: { /* flush down to vert */ - for (e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)) { - if (BMO_TestFlag(bm, (BMHeader *)e, oflag)) { - BMO_SetFlag(bm, (BMHeader *)(e->v1), oflag); - BMO_SetFlag(bm, (BMHeader *)(e->v2), oflag); + for (e = BM_iter_new(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BM_iter_step(&edges)) { + if (BMO_elem_flag_test(bm, (BMHeader *)e, oflag)) { + BMO_elem_flag_set(bm, (BMHeader *)(e->v1), oflag); + BMO_elem_flag_set(bm, (BMHeader *)(e->v2), oflag); } } bmo_remove_tagged_context_edges(bm, oflag); /* remove loose vertice */ - for (v = BMIter_New(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BMIter_Step(&verts)) { - if (BMO_TestFlag(bm, (BMHeader *)v, oflag) && (!(v->e))) - BMO_SetFlag(bm, (BMHeader *)v, DEL_WIREVERT); + for (v = BM_iter_new(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BM_iter_step(&verts)) { + if (BMO_elem_flag_test(bm, (BMHeader *)v, oflag) && (!(v->e))) + BMO_elem_flag_set(bm, (BMHeader *)v, DEL_WIREVERT); } BMO_remove_tagged_verts(bm, DEL_WIREVERT); @@ -512,30 +512,30 @@ 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 */ - for (f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces)) { - if (BMO_TestFlag(bm, (BMHeader *)f, oflag)) { - for (e = BMIter_New(&edges, bm, BM_EDGES_OF_FACE, f); e; e = BMIter_Step(&edges)) - BMO_SetFlag(bm, (BMHeader *)e, oflag); - for (v = BMIter_New(&verts, bm, BM_VERTS_OF_FACE, f); v; v = BMIter_Step(&verts)) - BMO_SetFlag(bm, (BMHeader *)v, oflag); + for (f = BM_iter_new(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BM_iter_step(&faces)) { + if (BMO_elem_flag_test(bm, (BMHeader *)f, oflag)) { + for (e = BM_iter_new(&edges, bm, BM_EDGES_OF_FACE, f); e; e = BM_iter_step(&edges)) + BMO_elem_flag_set(bm, (BMHeader *)e, oflag); + for (v = BM_iter_new(&verts, bm, BM_VERTS_OF_FACE, f); v; v = BM_iter_step(&verts)) + BMO_elem_flag_set(bm, (BMHeader *)v, oflag); } } /* now go through and mark all remaining faces all edges for keeping */ - for (f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces)) { - if (!BMO_TestFlag(bm, (BMHeader *)f, oflag)) { - for (e = BMIter_New(&edges, bm, BM_EDGES_OF_FACE, f); e; e = BMIter_Step(&edges)) { - BMO_ClearFlag(bm, (BMHeader *)e, oflag); + for (f = BM_iter_new(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BM_iter_step(&faces)) { + if (!BMO_elem_flag_test(bm, (BMHeader *)f, oflag)) { + for (e = BM_iter_new(&edges, bm, BM_EDGES_OF_FACE, f); e; e = BM_iter_step(&edges)) { + BMO_elem_flag_clear(bm, (BMHeader *)e, oflag); } - for (v = BMIter_New(&verts, bm, BM_VERTS_OF_FACE, f); v; v = BMIter_Step(&verts)) { - BMO_ClearFlag(bm, (BMHeader *)v, oflag); + for (v = BM_iter_new(&verts, bm, BM_VERTS_OF_FACE, f); v; v = BM_iter_step(&verts)) { + BMO_elem_flag_clear(bm, (BMHeader *)v, oflag); } } } /* also mark all the vertices of remaining edges for keeping */ - for (e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)) { - if (!BMO_TestFlag(bm, (BMHeader *)e, oflag)) { - BMO_ClearFlag(bm, (BMHeader *)e->v1, oflag); - BMO_ClearFlag(bm, (BMHeader *)e->v2, oflag); + for (e = BM_iter_new(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BM_iter_step(&edges)) { + if (!BMO_elem_flag_test(bm, (BMHeader *)e, oflag)) { + BMO_elem_flag_clear(bm, (BMHeader *)e->v1, oflag); + BMO_elem_flag_clear(bm, (BMHeader *)e->v2, oflag); } } /* now delete marked face */ @@ -550,12 +550,12 @@ void BMO_remove_tagged_context(BMesh *bm, const short oflag, const int type) case DEL_ALL: { /* does this option even belong in here? */ - for (f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces)) - BMO_SetFlag(bm, (BMHeader *)f, oflag); - for (e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)) - BMO_SetFlag(bm, (BMHeader *)e, oflag); - for (v = BMIter_New(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BMIter_Step(&verts)) - BMO_SetFlag(bm, (BMHeader *)v, oflag); + for (f = BM_iter_new(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BM_iter_step(&faces)) + BMO_elem_flag_set(bm, (BMHeader *)f, oflag); + for (e = BM_iter_new(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BM_iter_step(&edges)) + BMO_elem_flag_set(bm, (BMHeader *)e, oflag); + for (v = BM_iter_new(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BM_iter_step(&verts)) + BMO_elem_flag_set(bm, (BMHeader *)v, oflag); BMO_remove_tagged_faces(bm, oflag); BMO_remove_tagged_edges(bm, oflag); @@ -622,7 +622,7 @@ static void bm_copy_face_attributes(BMesh *source_mesh, BMesh *target_mesh, /* BMESH_TODO: Special handling for hide flags? */ -void BM_Copy_Attributes(BMesh *source_mesh, BMesh *target_mesh, const void *source, void *target) +void BM_elem_copy_attrs(BMesh *source_mesh, BMesh *target_mesh, const void *source, void *target) { const BMHeader *sheader = source; BMHeader *theader = target; @@ -631,7 +631,7 @@ void BM_Copy_Attributes(BMesh *source_mesh, BMesh *target_mesh, const void *sour return; /* First we copy select */ - if (BM_Selected(source_mesh, source)) BM_Select(target_mesh, target, TRUE); + if (BM_elem_select_test(source_mesh, source)) BM_elem_select_set(target_mesh, target, TRUE); /* Now we copy flags */ theader->hflag = sheader->hflag; @@ -647,7 +647,7 @@ void BM_Copy_Attributes(BMesh *source_mesh, BMesh *target_mesh, const void *sour bm_copy_face_attributes(source_mesh, target_mesh, (const BMFace *)source, (BMFace *)target); } -BMesh *BM_Copy_Mesh(BMesh *bmold) +BMesh *BM_mesh_copy(BMesh *bmold) { BMesh *bm; BMVert *v, *v2, **vtable = NULL; @@ -662,7 +662,7 @@ BMesh *BM_Copy_Mesh(BMesh *bmold) int i, j; /* allocate a bmesh */ - bm = BM_Make_Mesh(bmold->ob, allocsize); + bm = BM_mesh_create(bmold->ob, allocsize); CustomData_copy(&bmold->vdata, &bm->vdata, CD_MASK_BMESH, CD_CALLOC, 0); CustomData_copy(&bmold->edata, &bm->edata, CD_MASK_BMESH, CD_CALLOC, 0); @@ -674,17 +674,17 @@ BMesh *BM_Copy_Mesh(BMesh *bmold) CustomData_bmesh_init_pool(&bm->ldata, allocsize[2]); CustomData_bmesh_init_pool(&bm->pdata, allocsize[3]); - vtable = MEM_mallocN(sizeof(BMVert *) * bmold->totvert, "BM_Copy_Mesh vtable"); - etable = MEM_mallocN(sizeof(BMEdge *) * bmold->totedge, "BM_Copy_Mesh etable"); - ftable = MEM_mallocN(sizeof(BMFace *) * bmold->totface, "BM_Copy_Mesh ftable"); + vtable = MEM_mallocN(sizeof(BMVert *) * bmold->totvert, "BM_mesh_copy vtable"); + etable = MEM_mallocN(sizeof(BMEdge *) * bmold->totedge, "BM_mesh_copy etable"); + ftable = MEM_mallocN(sizeof(BMFace *) * bmold->totface, "BM_mesh_copy ftable"); - v = BMIter_New(&iter, bmold, BM_VERTS_OF_MESH, NULL); - for (i = 0; v; v = BMIter_Step(&iter), i++) { - v2 = BM_Make_Vert(bm, v->co, NULL); /* copy between meshes so cant use 'example' argument */ - BM_Copy_Attributes(bmold, bm, v, v2); + v = BM_iter_new(&iter, bmold, BM_VERTS_OF_MESH, NULL); + for (i = 0; v; v = BM_iter_step(&iter), i++) { + v2 = BM_vert_create(bm, v->co, NULL); /* copy between meshes so cant use 'example' argument */ + BM_elem_copy_attrs(bmold, bm, v, v2); vtable[i] = v2; - BM_SetIndex(v, i); /* set_inline */ - BM_SetIndex(v2, i); /* set_inline */ + BM_elem_index_set(v, i); /* set_inline */ + BM_elem_index_set(v2, i); /* set_inline */ } bmold->elem_index_dirty &= ~BM_VERT; bm->elem_index_dirty &= ~BM_VERT; @@ -692,17 +692,17 @@ BMesh *BM_Copy_Mesh(BMesh *bmold) /* safety check */ BLI_assert(i == bmold->totvert); - e = BMIter_New(&iter, bmold, BM_EDGES_OF_MESH, NULL); - for (i = 0; e; e = BMIter_Step(&iter), i++) { - e2 = BM_Make_Edge(bm, - vtable[BM_GetIndex(e->v1)], - vtable[BM_GetIndex(e->v2)], + e = BM_iter_new(&iter, bmold, BM_EDGES_OF_MESH, NULL); + for (i = 0; e; e = BM_iter_step(&iter), i++) { + e2 = BM_edge_create(bm, + vtable[BM_elem_index_get(e->v1)], + vtable[BM_elem_index_get(e->v2)], e, FALSE); - BM_Copy_Attributes(bmold, bm, e, e2); + BM_elem_copy_attrs(bmold, bm, e, e2); etable[i] = e2; - BM_SetIndex(e, i); /* set_inline */ - BM_SetIndex(e2, i); /* set_inline */ + BM_elem_index_set(e, i); /* set_inline */ + BM_elem_index_set(e2, i); /* set_inline */ } bmold->elem_index_dirty &= ~BM_EDGE; bm->elem_index_dirty &= ~BM_EDGE; @@ -710,43 +710,43 @@ BMesh *BM_Copy_Mesh(BMesh *bmold) /* safety check */ BLI_assert(i == bmold->totedge); - f = BMIter_New(&iter, bmold, BM_FACES_OF_MESH, NULL); - for (i = 0; f; f = BMIter_Step(&iter), i++) { - BM_SetIndex(f, i); /* set_inline */ + f = BM_iter_new(&iter, bmold, BM_FACES_OF_MESH, NULL); + for (i = 0; f; f = BM_iter_step(&iter), i++) { + BM_elem_index_set(f, i); /* set_inline */ BLI_array_empty(loops); BLI_array_empty(edges); BLI_array_growitems(loops, f->len); BLI_array_growitems(edges, f->len); - l = BMIter_New(&liter, bmold, BM_LOOPS_OF_FACE, f); - for (j = 0; j < f->len; j++, l = BMIter_Step(&liter)) { + l = BM_iter_new(&liter, bmold, BM_LOOPS_OF_FACE, f); + for (j = 0; j < f->len; j++, l = BM_iter_step(&liter)) { loops[j] = l; - edges[j] = etable[BM_GetIndex(l->e)]; + edges[j] = etable[BM_elem_index_get(l->e)]; } - v = vtable[BM_GetIndex(loops[0]->v)]; - v2 = vtable[BM_GetIndex(loops[1]->v)]; + v = vtable[BM_elem_index_get(loops[0]->v)]; + v2 = vtable[BM_elem_index_get(loops[1]->v)]; if (!bmesh_verts_in_edge(v, v2, edges[0])) { - v = vtable[BM_GetIndex(loops[BLI_array_count(loops) - 1]->v)]; - v2 = vtable[BM_GetIndex(loops[0]->v)]; + v = vtable[BM_elem_index_get(loops[BLI_array_count(loops) - 1]->v)]; + v2 = vtable[BM_elem_index_get(loops[0]->v)]; } - f2 = BM_Make_Ngon(bm, v, v2, edges, f->len, FALSE); + f2 = BM_face_create_ngon(bm, v, v2, edges, f->len, FALSE); if (!f2) continue; /* use totface incase adding some faces fails */ - BM_SetIndex(f2, (bm->totface - 1)); /* set_inline */ + BM_elem_index_set(f2, (bm->totface - 1)); /* set_inline */ ftable[i] = f2; - BM_Copy_Attributes(bmold, bm, f, f2); + BM_elem_copy_attrs(bmold, bm, f, f2); copy_v3_v3(f2->no, f->no); - l = BMIter_New(&liter, bm, BM_LOOPS_OF_FACE, f2); - for (j = 0; j < f->len; j++, l = BMIter_Step(&liter)) { - BM_Copy_Attributes(bmold, bm, loops[j], l); + l = BM_iter_new(&liter, bm, BM_LOOPS_OF_FACE, f2); + for (j = 0; j < f->len; j++, l = BM_iter_step(&liter)) { + BM_elem_copy_attrs(bmold, bm, loops[j], l); } if (f == bmold->act_face) bm->act_face = f2; @@ -762,18 +762,18 @@ BMesh *BM_Copy_Mesh(BMesh *bmold) void *ele = NULL; if (ese->htype == BM_VERT) - ele = vtable[BM_GetIndex(ese->data)]; + ele = vtable[BM_elem_index_get(ese->data)]; else if (ese->htype == BM_EDGE) - ele = etable[BM_GetIndex(ese->data)]; + ele = etable[BM_elem_index_get(ese->data)]; else if (ese->htype == BM_FACE) { - ele = ftable[BM_GetIndex(ese->data)]; + ele = ftable[BM_elem_index_get(ese->data)]; } else { BLI_assert(0); } if (ele) - BM_store_selection(bm, ele); + BM_select_history_store(bm, ele); } MEM_freeN(etable); @@ -787,13 +787,13 @@ BMesh *BM_Copy_Mesh(BMesh *bmold) } /* ME -> BM */ -char BM_Vert_Flag_From_MEFlag(const char meflag) +char BM_vert_flag_from_mflag(const char meflag) { return ( ((meflag & SELECT) ? BM_ELEM_SELECT : 0) | ((meflag & ME_HIDE) ? BM_ELEM_HIDDEN : 0) ); } -char BM_Edge_Flag_From_MEFlag(const short meflag) +char BM_edge_flag_from_mflag(const short meflag) { return ( ((meflag & SELECT) ? BM_ELEM_SELECT : 0) | ((meflag & ME_SEAM) ? BM_ELEM_SEAM : 0) | @@ -801,7 +801,7 @@ char BM_Edge_Flag_From_MEFlag(const short meflag) ((meflag & ME_HIDE) ? BM_ELEM_HIDDEN : 0) ); } -char BM_Face_Flag_From_MEFlag(const char meflag) +char BM_face_flag_from_mflag(const char meflag) { return ( ((meflag & ME_FACE_SEL) ? BM_ELEM_SELECT : 0) | ((meflag & ME_SMOOTH) ? BM_ELEM_SMOOTH : 0) | @@ -810,7 +810,7 @@ char BM_Face_Flag_From_MEFlag(const char meflag) } /* BM -> ME */ -char BM_Vert_Flag_To_MEFlag(BMVert *eve) +char BM_vert_flag_to_mflag(BMVert *eve) { const char hflag = eve->head.hflag; @@ -818,7 +818,7 @@ char BM_Vert_Flag_To_MEFlag(BMVert *eve) ((hflag & BM_ELEM_HIDDEN) ? ME_HIDE : 0) ); } -short BM_Edge_Flag_To_MEFlag(BMEdge *eed) +short BM_edge_flag_to_mflag(BMEdge *eed) { const char hflag = eed->head.hflag; @@ -826,11 +826,11 @@ short BM_Edge_Flag_To_MEFlag(BMEdge *eed) ((hflag & BM_ELEM_SEAM) ? ME_SEAM : 0) | ((hflag & BM_ELEM_SHARP) ? ME_SHARP : 0) | ((hflag & BM_ELEM_HIDDEN) ? ME_HIDE : 0) | - ((BM_Wire_Edge(NULL, eed)) ? ME_LOOSEEDGE : 0) | /* not typical */ + ((BM_edge_is_wire(NULL, eed)) ? ME_LOOSEEDGE : 0) | /* not typical */ (ME_EDGEDRAW | ME_EDGERENDER) ); } -char BM_Face_Flag_To_MEFlag(BMFace *efa) +char BM_face_flag_to_mflag(BMFace *efa) { const char hflag = efa->head.hflag; @@ -839,56 +839,3 @@ char BM_Face_Flag_To_MEFlag(BMFace *efa) ((hflag & BM_ELEM_HIDDEN) ? ME_HIDE : 0) ); } - -/* unused, type spesific functions below */ -#if 0 -/* - BM FLAGS TO ME FLAGS - - Returns the flags stored in element, - which much be either a BMVert, BMEdge, - or BMFace, converted to mesh flags. - */ -short BMFlags_To_MEFlags(void *element) -{ - const char src_htype = ((BMHeader *)element)->htype; - - if (src_htype == BM_FACE) { - return BM_Face_Flag_To_MEFlag(element); - } - else if (src_htype == BM_EDGE) { - return BM_Edge_Flag_To_MEFlag(element); - } - else if (src_htype == BM_VERT) { - return BM_Vert_Flag_To_MEFlag(element); - } - else { - return 0; - } -} - -/* - BM FLAGS TO ME FLAGS - - Returns the flags stored in element, - which much be either a MVert, MEdge, - or MPoly, converted to mesh flags. - type must be either BM_VERT, BM_EDGE, - or BM_FACE. - */ -char MEFlags_To_BMFlags(const short hflag, const char htype) -{ - if (htype == BM_FACE) { - return BM_Face_Flag_From_MEFlag(hflag); - } - else if (htype == BM_EDGE) { - return BM_Edge_Flag_From_MEFlag(hflag); - } - else if (htype == BM_VERT) { - return BM_Vert_Flag_From_MEFlag(hflag); - } - else { - return 0; - } -} -#endif diff --git a/source/blender/bmesh/intern/bmesh_eulers.c b/source/blender/bmesh/intern/bmesh_eulers.c index 65cb2b3581f..b1ba4ca3176 100644 --- a/source/blender/bmesh/intern/bmesh_eulers.c +++ b/source/blender/bmesh/intern/bmesh_eulers.c @@ -362,7 +362,7 @@ BMFace *bmesh_mf(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **elist, int len) int bmesh_kv(BMesh *bm, BMVert *v) { if(v->e == NULL) { - if (BM_TestHFlag(v, BM_ELEM_SELECT)) bm->totvertsel--; + if (BM_elem_flag_test(v, BM_ELEM_SELECT)) bm->totvertsel--; BLI_remlink(&(bm->verts), &(v->head)); bmesh_free_vert(bm,v); @@ -398,7 +398,7 @@ int bmesh_ke(BMesh *bm, BMEdge *e) if(edok) bmesh_error(); /*remove and deallocate*/ - if (BM_TestHFlag(e, BM_ELEM_SELECT)) bm->totedgesel--; + if (BM_elem_flag_test(e, BM_ELEM_SELECT)) bm->totedgesel--; BLI_remlink(&(bm->edges), &(e->head)); bmesh_free_edge(bm, e); return 1; @@ -438,7 +438,7 @@ int bmesh_kf(BMesh *bm, BMFace *bply) bply->loopbase = newbase; } - if (BM_TestHFlag(bply, BM_ELEM_SELECT)) bm->totfacesel--; + if (BM_elem_flag_test(bply, BM_ELEM_SELECT)) bm->totfacesel--; BLI_remlink(&(bm->polys), &(bply->head)); bmesh_free_poly(bm, bply); return 1; @@ -982,7 +982,7 @@ BMFace *bmesh_jfke(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e) if(bmesh_radial_find_face( ((f2loop->prev))->e,f1)) return NULL; /*validate only one shared edge*/ - shared = BM_Face_Share_Edges(f1,f2); + shared = BM_face_share_edges(f1,f2); if(shared > 1) return NULL; /*validate no internal joins*/ diff --git a/source/blender/bmesh/intern/bmesh_inline.c b/source/blender/bmesh/intern/bmesh_inline.c index 54339610a9f..50a83bef674 100644 --- a/source/blender/bmesh/intern/bmesh_inline.c +++ b/source/blender/bmesh/intern/bmesh_inline.c @@ -31,39 +31,39 @@ #include "bmesh.h" -BM_INLINE char BM_TestHFlag(const void *element, const char hflag) +BM_INLINE char BM_elem_flag_test(const void *element, const char hflag) { return ((const BMHeader *)element)->hflag & hflag; } -BM_INLINE void BM_SetHFlag(void *element, const char hflag) +BM_INLINE void BM_elem_flag_set(void *element, const char hflag) { ((BMHeader *)element)->hflag |= hflag; } -BM_INLINE void BM_ClearHFlag(void *element, const char hflag) +BM_INLINE void BM_elem_flag_clear(void *element, const char hflag) { ((BMHeader *)element)->hflag &= ~hflag; } -BM_INLINE void BM_ToggleHFlag(void *element, const char hflag) +BM_INLINE void BM_elem_flag_toggle(void *element, const char hflag) { ((BMHeader *)element)->hflag ^= hflag; } -BM_INLINE void BM_MergeHFlag(void *element_a, void *element_b) +BM_INLINE void BM_elem_flag_merge(void *element_a, void *element_b) { ((BMHeader *)element_a)->hflag = ((BMHeader *)element_b)->hflag = (((BMHeader *)element_a)->hflag | ((BMHeader *)element_b)->hflag); } -BM_INLINE void BM_SetIndex(void *element, const int index) +BM_INLINE void BM_elem_index_set(void *element, const int index) { ((BMHeader *)element)->index = index; } -BM_INLINE int BM_GetIndex(const void *element) +BM_INLINE int BM_elem_index_get(const void *element) { return ((BMHeader *)element)->index; } diff --git a/source/blender/bmesh/intern/bmesh_interp.c b/source/blender/bmesh/intern/bmesh_interp.c index 69fd80b039c..ec94bd6de59 100644 --- a/source/blender/bmesh/intern/bmesh_interp.c +++ b/source/blender/bmesh/intern/bmesh_interp.c @@ -50,7 +50,7 @@ * * Interpolates per-vertex data from two sources to a target. */ -void BM_Data_Interp_From_Verts(BMesh *bm, BMVert *v1, BMVert *v2, BMVert *v, float fac) +void BM_data_interp_from_verts(BMesh *bm, BMVert *v1, BMVert *v2, BMVert *v, float fac) { if (v1->head.data && v2->head.data) { /* first see if we can avoid interpolation */ @@ -108,7 +108,7 @@ static void UNUSED_FUNCTION(BM_Data_Vert_Average)(BMesh *UNUSED(bm), BMFace *UNU * Nothing */ -void BM_Data_Facevert_Edgeinterp(BMesh *bm, BMVert *v1, BMVert *UNUSED(v2), BMVert *v, BMEdge *e1, float fac) +void BM_data_interp_face_vert_edge(BMesh *bm, BMVert *v1, BMVert *UNUSED(v2), BMVert *v, BMEdge *e1, float fac) { void *src[2]; float w[2]; @@ -207,7 +207,7 @@ void BM_face_interp_from_face(BMesh *bm, BMFace *target, BMFace *source) BLI_array_fixedstack_declare(blocks, BM_NGON_STACK_SIZE, source->len, __func__); int i; - BM_Copy_Attributes(bm, bm, source, target); + BM_elem_copy_attrs(bm, bm, source, target); i = 0; l_iter = l_first = BM_FACE_FIRST_LOOP(source); @@ -511,9 +511,9 @@ static int mdisp_in_mdispquad(BMesh *bm, BMLoop *l, BMLoop *tl, double p[3], dou double eps = FLT_EPSILON * 4000; if (len_v3(l->v->no) == 0.0f) - BM_Vert_UpdateAllNormals(bm, l->v); + BM_vert_normal_update_all(bm, l->v); if (len_v3(tl->v->no) == 0.0f) - BM_Vert_UpdateAllNormals(bm, tl->v); + BM_vert_normal_update_all(bm, tl->v); compute_mdisp_quad(tl, v1, v2, v3, v4, e1, e2); @@ -612,7 +612,7 @@ static void bmesh_loop_interp_mdisps(BMesh *bm, BMLoop *target, BMFace *source) } } -void BM_multires_smooth_bounds(BMesh *bm, BMFace *f) +void BM_face_multires_bounds_smooth(BMesh *bm, BMFace *f) { BMLoop *l; BMIter liter; @@ -733,7 +733,7 @@ void BM_loop_interp_from_face(BMesh *bm, BMLoop *target, BMFace *source, BLI_array_fixedstack_declare(vblocks, BM_NGON_STACK_SIZE, do_vertex ? source->len : 0, __func__); int i, ax, ay; - BM_Copy_Attributes(bm, bm, source, target->f); + BM_elem_copy_attrs(bm, bm, source, target->f); i = 0; l_iter = l_first = BM_FACE_FIRST_LOOP(source); @@ -901,7 +901,7 @@ static void update_data_blocks(BMesh *bm, CustomData *olddata, CustomData *data) } } -void BM_add_data_layer(BMesh *bm, CustomData *data, int type) +void BM_data_layer_add(BMesh *bm, CustomData *data, int type) { CustomData olddata; @@ -917,7 +917,7 @@ void BM_add_data_layer(BMesh *bm, CustomData *data, int type) if (olddata.layers) MEM_freeN(olddata.layers); } -void BM_add_data_layer_named(BMesh *bm, CustomData *data, int type, const char *name) +void BM_data_layer_add_named(BMesh *bm, CustomData *data, int type, const char *name) { CustomData olddata; @@ -933,7 +933,7 @@ void BM_add_data_layer_named(BMesh *bm, CustomData *data, int type, const char * if (olddata.layers) MEM_freeN(olddata.layers); } -void BM_free_data_layer(BMesh *bm, CustomData *data, int type) +void BM_data_layer_free(BMesh *bm, CustomData *data, int type) { CustomData olddata; @@ -949,7 +949,7 @@ void BM_free_data_layer(BMesh *bm, CustomData *data, int type) if (olddata.layers) MEM_freeN(olddata.layers); } -void BM_free_data_layer_n(BMesh *bm, CustomData *data, int type, int n) +void BM_data_layer_free_n(BMesh *bm, CustomData *data, int type, int n) { CustomData olddata; @@ -965,13 +965,13 @@ void BM_free_data_layer_n(BMesh *bm, CustomData *data, int type, int n) if (olddata.layers) MEM_freeN(olddata.layers); } -float BM_GetCDf(CustomData *cd, void *element, int type) +float BM_elem_float_data_get(CustomData *cd, void *element, int type) { float *f = CustomData_bmesh_get(cd, ((BMHeader *)element)->data, type); return f ? *f : 0.0f; } -void BM_SetCDf(CustomData *cd, void *element, int type, float val) +void BM_elem_float_data_set(CustomData *cd, void *element, int type, const float val) { float *f = CustomData_bmesh_get(cd, ((BMHeader *)element)->data, type); if (f) *f = val; diff --git a/source/blender/bmesh/intern/bmesh_iterators.c b/source/blender/bmesh/intern/bmesh_iterators.c index 0603a498354..0e839762971 100644 --- a/source/blender/bmesh/intern/bmesh_iterators.c +++ b/source/blender/bmesh/intern/bmesh_iterators.c @@ -33,9 +33,9 @@ #include "bmesh_private.h" /* - * note, we have BM_Vert_AtIndex/BM_Edge_AtIndex/BM_Face_AtIndex for arrays + * note, we have BM_vert_at_index/BM_edge_at_index/BM_face_at_index for arrays */ -void *BMIter_AtIndex(struct BMesh *bm, const char itype, void *data, int index) +void *BM_iter_at_index(struct BMesh *bm, const char itype, void *data, int index) { BMIter iter; void *val; @@ -46,11 +46,11 @@ void *BMIter_AtIndex(struct BMesh *bm, const char itype, void *data, int index) return NULL; } - val = BMIter_New(&iter, bm, itype, data); + val = BM_iter_new(&iter, bm, itype, data); i = 0; while (i < index) { - val = BMIter_Step(&iter); + val = BM_iter_step(&iter); i++; } @@ -62,10 +62,10 @@ void *BMIter_AtIndex(struct BMesh *bm, const char itype, void *data, int index) * ITERATOR AS ARRAY * * Sometimes its convenient to get the iterator as an array - * to avoid multiple calls to BMIter_AtIndex. + * to avoid multiple calls to BM_iter_at_index. */ -int BMIter_AsArray(struct BMesh *bm, const char type, void *data, void **array, const int len) +int BM_iter_as_array(struct BMesh *bm, const char type, void *data, void **array, const int len) { int i = 0; diff --git a/source/blender/bmesh/intern/bmesh_iterators_inline.c b/source/blender/bmesh/intern/bmesh_iterators_inline.c index eb04fe068a7..d403508885e 100644 --- a/source/blender/bmesh/intern/bmesh_iterators_inline.c +++ b/source/blender/bmesh/intern/bmesh_iterators_inline.c @@ -41,7 +41,7 @@ * the next element. */ -BM_INLINE void *BMIter_Step(BMIter *iter) +BM_INLINE void *BM_iter_step(BMIter *iter) { return iter->step(iter); } @@ -56,7 +56,7 @@ BM_INLINE void *BMIter_Step(BMIter *iter) * to return the first element of the iterator. * */ -BM_INLINE void *BMIter_New(BMIter *iter, BMesh *bm, const char itype, void *data) +BM_INLINE void *BM_iter_new(BMIter *iter, BMesh *bm, const char itype, void *data) { /* int argtype; */ iter->itype = itype; @@ -153,7 +153,7 @@ BM_INLINE void *BMIter_New(BMIter *iter, BMesh *bm, const char itype, void *data } iter->begin(iter); - return BMIter_Step(iter); + return BM_iter_step(iter); } diff --git a/source/blender/bmesh/intern/bmesh_marking.c b/source/blender/bmesh/intern/bmesh_marking.c index ff52424ef12..6e23979d4aa 100644 --- a/source/blender/bmesh/intern/bmesh_marking.c +++ b/source/blender/bmesh/intern/bmesh_marking.c @@ -69,14 +69,14 @@ static void recount_totsels(BMesh *bm) tots[2] = &bm->totfacesel; for (i = 0; i < 3; i++) { - ele = BMIter_New(&iter, bm, iter_types[i], NULL); - for ( ; ele; ele = BMIter_Step(&iter)) { - if (BM_TestHFlag(ele, BM_ELEM_SELECT)) *tots[i] += 1; + ele = BM_iter_new(&iter, bm, iter_types[i], NULL); + for ( ; ele; ele = BM_iter_step(&iter)) { + if (BM_elem_flag_test(ele, BM_ELEM_SELECT)) *tots[i] += 1; } } } -void BM_SelectMode_Flush(BMesh *bm) +void BM_mesh_select_mode_flush(BMesh *bm) { BMEdge *e; BMLoop *l_iter; @@ -89,20 +89,20 @@ void BM_SelectMode_Flush(BMesh *bm) int ok; if (bm->selectmode & SCE_SELECT_VERTEX) { - for (e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)) { - if (BM_TestHFlag(e->v1, BM_ELEM_SELECT) && BM_TestHFlag(e->v2, BM_ELEM_SELECT) && !BM_TestHFlag(e, BM_ELEM_HIDDEN)) { - BM_SetHFlag(e, BM_ELEM_SELECT); + for (e = BM_iter_new(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BM_iter_step(&edges)) { + 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)) { + BM_elem_flag_set(e, BM_ELEM_SELECT); } else { - BM_ClearHFlag(e, BM_ELEM_SELECT); + BM_elem_flag_clear(e, BM_ELEM_SELECT); } } - for (f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces)) { + for (f = BM_iter_new(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BM_iter_step(&faces)) { ok = TRUE; - if (!BM_TestHFlag(f, BM_ELEM_HIDDEN)) { + if (!BM_elem_flag_test(f, BM_ELEM_HIDDEN)) { l_iter = l_first = BM_FACE_FIRST_LOOP(f); do { - if (!BM_TestHFlag(l_iter->v, BM_ELEM_SELECT)) { + if (!BM_elem_flag_test(l_iter->v, BM_ELEM_SELECT)) { ok = FALSE; break; } @@ -113,20 +113,20 @@ void BM_SelectMode_Flush(BMesh *bm) } if (ok) { - BM_SetHFlag(f, BM_ELEM_SELECT); + BM_elem_flag_set(f, BM_ELEM_SELECT); } else { - BM_ClearHFlag(f, BM_ELEM_SELECT); + BM_elem_flag_clear(f, BM_ELEM_SELECT); } } } else if (bm->selectmode & SCE_SELECT_EDGE) { - for (f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces)) { + for (f = BM_iter_new(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BM_iter_step(&faces)) { ok = TRUE; - if (!BM_TestHFlag(f, BM_ELEM_HIDDEN)) { + if (!BM_elem_flag_test(f, BM_ELEM_HIDDEN)) { l_iter = l_first = BM_FACE_FIRST_LOOP(f); do { - if (!BM_TestHFlag(&(l_iter->e->head), BM_ELEM_SELECT)) { + if (!BM_elem_flag_test(&(l_iter->e->head), BM_ELEM_SELECT)) { ok = FALSE; break; } @@ -137,22 +137,22 @@ void BM_SelectMode_Flush(BMesh *bm) } if (ok) { - BM_SetHFlag(f, BM_ELEM_SELECT); + BM_elem_flag_set(f, BM_ELEM_SELECT); } else { - BM_ClearHFlag(f, BM_ELEM_SELECT); + BM_elem_flag_clear(f, BM_ELEM_SELECT); } } } /* Remove any deselected elements from the BMEditSelection */ - BM_validate_selections(bm); + BM_select_history_validate(bm); recount_totsels(bm); } /* BMESH NOTE: matches EM_deselect_flush() behavior from trunk */ -void BM_DeSelect_Flush(BMesh *bm) +void BM_mesh_deselect_flush(BMesh *bm) { BMEdge *e; BMLoop *l_iter; @@ -164,18 +164,18 @@ void BM_DeSelect_Flush(BMesh *bm) int ok; - for (e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)) { - if (!(BM_TestHFlag(e->v1, BM_ELEM_SELECT) && BM_TestHFlag(e->v2, BM_ELEM_SELECT) && !BM_TestHFlag(e, BM_ELEM_HIDDEN))) { - BM_ClearHFlag(e, BM_ELEM_SELECT); + for (e = BM_iter_new(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BM_iter_step(&edges)) { + 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))) { + BM_elem_flag_clear(e, BM_ELEM_SELECT); } } - for (f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces)) { + for (f = BM_iter_new(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BM_iter_step(&faces)) { ok = TRUE; - if (!BM_TestHFlag(f, BM_ELEM_HIDDEN)) { + if (!BM_elem_flag_test(f, BM_ELEM_HIDDEN)) { l_iter = l_first = BM_FACE_FIRST_LOOP(f); do { - if (!BM_TestHFlag(l_iter->v, BM_ELEM_SELECT)) { + if (!BM_elem_flag_test(l_iter->v, BM_ELEM_SELECT)) { ok = FALSE; break; } @@ -186,19 +186,19 @@ void BM_DeSelect_Flush(BMesh *bm) } if (ok == FALSE) { - BM_ClearHFlag(f, BM_ELEM_SELECT); + BM_elem_flag_clear(f, BM_ELEM_SELECT); } } /* Remove any deselected elements from the BMEditSelection */ - BM_validate_selections(bm); + BM_select_history_validate(bm); recount_totsels(bm); } /* BMESH NOTE: matches EM_select_flush() behavior from trunk */ -void BM_Select_Flush(BMesh *bm) +void BM_mesh_select_flush(BMesh *bm) { BMEdge *e; BMLoop *l_iter; @@ -210,18 +210,18 @@ void BM_Select_Flush(BMesh *bm) int ok; - for (e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)) { - if (BM_TestHFlag(e->v1, BM_ELEM_SELECT) && BM_TestHFlag(e->v2, BM_ELEM_SELECT) && !BM_TestHFlag(e, BM_ELEM_HIDDEN)) { - BM_SetHFlag(e, BM_ELEM_SELECT); + for (e = BM_iter_new(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BM_iter_step(&edges)) { + 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)) { + BM_elem_flag_set(e, BM_ELEM_SELECT); } } - for (f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces)) { + for (f = BM_iter_new(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BM_iter_step(&faces)) { ok = TRUE; - if (!BM_TestHFlag(f, BM_ELEM_HIDDEN)) { + if (!BM_elem_flag_test(f, BM_ELEM_HIDDEN)) { l_iter = l_first = BM_FACE_FIRST_LOOP(f); do { - if (!BM_TestHFlag(l_iter->v, BM_ELEM_SELECT)) { + if (!BM_elem_flag_test(l_iter->v, BM_ELEM_SELECT)) { ok = FALSE; break; } @@ -232,7 +232,7 @@ void BM_Select_Flush(BMesh *bm) } if (ok) { - BM_SetHFlag(f, BM_ELEM_SELECT); + BM_elem_flag_set(f, BM_ELEM_SELECT); } } @@ -248,25 +248,25 @@ void BM_Select_Flush(BMesh *bm) * */ -void BM_Select_Vert(BMesh *bm, BMVert *v, int select) +void BM_vert_select(BMesh *bm, BMVert *v, int select) { /* BMIter iter; */ /* BMEdge *e; */ - if (BM_TestHFlag(v, BM_ELEM_HIDDEN)) { + if (BM_elem_flag_test(v, BM_ELEM_HIDDEN)) { return; } if (select) { - if (!BM_TestHFlag(v, BM_ELEM_SELECT)) { + if (!BM_elem_flag_test(v, BM_ELEM_SELECT)) { bm->totvertsel += 1; - BM_SetHFlag(v, BM_ELEM_SELECT); + BM_elem_flag_set(v, BM_ELEM_SELECT); } } else { - if (BM_TestHFlag(v, BM_ELEM_SELECT)) { + if (BM_elem_flag_test(v, BM_ELEM_SELECT)) { bm->totvertsel -= 1; - BM_ClearHFlag(v, BM_ELEM_SELECT); + BM_elem_flag_clear(v, BM_ELEM_SELECT); } } } @@ -279,22 +279,22 @@ void BM_Select_Vert(BMesh *bm, BMVert *v, int select) * */ -void BM_Select_Edge(BMesh *bm, BMEdge *e, int select) +void BM_edge_select(BMesh *bm, BMEdge *e, int select) { - if (BM_TestHFlag(e, BM_ELEM_HIDDEN)) { + if (BM_elem_flag_test(e, BM_ELEM_HIDDEN)) { return; } if (select) { - if (!BM_TestHFlag(e, BM_ELEM_SELECT)) bm->totedgesel += 1; + if (!BM_elem_flag_test(e, BM_ELEM_SELECT)) bm->totedgesel += 1; - BM_SetHFlag(&(e->head), BM_ELEM_SELECT); - BM_Select(bm, e->v1, TRUE); - BM_Select(bm, e->v2, TRUE); + BM_elem_flag_set(&(e->head), BM_ELEM_SELECT); + BM_elem_select_set(bm, e->v1, TRUE); + BM_elem_select_set(bm, e->v2, TRUE); } else { - if (BM_TestHFlag(e, BM_ELEM_SELECT)) bm->totedgesel -= 1; - BM_ClearHFlag(&(e->head), BM_ELEM_SELECT); + if (BM_elem_flag_test(e, BM_ELEM_SELECT)) bm->totedgesel -= 1; + BM_elem_flag_clear(&(e->head), BM_ELEM_SELECT); if ( bm->selectmode == SCE_SELECT_EDGE || bm->selectmode == SCE_SELECT_FACE || @@ -309,23 +309,23 @@ void BM_Select_Edge(BMesh *bm, BMEdge *e, int select) for (i = 0; i < 2; i++) { int deselect = 1; - for (e2 = BMIter_New(&iter, bm, BM_EDGES_OF_VERT, verts[i]); e2; e2 = BMIter_Step(&iter)) { + for (e2 = BM_iter_new(&iter, bm, BM_EDGES_OF_VERT, verts[i]); e2; e2 = BM_iter_step(&iter)) { if (e2 == e) { continue; } - if (BM_TestHFlag(e2, BM_ELEM_SELECT)) { + if (BM_elem_flag_test(e2, BM_ELEM_SELECT)) { deselect = 0; break; } } - if (deselect) BM_Select_Vert(bm, verts[i], FALSE); + if (deselect) BM_vert_select(bm, verts[i], FALSE); } } else { - BM_Select(bm, e->v1, FALSE); - BM_Select(bm, e->v2, FALSE); + BM_elem_select_set(bm, e->v1, FALSE); + BM_elem_select_set(bm, e->v2, FALSE); } } @@ -340,44 +340,44 @@ void BM_Select_Edge(BMesh *bm, BMEdge *e, int select) * */ -void BM_Select_Face(BMesh *bm, BMFace *f, int select) +void BM_face_select(BMesh *bm, BMFace *f, int select) { BMLoop *l_iter; BMLoop *l_first; - if (BM_TestHFlag(f, BM_ELEM_HIDDEN)) { + if (BM_elem_flag_test(f, BM_ELEM_HIDDEN)) { return; } if (select) { - if (!BM_TestHFlag(f, BM_ELEM_SELECT)) bm->totfacesel += 1; + if (!BM_elem_flag_test(f, BM_ELEM_SELECT)) bm->totfacesel += 1; - BM_SetHFlag(&(f->head), BM_ELEM_SELECT); + BM_elem_flag_set(&(f->head), BM_ELEM_SELECT); l_iter = l_first = BM_FACE_FIRST_LOOP(f); do { - BM_Select_Vert(bm, l_iter->v, TRUE); - BM_Select_Edge(bm, l_iter->e, TRUE); + BM_vert_select(bm, l_iter->v, TRUE); + BM_edge_select(bm, l_iter->e, TRUE); } while ((l_iter = l_iter->next) != l_first); } else { BMIter liter; BMLoop *l; - if (BM_TestHFlag(f, BM_ELEM_SELECT)) bm->totfacesel -= 1; - BM_ClearHFlag(&(f->head), BM_ELEM_SELECT); + if (BM_elem_flag_test(f, BM_ELEM_SELECT)) bm->totfacesel -= 1; + BM_elem_flag_clear(&(f->head), BM_ELEM_SELECT); /* flush down to edges */ BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, f) { BMIter fiter; BMFace *f2; BM_ITER(f2, &fiter, bm, BM_FACES_OF_EDGE, l->e) { - if (BM_TestHFlag(f2, BM_ELEM_SELECT)) + if (BM_elem_flag_test(f2, BM_ELEM_SELECT)) break; } if (!f2) { - BM_Select(bm, l->e, FALSE); + BM_elem_select_set(bm, l->e, FALSE); } } @@ -386,12 +386,12 @@ void BM_Select_Face(BMesh *bm, BMFace *f, int select) BMIter eiter; BMEdge *e; BM_ITER(e, &eiter, bm, BM_EDGES_OF_VERT, l->v) { - if (BM_TestHFlag(e, BM_ELEM_SELECT)) + if (BM_elem_flag_test(e, BM_ELEM_SELECT)) break; } if (!e) { - BM_Select(bm, l->v, FALSE); + BM_elem_select_set(bm, l->v, FALSE); } } } @@ -404,7 +404,7 @@ void BM_Select_Face(BMesh *bm, BMFace *f, int select) * */ -void BM_Selectmode_Set(BMesh *bm, int selectmode) +void BM_select_mode_set(BMesh *bm, int selectmode) { BMVert *v; BMEdge *e; @@ -417,57 +417,57 @@ void BM_Selectmode_Set(BMesh *bm, int selectmode) bm->selectmode = selectmode; if (bm->selectmode & SCE_SELECT_VERTEX) { - for (e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)) - BM_ClearHFlag(e, 0); - for (f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces)) - BM_ClearHFlag(f, 0); - BM_SelectMode_Flush(bm); + for (e = BM_iter_new(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BM_iter_step(&edges)) + BM_elem_flag_clear(e, 0); + for (f = BM_iter_new(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BM_iter_step(&faces)) + BM_elem_flag_clear(f, 0); + BM_mesh_select_mode_flush(bm); } else if (bm->selectmode & SCE_SELECT_EDGE) { - for (v = BMIter_New(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BMIter_Step(&verts)) - BM_ClearHFlag(v, 0); - for (e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)) { - if (BM_TestHFlag(&(e->head), BM_ELEM_SELECT)) { - BM_Select_Edge(bm, e, TRUE); + for (v = BM_iter_new(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BM_iter_step(&verts)) + BM_elem_flag_clear(v, 0); + for (e = BM_iter_new(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BM_iter_step(&edges)) { + if (BM_elem_flag_test(&(e->head), BM_ELEM_SELECT)) { + BM_edge_select(bm, e, TRUE); } } - BM_SelectMode_Flush(bm); + BM_mesh_select_mode_flush(bm); } else if (bm->selectmode & SCE_SELECT_FACE) { - for (e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)) - BM_ClearHFlag(e, 0); - for (f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces)) { - if (BM_TestHFlag(&(f->head), BM_ELEM_SELECT)) { - BM_Select_Face(bm, f, TRUE); + for (e = BM_iter_new(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BM_iter_step(&edges)) + BM_elem_flag_clear(e, 0); + for (f = BM_iter_new(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BM_iter_step(&faces)) { + if (BM_elem_flag_test(&(f->head), BM_ELEM_SELECT)) { + BM_face_select(bm, f, TRUE); } } - BM_SelectMode_Flush(bm); + BM_mesh_select_mode_flush(bm); } } -int BM_CountFlag(struct BMesh *bm, const char htype, const char hflag, int respecthide) +int BM_mesh_count_flag(struct BMesh *bm, const char htype, const char hflag, int respecthide) { BMHeader *head; BMIter iter; int tot = 0; if (htype & BM_VERT) { - for (head = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL); head; head = BMIter_Step(&iter)) { - if (respecthide && BM_TestHFlag(head, BM_ELEM_HIDDEN)) continue; - if (BM_TestHFlag(head, hflag)) tot++; + for (head = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL); head; head = BM_iter_step(&iter)) { + if (respecthide && BM_elem_flag_test(head, BM_ELEM_HIDDEN)) continue; + if (BM_elem_flag_test(head, hflag)) tot++; } } if (htype & BM_EDGE) { - for (head = BMIter_New(&iter, bm, BM_EDGES_OF_MESH, NULL); head; head = BMIter_Step(&iter)) { - if (respecthide && BM_TestHFlag(head, BM_ELEM_HIDDEN)) continue; - if (BM_TestHFlag(head, hflag)) tot++; + for (head = BM_iter_new(&iter, bm, BM_EDGES_OF_MESH, NULL); head; head = BM_iter_step(&iter)) { + if (respecthide && BM_elem_flag_test(head, BM_ELEM_HIDDEN)) continue; + if (BM_elem_flag_test(head, hflag)) tot++; } } if (htype & BM_FACE) { - for (head = BMIter_New(&iter, bm, BM_FACES_OF_MESH, NULL); head; head = BMIter_Step(&iter)) { - if (respecthide && BM_TestHFlag(head, BM_ELEM_HIDDEN)) continue; - if (BM_TestHFlag(head, hflag)) tot++; + for (head = BM_iter_new(&iter, bm, BM_FACES_OF_MESH, NULL); head; head = BM_iter_step(&iter)) { + if (respecthide && BM_elem_flag_test(head, BM_ELEM_HIDDEN)) continue; + if (BM_elem_flag_test(head, hflag)) tot++; } } @@ -475,30 +475,30 @@ int BM_CountFlag(struct BMesh *bm, const char htype, const char hflag, int respe } /* note: by design, this will not touch the editselection history stuff */ -void BM_Select(struct BMesh *bm, void *element, int select) +void BM_elem_select_set(struct BMesh *bm, void *element, int select) { BMHeader *head = element; - if (head->htype == BM_VERT) BM_Select_Vert(bm, (BMVert *)element, select); - else if (head->htype == BM_EDGE) BM_Select_Edge(bm, (BMEdge *)element, select); - else if (head->htype == BM_FACE) BM_Select_Face(bm, (BMFace *)element, select); + if (head->htype == BM_VERT) BM_vert_select(bm, (BMVert *)element, select); + else if (head->htype == BM_EDGE) BM_edge_select(bm, (BMEdge *)element, select); + else if (head->htype == BM_FACE) BM_face_select(bm, (BMFace *)element, select); } -int BM_Selected(BMesh *UNUSED(bm), const void *element) +int BM_elem_select_test(BMesh *UNUSED(bm), const void *element) { const BMHeader *head = element; - int selected = BM_TestHFlag(head, BM_ELEM_SELECT); - BLI_assert(!selected || !BM_TestHFlag(head, BM_ELEM_HIDDEN)); + int selected = BM_elem_flag_test(head, BM_ELEM_SELECT); + BLI_assert(!selected || !BM_elem_flag_test(head, BM_ELEM_HIDDEN)); return selected; } /* this replaces the active flag used in uv/face mode */ -void BM_set_actFace(BMesh *bm, BMFace *efa) +void BM_active_face_set(BMesh *bm, BMFace *efa) { bm->act_face = efa; } -BMFace *BM_get_actFace(BMesh *bm, int sloppy) +BMFace *BM_active_face_get(BMesh *bm, int sloppy) { if (bm->act_face) { return bm->act_face; @@ -514,7 +514,7 @@ BMFace *BM_get_actFace(BMesh *bm, int sloppy) if (ese->htype == BM_FACE) { f = (BMFace *)ese->data; - if (BM_TestHFlag(f, BM_ELEM_HIDDEN)) { + if (BM_elem_flag_test(f, BM_ELEM_HIDDEN)) { f = NULL; } else { @@ -525,7 +525,7 @@ BMFace *BM_get_actFace(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) { - if (BM_TestHFlag(f, BM_ELEM_SELECT)) { + if (BM_elem_flag_test(f, BM_ELEM_SELECT)) { break; } } @@ -556,7 +556,7 @@ void BM_editselection_center(BMesh *bm, float r_center[3], BMEditSelection *ese) } else if (ese->htype == BM_FACE) { BMFace *efa = ese->data; - BM_Compute_Face_CenterBounds(bm, efa, r_center); + BM_face_center_bounds_calc(bm, efa, r_center); } } @@ -651,7 +651,7 @@ void BM_editselection_plane(BMesh *bm, float r_plane[3], BMEditSelection *ese) else { BMVert *verts[4] = {NULL}; - BMIter_AsArray(bm, BM_VERTS_OF_FACE, efa, (void **)verts, 4); + BM_iter_as_array(bm, BM_VERTS_OF_FACE, efa, (void **)verts, 4); if (efa->len == 4) { float vecA[3], vecB[3]; @@ -690,7 +690,7 @@ void BM_editselection_plane(BMesh *bm, float r_plane[3], BMEditSelection *ese) normalize_v3(r_plane); } -static int BM_check_selection(BMesh *bm, void *data) +int BM_select_history_check(BMesh *bm, void *data) { BMEditSelection *ese; @@ -703,7 +703,7 @@ static int BM_check_selection(BMesh *bm, void *data) return FALSE; } -void BM_remove_selection(BMesh *bm, void *data) +void BM_select_history_remove(BMesh *bm, void *data) { BMEditSelection *ese; for (ese = bm->selected.first; ese; ese = ese->next) { @@ -714,16 +714,16 @@ void BM_remove_selection(BMesh *bm, void *data) } } -void BM_clear_selection_history(BMesh *bm) +void BM_select_history_clear(BMesh *bm) { BLI_freelistN(&bm->selected); bm->selected.first = bm->selected.last = NULL; } -void BM_store_selection(BMesh *bm, void *data) +void BM_select_history_store(BMesh *bm, void *data) { BMEditSelection *ese; - if (!BM_check_selection(bm, data)) { + if (!BM_select_history_check(bm, data)) { ese = (BMEditSelection *) MEM_callocN(sizeof(BMEditSelection), "BMEdit Selection"); ese->htype = ((BMHeader *)data)->htype; ese->data = data; @@ -731,7 +731,7 @@ void BM_store_selection(BMesh *bm, void *data) } } -void BM_validate_selections(BMesh *bm) +void BM_select_history_validate(BMesh *bm) { BMEditSelection *ese, *nextese; @@ -739,7 +739,7 @@ void BM_validate_selections(BMesh *bm) while (ese) { nextese = ese->next; - if (!BM_TestHFlag(ese->data, BM_ELEM_SELECT)) { + if (!BM_elem_flag_test(ese->data, BM_ELEM_SELECT)) { BLI_freelinkN(&(bm->selected), ese); } ese = nextese; @@ -756,14 +756,14 @@ void BM_clear_flag_all(BMesh *bm, const char hflag) int i; if (hflag & BM_ELEM_SELECT) { - BM_clear_selection_history(bm); + BM_select_history_clear(bm); } for (i = 0; i < 3; i++) { - ele = BMIter_New(&iter, bm, iter_types[i], NULL); - for ( ; ele; ele = BMIter_Step(&iter)) { - if (hflag & BM_ELEM_SELECT) BM_Select(bm, ele, FALSE); - BM_ClearHFlag(ele, hflag); + ele = BM_iter_new(&iter, bm, iter_types[i], NULL); + for ( ; ele; ele = BM_iter_step(&iter)) { + if (hflag & BM_ELEM_SELECT) BM_elem_select_set(bm, ele, FALSE); + BM_elem_flag_clear(ele, hflag); } } } @@ -771,7 +771,7 @@ void BM_clear_flag_all(BMesh *bm, const char hflag) /***************** Mesh Hiding stuff *********** */ -#define SETHIDE(ele) hide ? BM_SetHFlag(ele, BM_ELEM_HIDDEN) : BM_ClearHFlag(ele, BM_ELEM_HIDDEN); +#define SETHIDE(ele) hide ? BM_elem_flag_set(ele, BM_ELEM_HIDDEN) : BM_elem_flag_clear(ele, BM_ELEM_HIDDEN); static void vert_flush_hide(BMesh *bm, BMVert *v) { @@ -780,7 +780,7 @@ static void vert_flush_hide(BMesh *bm, BMVert *v) int hide = 1; BM_ITER(e, &iter, bm, BM_EDGES_OF_VERT, v) { - hide = hide && BM_TestHFlag(e, BM_ELEM_HIDDEN); + hide = hide && BM_elem_flag_test(e, BM_ELEM_HIDDEN); } SETHIDE(v); @@ -793,13 +793,13 @@ static void edge_flush_hide(BMesh *bm, BMEdge *e) int hide = 1; BM_ITER(f, &iter, bm, BM_FACES_OF_EDGE, e) { - hide = hide && BM_TestHFlag(f, BM_ELEM_HIDDEN); + hide = hide && BM_elem_flag_test(f, BM_ELEM_HIDDEN); } SETHIDE(e); } -void BM_Hide_Vert(BMesh *bm, BMVert *v, int hide) +void BM_vert_hide_set(BMesh *bm, BMVert *v, int hide) { /* vert hiding: vert + surrounding edges and faces */ BMIter iter, fiter; @@ -817,7 +817,7 @@ void BM_Hide_Vert(BMesh *bm, BMVert *v, int hide) } } -void BM_Hide_Edge(BMesh *bm, BMEdge *e, int hide) +void BM_edge_hide_set(BMesh *bm, BMEdge *e, int hide) { BMIter iter; BMFace *f; @@ -835,7 +835,7 @@ void BM_Hide_Edge(BMesh *bm, BMEdge *e, int hide) vert_flush_hide(bm, e->v2); } -void BM_Hide_Face(BMesh *bm, BMFace *f, int hide) +void BM_face_hide_set(BMesh *bm, BMFace *f, int hide) { BMIter iter; BMLoop *l; @@ -851,25 +851,25 @@ void BM_Hide_Face(BMesh *bm, BMFace *f, int hide) } } -void BM_Hide(BMesh *bm, void *element, int hide) +void BM_elem_hide_set(BMesh *bm, void *element, int hide) { BMHeader *h = element; /* Follow convention of always deselecting before * hiding an element */ if (hide) { - BM_Select(bm, element, FALSE); + BM_elem_select_set(bm, element, FALSE); } switch (h->htype) { case BM_VERT: - BM_Hide_Vert(bm, element, hide); + BM_vert_hide_set(bm, element, hide); break; case BM_EDGE: - BM_Hide_Edge(bm, element, hide); + BM_edge_hide_set(bm, element, hide); break; case BM_FACE: - BM_Hide_Face(bm, element, hide); + BM_face_hide_set(bm, element, hide); break; } } diff --git a/source/blender/bmesh/intern/bmesh_mesh.c b/source/blender/bmesh/intern/bmesh_mesh.c index 9a4761b2330..f4c3a874d00 100644 --- a/source/blender/bmesh/intern/bmesh_mesh.c +++ b/source/blender/bmesh/intern/bmesh_mesh.c @@ -67,7 +67,7 @@ void bmesh_error(void) * */ -BMesh *BM_Make_Mesh(struct Object *ob, int allocsize[4]) +BMesh *BM_mesh_create(struct Object *ob, int allocsize[4]) { /* allocate the structure */ BMesh *bm = MEM_callocN(sizeof(BMesh), __func__); @@ -102,7 +102,7 @@ BMesh *BM_Make_Mesh(struct Object *ob, int allocsize[4]) * Frees a BMesh structure. */ -void BM_Free_Mesh_Data(BMesh *bm) +void BM_mesh_data_free(BMesh *bm) { BMVert *v; BMEdge *e; @@ -115,15 +115,15 @@ void BM_Free_Mesh_Data(BMesh *bm) BMIter faces; BMIter loops; - for (v = BMIter_New(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BMIter_Step(&verts)) { + for (v = BM_iter_new(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BM_iter_step(&verts)) { CustomData_bmesh_free_block(&(bm->vdata), &(v->head.data)); } - for (e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)) { + for (e = BM_iter_new(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BM_iter_step(&edges)) { CustomData_bmesh_free_block(&(bm->edata), &(e->head.data)); } - for (f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces)) { + for (f = BM_iter_new(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BM_iter_step(&faces)) { CustomData_bmesh_free_block(&(bm->pdata), &(f->head.data)); - for (l = BMIter_New(&loops, bm, BM_LOOPS_OF_FACE, f); l; l = BMIter_Step(&loops)) { + for (l = BM_iter_new(&loops, bm, BM_LOOPS_OF_FACE, f); l; l = BM_iter_step(&loops)) { CustomData_bmesh_free_block(&(bm->ldata), &(l->head.data)); } } @@ -158,10 +158,10 @@ void BM_Free_Mesh_Data(BMesh *bm) BLI_freelistN(&bm->selected); - BMO_ClearStack(bm); + BMO_error_clear(bm); } -void BM_Clear_Mesh(BMesh *bm) +void BM_mesh_clear(BMesh *bm) { /* allocate the structure */ int vsize, esize, lsize, fsize, lstsize; @@ -171,7 +171,7 @@ void BM_Clear_Mesh(BMesh *bm) Object *ob = bm->ob; /* free old mesh */ - BM_Free_Mesh_Data(bm); + BM_mesh_data_free(bm); memset(bm, 0, sizeof(BMesh)); /* re-initialize mesh */ @@ -202,9 +202,9 @@ void BM_Clear_Mesh(BMesh *bm) * Frees a BMesh structure. */ -void BM_Free_Mesh(BMesh *bm) +void BM_mesh_free(BMesh *bm) { - BM_Free_Mesh_Data(bm); + BM_mesh_data_free(bm); MEM_freeN(bm); } @@ -216,7 +216,7 @@ void BM_Free_Mesh(BMesh *bm) * */ -void BM_Compute_Normals(BMesh *bm) +void BM_mesh_normals_update(BMesh *bm) { BMVert *v; BMFace *f; @@ -233,7 +233,7 @@ void BM_Compute_Normals(BMesh *bm) /* first, find out the largest face in mesh */ BM_ITER(f, &faces, bm, BM_FACES_OF_MESH, NULL) { - if (BM_TestHFlag(f, BM_ELEM_HIDDEN)) + if (BM_elem_flag_test(f, BM_ELEM_HIDDEN)) continue; if (f->len > maxlength) maxlength = f->len; @@ -247,7 +247,7 @@ void BM_Compute_Normals(BMesh *bm) /* calculate all face normals */ BM_ITER(f, &faces, bm, BM_FACES_OF_MESH, NULL) { - if (BM_TestHFlag(f, BM_ELEM_HIDDEN)) + if (BM_elem_flag_test(f, BM_ELEM_HIDDEN)) continue; #if 0 /* UNUSED */ if (f->head.flag & BM_NONORMCALC) @@ -259,7 +259,7 @@ void BM_Compute_Normals(BMesh *bm) /* Zero out vertex normals */ BM_ITER(v, &verts, bm, BM_VERTS_OF_MESH, NULL) { - if (BM_TestHFlag(v, BM_ELEM_HIDDEN)) + if (BM_elem_flag_test(v, BM_ELEM_HIDDEN)) continue; zero_v3(v->no); @@ -271,7 +271,7 @@ void BM_Compute_Normals(BMesh *bm) 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_SetIndex(e, index); /* set_inline */ + BM_elem_index_set(e, index); /* set_inline */ if (e->l) { sub_v3_v3v3(edgevec[index], e->v2->co, e->v1->co); @@ -288,7 +288,7 @@ void BM_Compute_Normals(BMesh *bm) /* add weighted face normals to vertices */ BM_ITER(f, &faces, bm, BM_FACES_OF_MESH, NULL) { - if (BM_TestHFlag(f, BM_ELEM_HIDDEN)) + if (BM_elem_flag_test(f, BM_ELEM_HIDDEN)) continue; BM_ITER(l, &loops, bm, BM_LOOPS_OF_FACE, f) { @@ -298,8 +298,8 @@ void BM_Compute_Normals(BMesh *bm) /* calculate the dot product of the two edges that * meet at the loop's vertex */ - e1diff = edgevec[BM_GetIndex(l->prev->e)]; - e2diff = edgevec[BM_GetIndex(l->e)]; + e1diff = edgevec[BM_elem_index_get(l->prev->e)]; + e2diff = edgevec[BM_elem_index_get(l->e)]; dotprod = dot_v3v3(e1diff, e2diff); /* edge vectors are calculated from e->v1 to e->v2, so @@ -318,7 +318,7 @@ void BM_Compute_Normals(BMesh *bm) /* normalize the accumulated vertex normals */ BM_ITER(v, &verts, bm, BM_VERTS_OF_MESH, NULL) { - if (BM_TestHFlag(v, BM_ELEM_HIDDEN)) + if (BM_elem_flag_test(v, BM_ELEM_HIDDEN)) continue; if (normalize_v3(v->no) == 0.0f) { @@ -348,28 +348,28 @@ static void bmesh_rationalize_normals(BMesh *bm, int undo) if (undo) { BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) { - if (BM_TestHFlag(f, BM_ELEM_TAG)) { - BM_flip_normal(bm, f); + if (BM_elem_flag_test(f, BM_ELEM_TAG)) { + BM_face_normal_flip(bm, f); } - BM_ClearHFlag(f, BM_ELEM_TAG); + BM_elem_flag_clear(f, BM_ELEM_TAG); } return; } - BMO_InitOpf(bm, &bmop, "righthandfaces faces=%af doflip=%d", FALSE); + BMO_op_initf(bm, &bmop, "righthandfaces faces=%af doflip=%d", FALSE); BMO_push(bm, &bmop); bmesh_righthandfaces_exec(bm, &bmop); BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) { - if (BMO_TestFlag(bm, f, FACE_FLIP)) - BM_SetHFlag(f, BM_ELEM_TAG); - else BM_ClearHFlag(f, BM_ELEM_TAG); + if (BMO_elem_flag_test(bm, f, FACE_FLIP)) + BM_elem_flag_set(f, BM_ELEM_TAG); + else BM_elem_flag_clear(f, BM_ELEM_TAG); } BMO_pop(bm); - BMO_Finish_Op(bm, &bmop); + BMO_op_finish(bm, &bmop); } static void bmesh_set_mdisps_space(BMesh *bm, int from, int to) @@ -447,7 +447,7 @@ void bmesh_begin_edit(BMesh *bm, int flag) /* ensure correct normals, if possible */ bmesh_rationalize_normals(bm, 0); - BM_Compute_Normals(bm); + BM_mesh_normals_update(bm); } else if (flag & BMOP_RATIONALIZE_NORMALS) { bmesh_rationalize_normals(bm, 0); @@ -481,11 +481,11 @@ void bmesh_end_edit(BMesh *bm, int flag) bm->opflag = 0; /* compute normals, clear temp flags and flush selections */ - BM_Compute_Normals(bm); - BM_SelectMode_Flush(bm); + BM_mesh_normals_update(bm); + BM_mesh_select_mode_flush(bm); } -void BM_ElemIndex_Ensure(BMesh *bm, const char hflag) +void BM_mesh_elem_index_ensure(BMesh *bm, const char hflag) { BMIter iter; BMHeader *ele; @@ -498,7 +498,7 @@ void BM_ElemIndex_Ensure(BMesh *bm, const char hflag) if (bm->elem_index_dirty & BM_VERT) { int index = 0; BM_ITER(ele, &iter, bm, BM_VERTS_OF_MESH, NULL) { - BM_SetIndex(ele, index); /* set_ok */ + BM_elem_index_set(ele, index); /* set_ok */ index++; } bm->elem_index_dirty &= ~BM_VERT; @@ -513,7 +513,7 @@ void BM_ElemIndex_Ensure(BMesh *bm, const char hflag) if (bm->elem_index_dirty & BM_EDGE) { int index = 0; BM_ITER(ele, &iter, bm, BM_EDGES_OF_MESH, NULL) { - BM_SetIndex(ele, index); /* set_ok */ + BM_elem_index_set(ele, index); /* set_ok */ index++; } bm->elem_index_dirty &= ~BM_EDGE; @@ -528,7 +528,7 @@ void BM_ElemIndex_Ensure(BMesh *bm, const char hflag) if (bm->elem_index_dirty & BM_FACE) { int index = 0; BM_ITER(ele, &iter, bm, BM_FACES_OF_MESH, NULL) { - BM_SetIndex(ele, index); /* set_ok */ + BM_elem_index_set(ele, index); /* set_ok */ index++; } bm->elem_index_dirty &= ~BM_FACE; @@ -551,7 +551,7 @@ void BM_ElemIndex_Ensure(BMesh *bm, const char hflag) * */ -void BM_ElemIndex_Validate(BMesh *bm, const char *location, const char *func, const char *msg_a, const char *msg_b) +void BM_mesh_elem_index_validate(BMesh *bm, const char *location, const char *func, const char *msg_a, const char *msg_b) { const char iter_types[3] = {BM_VERTS_OF_MESH, BM_EDGES_OF_MESH, @@ -574,14 +574,14 @@ void BM_ElemIndex_Validate(BMesh *bm, const char *location, const char *func, co BM_ITER(ele, &iter, bm, iter_types[i], NULL) { if (!is_dirty) { - if (BM_GetIndex(ele) != index) { - err_val = BM_GetIndex(ele); + if (BM_elem_index_get(ele) != index) { + err_val = BM_elem_index_get(ele); err_idx = index; is_error = TRUE; } } - BM_SetIndex(ele, index); /* set_ok */ + BM_elem_index_set(ele, index); /* set_ok */ index++; } @@ -616,17 +616,17 @@ void BM_ElemIndex_Validate(BMesh *bm, const char *location, const char *func, co } -BMVert *BM_Vert_AtIndex(BMesh *bm, const int index) +BMVert *BM_vert_at_index(BMesh *bm, const int index) { return BLI_mempool_findelem(bm->vpool, index); } -BMEdge *BM_Edge_AtIndex(BMesh *bm, const int index) +BMEdge *BM_edge_at_index(BMesh *bm, const int index) { return BLI_mempool_findelem(bm->epool, index); } -BMFace *BM_Face_AtIndex(BMesh *bm, const int index) +BMFace *BM_face_at_index(BMesh *bm, const int index) { return BLI_mempool_findelem(bm->fpool, index); } diff --git a/source/blender/bmesh/intern/bmesh_mods.c b/source/blender/bmesh/intern/bmesh_mods.c index ae1252f8d58..22094e5d9fd 100644 --- a/source/blender/bmesh/intern/bmesh_mods.c +++ b/source/blender/bmesh/intern/bmesh_mods.c @@ -57,7 +57,7 @@ * */ #if 1 -int BM_Dissolve_Vert(BMesh *bm, BMVert *v) +int BM_vert_dissolve(BMesh *bm, BMVert *v) { BMIter iter; BMEdge *e; @@ -67,23 +67,23 @@ int BM_Dissolve_Vert(BMesh *bm, BMVert *v) return FALSE; } - e = BMIter_New(&iter, bm, BM_EDGES_OF_VERT, v); - for ( ; e; e = BMIter_Step(&iter)) { + e = BM_iter_new(&iter, bm, BM_EDGES_OF_VERT, v); + for ( ; e; e = BM_iter_step(&iter)) { len++; } if (len == 1) { if (v->e) - BM_Kill_Edge(bm, v->e); - BM_Kill_Vert(bm, v); + BM_edge_kill(bm, v->e); + BM_vert_kill(bm, v); return TRUE; } - if (BM_Nonmanifold_Vert(bm, v)) { - if (!v->e) BM_Kill_Vert(bm, v); + if (BM_vert_is_nonmanifold(bm, v)) { + if (!v->e) BM_vert_kill(bm, v); else if (!v->e->l) { - BM_Kill_Edge(bm, v->e); - BM_Kill_Vert(bm, v); + BM_edge_kill(bm, v->e); + BM_vert_kill(bm, v); } else { return FALSE; @@ -92,16 +92,16 @@ int BM_Dissolve_Vert(BMesh *bm, BMVert *v) return TRUE; } - return BM_Dissolve_Disk(bm, v); + return BM_disk_dissolve(bm, v); } -int BM_Dissolve_Disk(BMesh *bm, BMVert *v) +int BM_disk_dissolve(BMesh *bm, BMVert *v) { BMFace *f, *f2; BMEdge *e, *keepedge = NULL, *baseedge = NULL; int len = 0; - if (BM_Nonmanifold_Vert(bm, v)) { + if (BM_vert_is_nonmanifold(bm, v)) { return FALSE; } @@ -110,7 +110,7 @@ int BM_Dissolve_Disk(BMesh *bm, BMVert *v) e = v->e; do { e = bmesh_disk_nextedge(e, v); - if (!(BM_Edge_Share_Faces(e, v->e))) { + if (!(BM_edge_share_faces(e, v->e))) { keepedge = e; baseedge = v->e; break; @@ -126,17 +126,17 @@ int BM_Dissolve_Disk(BMesh *bm, BMVert *v) * increasing valence to four. this may be hackish. . */ BMLoop *loop = e->l; if (loop->v == v) loop = loop->next; - if (!BM_Split_Face(bm, loop->f, v, loop->v, NULL, NULL)) + if (!BM_face_split(bm, loop->f, v, loop->v, NULL, NULL)) return FALSE; - if (!BM_Dissolve_Disk(bm, v)) { + if (!BM_disk_dissolve(bm, v)) { return FALSE; } return TRUE; } else if (keepedge == NULL && len == 2) { /* collapse the verte */ - e = BM_Collapse_Vert_Faces(bm, v->e, v, 1.0, TRUE); + e = BM_vert_collapse_faces(bm, v->e, v, 1.0, TRUE); if (!e) { return FALSE; @@ -146,7 +146,7 @@ int BM_Dissolve_Disk(BMesh *bm, BMVert *v) f = e->l->f; f2 = e->l->radial_next->f; - if (f != f2 && !BM_Join_TwoFaces(bm, f, f2, e)) { + if (f != f2 && !BM_faces_join_pair(bm, f, f2, e)) { return FALSE; } @@ -163,7 +163,7 @@ int BM_Dissolve_Disk(BMesh *bm, BMVert *v) f = NULL; len = bmesh_radial_length(e->l); if (len == 2 && (e != baseedge) && (e != keepedge)) { - f = BM_Join_TwoFaces(bm, e->l->f, e->l->radial_next->f, e); + f = BM_faces_join_pair(bm, e->l->f, e->l->radial_next->f, e); /* return if couldn't join faces in manifold * conditions */ //!disabled for testing why bad things happen @@ -181,7 +181,7 @@ int BM_Dissolve_Disk(BMesh *bm, BMVert *v) } /* collapse the verte */ - e = BM_Collapse_Vert_Faces(bm, baseedge, v, 1.0, TRUE); + e = BM_vert_collapse_faces(bm, baseedge, v, 1.0, TRUE); if (!e) { return FALSE; @@ -193,7 +193,7 @@ int BM_Dissolve_Disk(BMesh *bm, BMVert *v) if (f != f2) { /* join two remaining face */ - if (!BM_Join_TwoFaces(bm, f, f2, e)) { + if (!BM_faces_join_pair(bm, f, f2, e)) { return FALSE; } } @@ -202,7 +202,7 @@ int BM_Dissolve_Disk(BMesh *bm, BMVert *v) return TRUE; } #else -void BM_Dissolve_Disk(BMesh *bm, BMVert *v) +void BM_disk_dissolve(BMesh *bm, BMVert *v) { BMFace *f; BMEdge *e; @@ -215,12 +215,12 @@ void BM_Dissolve_Disk(BMesh *bm, BMVert *v) done = 1; /* loop the edges looking for an edge to dissolv */ - for (e = BMIter_New(&iter, bm, BM_EDGES_OF_VERT, v); e; - e = BMIter_Step(&iter)) { + for (e = BM_iter_new(&iter, bm, BM_EDGES_OF_VERT, v); e; + e = BM_iter_step(&iter)) { f = NULL; len = bmesh_cycle_length(&(e->l->radial)); if (len == 2) { - f = BM_Join_TwoFaces(bm, e->l->f, ((BMLoop *)(e->l->radial_next))->f, e); + f = BM_faces_join_pair(bm, e->l->f, ((BMLoop *)(e->l->radial_next))->f, e); } if (f) { done = 0; @@ -228,17 +228,17 @@ void BM_Dissolve_Disk(BMesh *bm, BMVert *v) } }; } - BM_Collapse_Vert_Faces(bm, v->e, v, 1.0, TRUE); + BM_vert_collapse_faces(bm, v->e, v, 1.0, TRUE); } } #endif /** - * BM_Join_TwoFaces + * BM_faces_join_pair * * Joins two adjacenct faces togather. * - * Because this method calls to BM_Join_Faces to do its work, ff a pair + * Because this method calls to BM_faces_join to do its work, ff a pair * of faces share multiple edges, the pair of faces will be joined at * every edge (not just edge e). This part of the functionality might need * to be reconsidered. @@ -250,7 +250,7 @@ void BM_Dissolve_Disk(BMesh *bm, BMVert *v) * pointer to the combined face */ -BMFace *BM_Join_TwoFaces(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e) +BMFace *BM_faces_join_pair(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e) { BMLoop *l1, *l2; BMEdge *jed = NULL; @@ -286,7 +286,7 @@ BMFace *BM_Join_TwoFaces(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e) bmesh_loop_reverse(bm, f2); } - f1 = BM_Join_Faces(bm, faces, 2); + f1 = BM_faces_join(bm, faces, 2); return f1; } @@ -300,7 +300,7 @@ BMFace *BM_Join_TwoFaces(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e) * the two verts belong to for splitting (e.g. the subdivision operator). */ -BMEdge *BM_Connect_Verts(BMesh *bm, BMVert *v1, BMVert *v2, BMFace **nf) +BMEdge *BM_verts_connect(BMesh *bm, BMVert *v1, BMVert *v2, BMFace **nf) { BMIter iter, iter2; BMVert *v; @@ -308,10 +308,10 @@ BMEdge *BM_Connect_Verts(BMesh *bm, BMVert *v1, BMVert *v2, BMFace **nf) BMFace *face; /* be warned: this can do weird things in some ngon situation, see BM_LegalSplit */ - for (face = BMIter_New(&iter, bm, BM_FACES_OF_VERT, v1); face; face = BMIter_Step(&iter)) { - for (v = BMIter_New(&iter2, bm, BM_VERTS_OF_FACE, face); v; v = BMIter_Step(&iter2)) { + for (face = BM_iter_new(&iter, bm, BM_FACES_OF_VERT, v1); face; face = BM_iter_step(&iter)) { + for (v = BM_iter_new(&iter2, bm, BM_VERTS_OF_FACE, face); v; v = BM_iter_step(&iter2)) { if (v == v2) { - face = BM_Split_Face(bm, face, v1, v2, &nl, NULL); + face = BM_face_split(bm, face, v1, v2, &nl, NULL); if (nf) *nf = face; return nl->e; @@ -323,7 +323,7 @@ BMEdge *BM_Connect_Verts(BMesh *bm, BMVert *v1, BMVert *v2, BMFace **nf) } /** - * BM_Split_Face + * BM_face_split * * Splits a single face into two. * @@ -340,20 +340,20 @@ BMEdge *BM_Connect_Verts(BMesh *bm, BMVert *v1, BMVert *v2, BMFace **nf) * */ -BMFace *BM_Split_Face(BMesh *bm, BMFace *f, BMVert *v1, BMVert *v2, BMLoop **nl, BMEdge *UNUSED(example)) +BMFace *BM_face_split(BMesh *bm, BMFace *f, BMVert *v1, BMVert *v2, BMLoop **nl, BMEdge *UNUSED(example)) { const int has_mdisp = CustomData_has_layer(&bm->ldata, CD_MDISPS); BMFace *nf, *of; /* do we have a multires layer */ if (has_mdisp) { - of = BM_Copy_Face(bm, f, 0, 0); + of = BM_face_copy(bm, f, 0, 0); } nf = bmesh_sfme(bm, f, v1, v2, nl, NULL); if (nf) { - BM_Copy_Attributes(bm, bm, f, nf); + BM_elem_copy_attrs(bm, bm, f, nf); copy_v3_v3(nf->no, f->no); /* handle multires update */ @@ -371,10 +371,10 @@ BMFace *BM_Split_Face(BMesh *bm, BMFace *f, BMVert *v1, BMVert *v2, BMLoop **nl, BM_loop_interp_from_face(bm, l_iter, of, FALSE, TRUE); } while ((l_iter = l_iter->next) != l_first); - BM_Kill_Face(bm, of); + BM_face_kill(bm, of); - BM_multires_smooth_bounds(bm, f); - BM_multires_smooth_bounds(bm, nf); + BM_face_multires_bounds_smooth(bm, f); + BM_face_multires_bounds_smooth(bm, nf); } } @@ -382,7 +382,7 @@ BMFace *BM_Split_Face(BMesh *bm, BMFace *f, BMVert *v1, BMVert *v2, BMLoop **nl, } /** - * BM_Collapse_Vert_Faces + * BM_vert_collapse_faces * * Collapses a vertex that has only two manifold edges * onto a vertex it shares an edge with. Fac defines @@ -390,7 +390,7 @@ BMFace *BM_Split_Face(BMesh *bm, BMFace *f, BMVert *v1, BMVert *v2, BMLoop **nl, * * Note that this is not a general edge collapse function. * - * Note this function is very close to 'BM_Collapse_Vert_Edges', both collapse + * Note this function is very close to 'BM_vert_collapse_edges', both collapse * a vertex and return a new edge. Except this takes a factor and merges * custom data. * @@ -403,7 +403,7 @@ BMFace *BM_Split_Face(BMesh *bm, BMFace *f, BMVert *v1, BMVert *v2, BMLoop **nl, * @returns The New Edge */ -BMEdge *BM_Collapse_Vert_Faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac, const int join_faces) +BMEdge *BM_vert_collapse_faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac, const int join_faces) { BMEdge *ne = NULL; BMVert *tv = bmesh_edge_getothervert(ke, kv); @@ -441,10 +441,10 @@ BMEdge *BM_Collapse_Vert_Faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac, con } /* now interpolate the vertex data */ - BM_Data_Interp_From_Verts(bm, kv, tv, kv, fac); + BM_data_interp_from_verts(bm, kv, tv, kv, fac); e2 = bmesh_disk_nextedge(ke, kv); - tv2 = BM_OtherEdgeVert(e2, kv); + tv2 = BM_edge_other_vert(e2, kv); if (join_faces) { BMFace **faces = NULL, *f; @@ -455,10 +455,10 @@ BMEdge *BM_Collapse_Vert_Faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac, con } if (BLI_array_count(faces) >= 2) { - BMFace *f2 = BM_Join_Faces(bm, faces, BLI_array_count(faces)); + BMFace *f2 = BM_faces_join(bm, faces, BLI_array_count(faces)); if (f2) { BMLoop *nl = NULL; - if (BM_Split_Face(bm, f2, tv, tv2, &nl, NULL)) { + if (BM_face_split(bm, f2, tv, tv2, &nl, NULL)) { ne = nl->e; } } @@ -470,17 +470,17 @@ BMEdge *BM_Collapse_Vert_Faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac, con } /* single face or no faces */ - /* same as BM_Collapse_Vert_Edges() however we already + /* same as BM_vert_collapse_edges() however we already * have vars to perform this operation so dont call. */ bmesh_jekv(bm, ke, kv); - ne = BM_Edge_Exist(tv, tv2); + ne = BM_edge_exists(tv, tv2); return ne; } /** - * BM_Collapse_Vert_Edges + * BM_vert_collapse_edges * * Collapses a vertex onto another vertex it shares an edge with. * @@ -488,7 +488,7 @@ BMEdge *BM_Collapse_Vert_Faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac, con * The New Edge */ -BMEdge *BM_Collapse_Vert_Edges(BMesh *bm, BMEdge *ke, BMVert *kv) +BMEdge *BM_vert_collapse_edges(BMesh *bm, BMEdge *ke, BMVert *kv) { /* nice example implimentation but we want loops to have their customdata * accounted for */ @@ -503,12 +503,12 @@ BMEdge *BM_Collapse_Vert_Edges(BMesh *bm, BMEdge *ke, BMVert *kv) if (tv) { BMEdge *e2 = bmesh_disk_nextedge(ke, kv); if (e2) { - BMVert *tv2 = BM_OtherEdgeVert(e2, kv); + BMVert *tv2 = BM_edge_other_vert(e2, kv); if (tv2) { /* only action, other calls here only get the edge to return */ bmesh_jekv(bm, ke, kv); - ne = BM_Edge_Exist(tv, tv2); + ne = BM_edge_exists(tv, tv2); } } } @@ -517,7 +517,7 @@ BMEdge *BM_Collapse_Vert_Edges(BMesh *bm, BMEdge *ke, BMVert *kv) #else /* with these args faces are never joined, same as above * but account for loop customdata */ - return BM_Collapse_Vert_Faces(bm, ke, kv, 1.0f, FALSE); + return BM_vert_collapse_faces(bm, ke, kv, 1.0f, FALSE); #endif } @@ -534,7 +534,7 @@ BMEdge *BM_Collapse_Vert_Edges(BMesh *bm, BMEdge *ke, BMVert *kv) * the new vert */ -BMVert *BM_Split_Edge(BMesh *bm, BMVert *v, BMEdge *e, BMEdge **ne, float percent) +BMVert *BM_edge_split(BMesh *bm, BMVert *v, BMEdge *e, BMEdge **ne, float percent) { BMVert *nv, *v2; BMFace **oldfaces = NULL; @@ -561,7 +561,7 @@ BMVert *BM_Split_Edge(BMesh *bm, BMVert *v, BMEdge *e, BMEdge **ne, float percen BLI_smallhash_init(&hash); for (i = 0; i < BLI_array_count(oldfaces); i++) { - oldfaces[i] = BM_Copy_Face(bm, oldfaces[i], 1, 1); + oldfaces[i] = BM_face_copy(bm, oldfaces[i], 1, 1); BLI_smallhash_insert(&hash, (intptr_t)oldfaces[i], NULL); } } @@ -577,12 +577,12 @@ BMVert *BM_Split_Edge(BMesh *bm, BMVert *v, BMEdge *e, BMEdge **ne, float percen if (ne) { (*ne)->head.hflag = e->head.hflag; - BM_Copy_Attributes(bm, bm, e, *ne); + BM_elem_copy_attrs(bm, bm, e, *ne); } /* v->nv->v2 */ - BM_Data_Facevert_Edgeinterp(bm, v2, v, nv, e, percent); - BM_Data_Interp_From_Verts(bm, v, v2, nv, percent); + BM_data_interp_face_vert_edge(bm, v2, v, nv, e, percent); + BM_data_interp_from_verts(bm, v, v2, nv, percent); if (CustomData_has_layer(&bm->ldata, CD_MDISPS) && e->l && nv) { int i, j; @@ -615,7 +615,7 @@ BMVert *BM_Split_Edge(BMesh *bm, BMVert *v, BMEdge *e, BMEdge **ne, float percen /* destroy the old face */ for (i = 0; i < BLI_array_count(oldfaces); i++) { - BM_Kill_Face_Verts(bm, oldfaces[i]); + BM_face_verts_kill(bm, oldfaces[i]); } /* fix boundaries a bit, doesn't work too well quite ye */ @@ -631,7 +631,7 @@ BMVert *BM_Split_Edge(BMesh *bm, BMVert *v, BMEdge *e, BMEdge **ne, float percen } do { - BM_multires_smooth_bounds(bm, l->f); + BM_face_multires_bounds_smooth(bm, l->f); l = l->radial_next; } while (l != e1->l); } @@ -644,7 +644,7 @@ BMVert *BM_Split_Edge(BMesh *bm, BMVert *v, BMEdge *e, BMEdge **ne, float percen return nv; } -BMVert *BM_Split_Edge_Multi(BMesh *bm, BMEdge *e, int numcuts) +BMVert *BM_edge_split_n(BMesh *bm, BMEdge *e, int numcuts) { int i; float percent; @@ -652,12 +652,12 @@ BMVert *BM_Split_Edge_Multi(BMesh *bm, BMEdge *e, int numcuts) for (i = 0; i < numcuts; i++) { percent = 1.0f / (float)(numcuts + 1 - i); - nv = BM_Split_Edge(bm, e->v2, e, NULL, percent); + nv = BM_edge_split(bm, e->v2, e, NULL, percent); } return nv; } -int BM_Validate_Face(BMesh *bm, BMFace *face, FILE *err) +int BM_face_validate(BMesh *bm, BMFace *face, FILE *err) { BMIter iter; BLI_array_declare(verts); @@ -670,7 +670,7 @@ int BM_Validate_Face(BMesh *bm, BMFace *face, FILE *err) fflush(err); } - for (l = BMIter_New(&iter, bm, BM_LOOPS_OF_FACE, face); l; l = BMIter_Step(&iter)) { + for (l = BM_iter_new(&iter, bm, BM_LOOPS_OF_FACE, face); l; l = BM_iter_step(&iter)) { BLI_array_growone(verts); verts[BLI_array_count(verts) - 1] = l->v; @@ -715,7 +715,7 @@ int BM_Validate_Face(BMesh *bm, BMFace *face, FILE *err) * Returns NULL on error (e.g., if the edge isn't surrounded by exactly * two faces). */ -BMEdge *BM_Rotate_Edge(BMesh *bm, BMEdge *e, int ccw) +BMEdge *BM_edge_rotate(BMesh *bm, BMEdge *e, int ccw) { BMVert *v1, *v2; BMLoop *l, *l1, *l2, *nl; @@ -725,10 +725,10 @@ BMEdge *BM_Rotate_Edge(BMesh *bm, BMEdge *e, int ccw) v1 = e->v1; v2 = e->v2; - if (BM_Edge_FaceCount(e) != 2) + if (BM_edge_face_count(e) != 2) return NULL; - f = BM_Join_TwoFaces(bm, e->l->f, e->l->radial_next->f, e); + f = BM_faces_join_pair(bm, e->l->f, e->l->radial_next->f, e); if (f == NULL) return NULL; @@ -749,13 +749,13 @@ BMEdge *BM_Rotate_Edge(BMesh *bm, BMEdge *e, int ccw) l2 = l2->next; } - if (!BM_Split_Face(bm, f, l1->v, l2->v, &nl, NULL)) + if (!BM_face_split(bm, f, l1->v, l2->v, &nl, NULL)) return NULL; return nl->e; } -BMVert *BM_Rip_Vertex ( BMesh *bm, BMFace *sf, BMVert *sv) +BMVert *BM_vert_rip ( BMesh *bm, BMFace *sf, BMVert *sv) { return bmesh_urmv(bm, sf, sv); } diff --git a/source/blender/bmesh/intern/bmesh_newcore.c b/source/blender/bmesh/intern/bmesh_newcore.c index 5982a9eae48..e8a0e8f8698 100644 --- a/source/blender/bmesh/intern/bmesh_newcore.c +++ b/source/blender/bmesh/intern/bmesh_newcore.c @@ -45,19 +45,19 @@ #define DEBUG_MEMCHECK_INDEX_INVALIDATE(ele) \ { \ int undef_idx; \ - BM_SetIndex(ele, undef_idx); /* set_ok_invalid */ \ + BM_elem_index_set(ele, undef_idx); /* set_ok_invalid */ \ } \ #endif -BMVert *BM_Make_Vert(BMesh *bm, const float co[3], const struct BMVert *example) +BMVert *BM_vert_create(BMesh *bm, const float co[3], const struct BMVert *example) { BMVert *v = BLI_mempool_calloc(bm->vpool); #ifdef USE_DEBUG_INDEX_MEMCHECK DEBUG_MEMCHECK_INDEX_INVALIDATE(v) #else - BM_SetIndex(v, -1); /* set_ok_invalid */ + BM_elem_index_set(v, -1); /* set_ok_invalid */ #endif bm->elem_index_dirty |= BM_VERT; /* may add to middle of the pool */ @@ -66,7 +66,7 @@ BMVert *BM_Make_Vert(BMesh *bm, const float co[3], const struct BMVert *example) v->head.htype = BM_VERT; - /* 'v->no' is handled by BM_Copy_Attributes */ + /* 'v->no' is handled by BM_elem_copy_attrs */ if (co) copy_v3_v3(v->co, co); /* allocate flag */ @@ -75,7 +75,7 @@ BMVert *BM_Make_Vert(BMesh *bm, const float co[3], const struct BMVert *example) CustomData_bmesh_set_default(&bm->vdata, &v->head.data); if (example) { - BM_Copy_Attributes(bm, bm, (BMVert *)example, (BMVert *)v); + BM_elem_copy_attrs(bm, bm, (BMVert *)example, (BMVert *)v); } BM_CHECK_ELEMENT(bm, v); @@ -94,7 +94,7 @@ BMVert *BM_Make_Vert(BMesh *bm, const float co[3], const struct BMVert *example) * Returns - * BMEdge pointer */ -BMEdge *BM_Edge_Exist(BMVert *v1, BMVert *v2) +BMEdge *BM_edge_exists(BMVert *v1, BMVert *v2) { BMIter iter; BMEdge *e; @@ -107,11 +107,11 @@ BMEdge *BM_Edge_Exist(BMVert *v1, BMVert *v2) return NULL; } -BMEdge *BM_Make_Edge(BMesh *bm, BMVert *v1, BMVert *v2, const BMEdge *example, int nodouble) +BMEdge *BM_edge_create(BMesh *bm, BMVert *v1, BMVert *v2, const BMEdge *example, int nodouble) { BMEdge *e; - if (nodouble && (e = BM_Edge_Exist(v1, v2))) + if (nodouble && (e = BM_edge_exists(v1, v2))) return (BMEdge *)e; e = BLI_mempool_calloc(bm->epool); @@ -119,7 +119,7 @@ BMEdge *BM_Make_Edge(BMesh *bm, BMVert *v1, BMVert *v2, const BMEdge *example, i #ifdef USE_DEBUG_INDEX_MEMCHECK DEBUG_MEMCHECK_INDEX_INVALIDATE(e) #else - BM_SetIndex(e, -1); /* set_ok_invalid */ + BM_elem_index_set(e, -1); /* set_ok_invalid */ #endif bm->elem_index_dirty |= BM_EDGE; /* may add to middle of the pool */ @@ -141,7 +141,7 @@ BMEdge *BM_Make_Edge(BMesh *bm, BMVert *v1, BMVert *v2, const BMEdge *example, i bmesh_disk_append_edge(e, e->v2); if (example) - BM_Copy_Attributes(bm, bm, (BMEdge *)example, (BMEdge *)e); + BM_elem_copy_attrs(bm, bm, (BMEdge *)example, (BMEdge *)e); BM_CHECK_ELEMENT(bm, e); @@ -171,7 +171,7 @@ static BMLoop *bmesh_create_loop(BMesh *bm, BMVert *v, BMEdge *e, BMFace *f, con return l; } -static BMLoop *BM_Add_FaceBoundary(BMesh *bm, BMFace *f, BMVert *startv, BMEdge *starte) +static BMLoop *bm_face_boundry_add(BMesh *bm, BMFace *f, BMVert *startv, BMEdge *starte) { BMLoopList *lst = BLI_mempool_calloc(bm->looplistpool); BMLoop *l = bmesh_create_loop(bm, startv, starte, f, NULL); @@ -186,7 +186,7 @@ static BMLoop *BM_Add_FaceBoundary(BMesh *bm, BMFace *f, BMVert *startv, BMEdge return l; } -BMFace *BM_Copy_Face(BMesh *bm, BMFace *f, int copyedges, int copyverts) +BMFace *BM_face_copy(BMesh *bm, BMFace *f, int copyedges, int copyverts) { BMEdge **edges = NULL; BMVert **verts = NULL; @@ -201,7 +201,7 @@ BMFace *BM_Copy_Face(BMesh *bm, BMFace *f, int copyedges, int copyverts) l_iter = l_first = BM_FACE_FIRST_LOOP(f); do { if (copyverts) { - BMVert *v = BM_Make_Vert(bm, l_iter->v->co, l_iter->v); + BMVert *v = BM_vert_create(bm, l_iter->v->co, l_iter->v); BLI_array_append(verts, v); } else { @@ -225,7 +225,7 @@ BMFace *BM_Copy_Face(BMesh *bm, BMFace *f, int copyedges, int copyverts) v1 = verts[(i + 1) % f->len]; } - e = BM_Make_Edge(bm, v1, v2, l_iter->e, FALSE); + e = BM_edge_create(bm, v1, v2, l_iter->e, FALSE); BLI_array_append(edges, e); } else { @@ -235,21 +235,21 @@ BMFace *BM_Copy_Face(BMesh *bm, BMFace *f, int copyedges, int copyverts) i++; } while ((l_iter = l_iter->next) != l_first); - f2 = BM_Make_Face(bm, verts, edges, f->len, FALSE); + f2 = BM_face_create(bm, verts, edges, f->len, FALSE); - BM_Copy_Attributes(bm, bm, f, f2); + BM_elem_copy_attrs(bm, bm, f, f2); l_iter = l_first = BM_FACE_FIRST_LOOP(f); l2 = BM_FACE_FIRST_LOOP(f2); do { - BM_Copy_Attributes(bm, bm, l_iter, l2); + BM_elem_copy_attrs(bm, bm, l_iter, l2); l2 = l2->next; } while ((l_iter = l_iter->next) != l_first); return f2; } -BMFace *BM_Make_Face(BMesh *bm, BMVert **verts, BMEdge **edges, const int len, int nodouble) +BMFace *BM_face_create(BMesh *bm, BMVert **verts, BMEdge **edges, const int len, int nodouble) { BMFace *f = NULL; BMLoop *l, *startl, *lastl; @@ -262,7 +262,7 @@ BMFace *BM_Make_Face(BMesh *bm, BMVert **verts, BMEdge **edges, const int len, i if (nodouble) { /* Check if face already exists */ - overlap = BM_Face_Exists(bm, verts, len, &f); + overlap = BM_face_exists(bm, verts, len, &f); if (overlap) { return f; } @@ -276,7 +276,7 @@ BMFace *BM_Make_Face(BMesh *bm, BMVert **verts, BMEdge **edges, const int len, i #ifdef USE_DEBUG_INDEX_MEMCHECK DEBUG_MEMCHECK_INDEX_INVALIDATE(f) #else - BM_SetIndex(f, -1); /* set_ok_invalid */ + BM_elem_index_set(f, -1); /* set_ok_invalid */ #endif bm->elem_index_dirty |= BM_FACE; /* may add to middle of the pool */ @@ -285,7 +285,7 @@ BMFace *BM_Make_Face(BMesh *bm, BMVert **verts, BMEdge **edges, const int len, i f->head.htype = BM_FACE; - startl = lastl = BM_Add_FaceBoundary(bm, (BMFace *)f, verts[0], edges[0]); + startl = lastl = bm_face_boundry_add(bm, (BMFace *)f, verts[0], edges[0]); startl->v = (BMVert *) verts[0]; startl->e = (BMEdge *) edges[0]; @@ -359,7 +359,7 @@ int bmesh_check_element(BMesh *UNUSED(bm), void *element, const char htype) err |= 512; if (l->v->head.htype != BM_VERT) err |= 1024; - if (!BM_Vert_In_Edge(l->e, l->v)) { + if (!BM_vert_in_edge(l->e, l->v)) { fprintf(stderr, "%s: fatal bmesh error (vert not in edge)! (bmesh internal error)\n", __func__); err |= 2048; } @@ -408,7 +408,7 @@ int bmesh_check_element(BMesh *UNUSED(bm), void *element, const char htype) err |= (1 << 18); if (!l_iter->v) err |= (1 << 19); - if (!BM_Vert_In_Edge(l_iter->e, l_iter->v) || !BM_Vert_In_Edge(l_iter->e, l_iter->next->v)) { + if (!BM_vert_in_edge(l_iter->e, l_iter->v) || !BM_vert_in_edge(l_iter->e, l_iter->next->v)) { err |= (1 << 20); } @@ -440,7 +440,7 @@ static void bmesh_kill_only_vert(BMesh *bm, BMVert *v) bm->totvert--; bm->elem_index_dirty |= BM_VERT; - BM_remove_selection(bm, v); + BM_select_history_remove(bm, v); if (v->head.data) CustomData_bmesh_free_block(&bm->vdata, &v->head.data); @@ -453,7 +453,7 @@ static void bmesh_kill_only_edge(BMesh *bm, BMEdge *e) bm->totedge--; bm->elem_index_dirty |= BM_EDGE; - BM_remove_selection(bm, e); + BM_select_history_remove(bm, e); if (e->head.data) CustomData_bmesh_free_block(&bm->edata, &e->head.data); @@ -470,7 +470,7 @@ static void bmesh_kill_only_face(BMesh *bm, BMFace *f) bm->totface--; bm->elem_index_dirty |= BM_FACE; - BM_remove_selection(bm, f); + BM_select_history_remove(bm, f); if (f->head.data) CustomData_bmesh_free_block(&bm->pdata, &f->head.data); @@ -490,7 +490,7 @@ static void bmesh_kill_only_loop(BMesh *bm, BMLoop *l) BLI_mempool_free(bm->lpool, l); } -void BM_Kill_Face_Edges(BMesh *bm, BMFace *f) +void BM_face_edges_kill(BMesh *bm, BMFace *f) { BMEdge **edges = NULL; BLI_array_staticdeclare(edges, BM_NGON_STACK_SIZE); @@ -504,13 +504,13 @@ void BM_Kill_Face_Edges(BMesh *bm, BMFace *f) } while ((l_iter = l_iter->next) != l_first); for (i = 0; i < BLI_array_count(edges); i++) { - BM_Kill_Edge(bm, edges[i]); + BM_edge_kill(bm, edges[i]); } BLI_array_free(edges); } -void BM_Kill_Face_Verts(BMesh *bm, BMFace *f) +void BM_face_verts_kill(BMesh *bm, BMFace *f) { BMVert **verts = NULL; BLI_array_staticdeclare(verts, BM_NGON_STACK_SIZE); @@ -524,13 +524,13 @@ void BM_Kill_Face_Verts(BMesh *bm, BMFace *f) } while ((l_iter = l_iter->next) != l_first); for (i = 0; i < BLI_array_count(verts); i++) { - BM_Kill_Vert(bm, verts[i]); + BM_vert_kill(bm, verts[i]); } BLI_array_free(verts); } -void BM_Kill_Face(BMesh *bm, BMFace *f) +void BM_face_kill(BMesh *bm, BMFace *f) { BMLoopList *ls, *lsnext; @@ -556,7 +556,7 @@ void BM_Kill_Face(BMesh *bm, BMFace *f) bmesh_kill_only_face(bm, f); } -void BM_Kill_Edge(BMesh *bm, BMEdge *e) +void BM_edge_kill(BMesh *bm, BMEdge *e) { bmesh_disk_remove_edge(e, e->v1); @@ -568,11 +568,11 @@ void BM_Kill_Edge(BMesh *bm, BMEdge *e) do { lnext = l->radial_next; if (lnext->f == l->f) { - BM_Kill_Face(bm, l->f); + BM_face_kill(bm, l->f); break; } - BM_Kill_Face(bm, l->f); + BM_face_kill(bm, l->f); if (l == lnext) break; @@ -583,7 +583,7 @@ void BM_Kill_Edge(BMesh *bm, BMEdge *e) bmesh_kill_only_edge(bm, e); } -void BM_Kill_Vert(BMesh *bm, BMVert *v) +void BM_vert_kill(BMesh *bm, BMVert *v) { if (v->e) { BMEdge *e, *nexte; @@ -591,7 +591,7 @@ void BM_Kill_Vert(BMesh *bm, BMVert *v) e = v->e; while (v->e) { nexte = bmesh_disk_nextedge(e, v); - BM_Kill_Edge(bm, e); + BM_edge_kill(bm, e); e = nexte; } } @@ -758,7 +758,7 @@ static int count_flagged_radial(BMesh *bm, BMLoop *l, int flag) return i; error: - BMO_RaiseError(bm, bm->currentop, BMERR_MESH_ERROR, NULL); + BMO_error_raise(bm, bm->currentop, BMERR_MESH_ERROR, NULL); return 0; } @@ -811,7 +811,7 @@ static int disk_is_flagged(BMVert *v, int flag) /* Midlevel Topology Manipulation Functions */ /* - * BM_Join_Faces + * BM_faces_join * * Joins a collected group of faces into one. Only restriction on * the input data is that the faces must be connected to each other. @@ -821,7 +821,7 @@ static int disk_is_flagged(BMVert *v, int flag) * * Returns a pointer to the combined face. */ -BMFace *BM_Join_Faces(BMesh *bm, BMFace **faces, int totface) +BMFace *BM_faces_join(BMesh *bm, BMFace **faces, int totface) { BMFace *f, *newf; BMLoopList *lst; @@ -863,7 +863,7 @@ BMFace *BM_Join_Faces(BMesh *bm, BMFace **faces, int totface) if (!v1) { v1 = l_iter->v; - v2 = BM_OtherEdgeVert(l_iter->e, l_iter->v); + v2 = BM_edge_other_vert(l_iter->e, l_iter->v); } tote++; } @@ -900,9 +900,9 @@ BMFace *BM_Join_Faces(BMesh *bm, BMFace **faces, int totface) } /* create region fac */ - newf = BM_Make_Ngon(bm, v1, v2, edges, tote, FALSE); - if (!newf || BMO_HasError(bm)) { - if (!BMO_HasError(bm)) + newf = BM_face_create_ngon(bm, v1, v2, edges, tote, FALSE); + if (!newf || BMO_error_occurred(bm)) { + if (!BMO_error_occurred(bm)) err = "Invalid boundary region to join faces"; goto error; } @@ -924,11 +924,11 @@ BMFace *BM_Join_Faces(BMesh *bm, BMFace **faces, int totface) l2 = l2->next; } - BM_Copy_Attributes(bm, bm, l2, l_iter); + BM_elem_copy_attrs(bm, bm, l2, l_iter); } } while ((l_iter = l_iter->next) != l_first); - BM_Copy_Attributes(bm, bm, faces[0], newf); + BM_elem_copy_attrs(bm, bm, faces[0], newf); /* add hole */ BLI_movelisttolist(&newf->loops, &holes); @@ -957,11 +957,11 @@ BMFace *BM_Join_Faces(BMesh *bm, BMFace **faces, int totface) /* delete old geometr */ for (i = 0; i < BLI_array_count(deledges); i++) { - BM_Kill_Edge(bm, deledges[i]); + BM_edge_kill(bm, deledges[i]); } for (i = 0; i < BLI_array_count(delverts); i++) { - BM_Kill_Vert(bm, delverts[i]); + BM_vert_kill(bm, delverts[i]); } BLI_array_free(edges); @@ -977,7 +977,7 @@ error: BLI_array_free(delverts); if (err) { - BMO_RaiseError(bm, bm->currentop, BMERR_DISSOLVEFACES_FAILED, err); + BMO_error_raise(bm, bm->currentop, BMERR_DISSOLVEFACES_FAILED, err); } return NULL; } @@ -996,7 +996,7 @@ static BMFace *bmesh_addpolylist(BMesh *bm, BMFace *UNUSED(example)) #ifdef USE_DEBUG_INDEX_MEMCHECK DEBUG_MEMCHECK_INDEX_INVALIDATE(f) #else - BM_SetIndex(f, -1); /* set_ok_invalid */ + BM_elem_index_set(f, -1); /* set_ok_invalid */ #endif bm->elem_index_dirty |= BM_FACE; /* may add to middle of the pool */ @@ -1073,7 +1073,7 @@ BMFace *bmesh_sfme(BMesh *bm, BMFace *f, BMVert *v1, BMVert *v2, } /* allocate new edge between v1 and v2 */ - e = BM_Make_Edge(bm, v1, v2, NULL, FALSE); + e = BM_edge_create(bm, v1, v2, NULL, FALSE); f2 = bmesh_addpolylist(bm, f); f1loop = bmesh_create_loop(bm, v2, e, f, v2loop); @@ -1177,8 +1177,8 @@ BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **re) /* count valence of v2 */ valence2 = bmesh_disk_count(tv); - nv = BM_Make_Vert(bm, tv->co, tv); - ne = BM_Make_Edge(bm, nv, tv, e, FALSE); + nv = BM_vert_create(bm, tv->co, tv); + ne = BM_edge_create(bm, nv, tv, e, FALSE); bmesh_disk_remove_edge(ne, tv); bmesh_disk_remove_edge(ne, nv); @@ -1549,28 +1549,28 @@ BMFace *bmesh_jfke(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e) } /* validate only one shared edg */ - shared = BM_Face_Share_Edges(f1, f2); + shared = BM_face_share_edges(f1, f2); if (shared > 1) { return NULL; } /* validate no internal join */ for (i = 0, l_iter = BM_FACE_FIRST_LOOP(f1); i < f1len; i++, l_iter = l_iter->next) { - BM_ClearHFlag(l_iter->v, BM_ELEM_TAG); + BM_elem_flag_clear(l_iter->v, BM_ELEM_TAG); } for (i = 0, l_iter = BM_FACE_FIRST_LOOP(f2); i < f2len; i++, l_iter = l_iter->next) { - BM_ClearHFlag(l_iter->v, BM_ELEM_TAG); + BM_elem_flag_clear(l_iter->v, BM_ELEM_TAG); } for (i = 0, l_iter = BM_FACE_FIRST_LOOP(f1); i < f1len; i++, l_iter = l_iter->next) { if (l_iter != f1loop) { - BM_SetHFlag(l_iter->v, BM_ELEM_TAG); + BM_elem_flag_set(l_iter->v, BM_ELEM_TAG); } } for (i = 0, l_iter = BM_FACE_FIRST_LOOP(f2); i < f2len; i++, l_iter = l_iter->next) { if (l_iter != f2loop) { /* as soon as a duplicate is found, bail out */ - if (BM_TestHFlag(l_iter->v, BM_ELEM_TAG)) { + if (BM_elem_flag_test(l_iter->v, BM_ELEM_TAG)) { return NULL; } } @@ -1656,7 +1656,7 @@ static int bmesh_splicevert(BMesh *bm, BMVert *v, BMVert *vtarget) BM_CHECK_ELEMENT(bm, vtarget); /* v is unused now, and can be killed */ - BM_Kill_Vert(bm, v); + BM_vert_kill(bm, v); return TRUE; } @@ -1710,7 +1710,7 @@ static int bmesh_cutvert(BMesh *bm, BMVert *v, BMVert ***vout, int *len) verts = MEM_callocN(sizeof(BMVert *) * maxindex, "bmesh_cutvert"); verts[0] = v; for (i = 1; i < maxindex; i++) { - verts[i] = BM_Make_Vert(bm, v->co, v); + verts[i] = BM_vert_create(bm, v->co, v); } /* Replace v with the new verts in each group */ @@ -1774,15 +1774,15 @@ static int UNUSED_FUNCTION(bmesh_spliceedge)(BMesh *bm, BMEdge *e, BMEdge *etarg { BMLoop *l; - if (!BM_Vert_In_Edge(e, etarget->v1) || !BM_Vert_In_Edge(e, etarget->v2)) { + if (!BM_vert_in_edge(e, etarget->v1) || !BM_vert_in_edge(e, etarget->v2)) { /* not the same vertices can't splice */ return FALSE; } while (e->l) { l = e->l; - BLI_assert(BM_Vert_In_Edge(etarget, l->v)); - BLI_assert(BM_Vert_In_Edge(etarget, l->next->v)); + BLI_assert(BM_vert_in_edge(etarget, l->v)); + BLI_assert(BM_vert_in_edge(etarget, l->next->v)); bmesh_radial_remove_loop(l, e); bmesh_radial_append(etarget, l); } @@ -1792,7 +1792,7 @@ static int UNUSED_FUNCTION(bmesh_spliceedge)(BMesh *bm, BMEdge *e, BMEdge *etarg BM_CHECK_ELEMENT(bm, e); BM_CHECK_ELEMENT(bm, etarget); - BM_Kill_Edge(bm, e); + BM_edge_kill(bm, e); return TRUE; } @@ -1824,7 +1824,7 @@ static int bmesh_cutedge(BMesh *bm, BMEdge *e, BMLoop *cutl) e->l = cutl->radial_next; } - ne = BM_Make_Edge(bm, e->v1, e->v2, e, FALSE); + ne = BM_edge_create(bm, e->v1, e->v2, e, FALSE); bmesh_radial_remove_loop(cutl, e); bmesh_radial_append(ne, cutl); cutl->e = ne; diff --git a/source/blender/bmesh/intern/bmesh_operators.c b/source/blender/bmesh/intern/bmesh_operators.c index 8c761cff644..6ba4e660263 100644 --- a/source/blender/bmesh/intern/bmesh_operators.c +++ b/source/blender/bmesh/intern/bmesh_operators.c @@ -78,12 +78,12 @@ const int BMOP_OPSLOT_TYPEINFO[] = { /* Dummy slot so there is something to return when slot name lookup fails */ static BMOpSlot BMOpEmptySlot = {0}; -void BMO_Set_OpFlag(BMesh *UNUSED(bm), BMOperator *op, const int op_flag) +void BMO_op_flag_set(BMesh *UNUSED(bm), BMOperator *op, const int op_flag) { op->flag |= op_flag; } -void BMO_Clear_OpFlag(BMesh *UNUSED(bm), BMOperator *op, const int op_flag) +void BMO_op_flag_clear(BMesh *UNUSED(bm), BMOperator *op, const int op_flag) { op->flag &= ~op_flag; } @@ -128,7 +128,7 @@ void BMO_pop(BMesh *bm) * Initializes an operator structure * to a certain type */ -void BMO_Init_Op(BMesh *bm, BMOperator *op, const char *opname) +void BMO_op_init(BMesh *bm, BMOperator *op, const char *opname) { int i, opcode = bmesh_opname_to_opcode(opname); @@ -169,7 +169,7 @@ void BMO_Init_Op(BMesh *bm, BMOperator *op, const char *opname) * loop. Can be called from other operators * exec callbacks as well. */ -void BMO_Exec_Op(BMesh *bm, BMOperator *op) +void BMO_op_exec(BMesh *bm, BMOperator *op) { BMO_push(bm, op); @@ -190,7 +190,7 @@ void BMO_Exec_Op(BMesh *bm, BMOperator *op) * Does housekeeping chores related to finishing * up an operator. */ -void BMO_Finish_Op(BMesh *bm, BMOperator *op) +void BMO_op_finish(BMesh *bm, BMOperator *op) { BMOpSlot *slot; int i; @@ -218,7 +218,7 @@ void BMO_Finish_Op(BMesh *bm, BMOperator *op) * Returns 1 if the named slot exists on the given operator, * otherwise returns 0. */ -int BMO_HasSlot(BMOperator *op, const char *slotname) +int BMO_slot_exists(BMOperator *op, const char *slotname) { int slotcode = bmesh_name_to_slotcode(opdefines[op->type], slotname); return (slotcode >= 0); @@ -230,7 +230,7 @@ int BMO_HasSlot(BMOperator *op, const char *slotname) * Returns a pointer to the slot of * type 'slotcode' */ -BMOpSlot *BMO_GetSlot(BMOperator *op, const char *slotname) +BMOpSlot *BMO_slot_get(BMOperator *op, const char *slotname) { int slotcode = bmesh_name_to_slotcode_check(opdefines[op->type], slotname); @@ -246,10 +246,10 @@ BMOpSlot *BMO_GetSlot(BMOperator *op, const char *slotname) * * Copies data from one slot to another */ -void BMO_CopySlot(BMOperator *source_op, BMOperator *dest_op, const char *src, const char *dst) +void BMO_slot_copy(BMOperator *source_op, BMOperator *dest_op, const char *src, const char *dst) { - BMOpSlot *source_slot = BMO_GetSlot(source_op, src); - BMOpSlot *dest_slot = BMO_GetSlot(dest_op, dst); + BMOpSlot *source_slot = BMO_slot_get(source_op, src); + BMOpSlot *dest_slot = BMO_slot_get(dest_op, dst); if (source_slot == dest_slot) return; @@ -306,18 +306,18 @@ void BMO_CopySlot(BMOperator *source_op, BMOperator *dest_op, const char *src, c * */ -void BMO_Set_Float(BMOperator *op, const char *slotname, float f) +void BMO_slot_float_set(BMOperator *op, const char *slotname, float f) { - BMOpSlot *slot = BMO_GetSlot(op, slotname); + BMOpSlot *slot = BMO_slot_get(op, slotname); if (!(slot->slottype == BMOP_OPSLOT_FLT)) return; slot->data.f = f; } -void BMO_Set_Int(BMOperator *op, const char *slotname, int i) +void BMO_slot_int_set(BMOperator *op, const char *slotname, int i) { - BMOpSlot *slot = BMO_GetSlot(op, slotname); + BMOpSlot *slot = BMO_slot_get(op, slotname); if (!(slot->slottype == BMOP_OPSLOT_INT)) return; @@ -325,9 +325,9 @@ void BMO_Set_Int(BMOperator *op, const char *slotname, int i) } /* only supports square mats */ -void BMO_Set_Mat(struct BMOperator *op, const char *slotname, float *mat, int size) +void BMO_slot_mat_set(struct BMOperator *op, const char *slotname, float *mat, int size) { - BMOpSlot *slot = BMO_GetSlot(op, slotname); + BMOpSlot *slot = BMO_slot_get(op, slotname); if (!(slot->slottype == BMOP_OPSLOT_MAT)) return; @@ -348,36 +348,36 @@ void BMO_Set_Mat(struct BMOperator *op, const char *slotname, float *mat, int si } } -void BMO_Get_Mat4(struct BMOperator *op, const char *slotname, float mat[4][4]) +void BMO_slot_mat4_set(struct BMOperator *op, const char *slotname, float mat[4][4]) { - BMOpSlot *slot = BMO_GetSlot(op, slotname); + BMOpSlot *slot = BMO_slot_get(op, slotname); if (!(slot->slottype == BMOP_OPSLOT_MAT)) return; memcpy(mat, slot->data.p, sizeof(float) * 4 * 4); } -void BMO_Get_Mat3(struct BMOperator *op, const char *slotname, float mat[3][3]) +void BMO_slot_mat3_set(struct BMOperator *op, const char *slotname, float mat[3][3]) { - BMOpSlot *slot = BMO_GetSlot(op, slotname); + BMOpSlot *slot = BMO_slot_get(op, slotname); if (!(slot->slottype == BMOP_OPSLOT_MAT)) return; copy_m3_m4(mat, slot->data.p); } -void BMO_Set_Pnt(BMOperator *op, const char *slotname, void *p) +void BMO_slot_ptr_set(BMOperator *op, const char *slotname, void *p) { - BMOpSlot *slot = BMO_GetSlot(op, slotname); + BMOpSlot *slot = BMO_slot_get(op, slotname); if (!(slot->slottype == BMOP_OPSLOT_PNT)) return; slot->data.p = p; } -void BMO_Set_Vec(BMOperator *op, const char *slotname, const float vec[3]) +void BMO_slot_vec_set(BMOperator *op, const char *slotname, const float vec[3]) { - BMOpSlot *slot = BMO_GetSlot(op, slotname); + BMOpSlot *slot = BMO_slot_get(op, slotname); if (!(slot->slottype == BMOP_OPSLOT_VEC)) return; @@ -385,18 +385,18 @@ void BMO_Set_Vec(BMOperator *op, const char *slotname, const float vec[3]) } -float BMO_Get_Float(BMOperator *op, const char *slotname) +float BMO_slot_float_get(BMOperator *op, const char *slotname) { - BMOpSlot *slot = BMO_GetSlot(op, slotname); + BMOpSlot *slot = BMO_slot_get(op, slotname); if (!(slot->slottype == BMOP_OPSLOT_FLT)) return 0.0f; return slot->data.f; } -int BMO_Get_Int(BMOperator *op, const char *slotname) +int BMO_slot_int_get(BMOperator *op, const char *slotname) { - BMOpSlot *slot = BMO_GetSlot(op, slotname); + BMOpSlot *slot = BMO_slot_get(op, slotname); if (!(slot->slottype == BMOP_OPSLOT_INT)) return 0; @@ -404,18 +404,18 @@ int BMO_Get_Int(BMOperator *op, const char *slotname) } -void *BMO_Get_Pnt(BMOperator *op, const char *slotname) +void *BMO_slot_ptr_get(BMOperator *op, const char *slotname) { - BMOpSlot *slot = BMO_GetSlot(op, slotname); + BMOpSlot *slot = BMO_slot_get(op, slotname); if (!(slot->slottype == BMOP_OPSLOT_PNT)) return NULL; return slot->data.p; } -void BMO_Get_Vec(BMOperator *op, const char *slotname, float r_vec[3]) +void BMO_slot_vec_get(BMOperator *op, const char *slotname, float r_vec[3]) { - BMOpSlot *slot = BMO_GetSlot(op, slotname); + BMOpSlot *slot = BMO_slot_get(op, slotname); if (!(slot->slottype == BMOP_OPSLOT_VEC)) return; @@ -430,27 +430,27 @@ void BMO_Get_Vec(BMOperator *op, const char *slotname, float r_vec[3]) * */ -int BMO_CountFlag(BMesh *bm, const short oflag, const char htype) +int BMO_mesh_flag_count(BMesh *bm, const short oflag, const char htype) { BMIter elements; BMHeader *e; int count = 0; if (htype & BM_VERT) { - for (e = BMIter_New(&elements, bm, BM_VERTS_OF_MESH, bm); e; e = BMIter_Step(&elements)) { - if (BMO_TestFlag(bm, e, oflag)) + for (e = BM_iter_new(&elements, bm, BM_VERTS_OF_MESH, bm); e; e = BM_iter_step(&elements)) { + if (BMO_elem_flag_test(bm, e, oflag)) count++; } } if (htype & BM_EDGE) { - for (e = BMIter_New(&elements, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&elements)) { - if (BMO_TestFlag(bm, e, oflag)) + for (e = BM_iter_new(&elements, bm, BM_EDGES_OF_MESH, bm); e; e = BM_iter_step(&elements)) { + if (BMO_elem_flag_test(bm, e, oflag)) count++; } } if (htype & BM_FACE) { - for (e = BMIter_New(&elements, bm, BM_FACES_OF_MESH, bm); e; e = BMIter_Step(&elements)) { - if (BMO_TestFlag(bm, e, oflag)) + for (e = BM_iter_new(&elements, bm, BM_FACES_OF_MESH, bm); e; e = BM_iter_step(&elements)) { + if (BMO_elem_flag_test(bm, e, oflag)) count++; } } @@ -458,7 +458,7 @@ int BMO_CountFlag(BMesh *bm, const short oflag, const char htype) return count; } -void BMO_Clear_Flag_All(BMesh *bm, BMOperator *UNUSED(op), const char htype, const short oflag) +void BMO_mesh_flag_clear_all(BMesh *bm, BMOperator *UNUSED(op), const char htype, const short oflag) { const char iter_types[3] = {BM_VERTS_OF_MESH, BM_EDGES_OF_MESH, @@ -473,15 +473,15 @@ void BMO_Clear_Flag_All(BMesh *bm, BMOperator *UNUSED(op), const char htype, con for (i = 0; i < 3; i++) { if (htype & flag_types[i]) { BM_ITER(ele, &iter, bm, iter_types[i], NULL) { - BMO_ClearFlag(bm, ele, oflag); + BMO_elem_flag_clear(bm, ele, oflag); } } } } -int BMO_CountSlotBuf(struct BMesh *UNUSED(bm), struct BMOperator *op, const char *slotname) +int BMO_slot_buf_count(struct BMesh *UNUSED(bm), struct BMOperator *op, const char *slotname) { - BMOpSlot *slot = BMO_GetSlot(op, slotname); + BMOpSlot *slot = BMO_slot_get(op, slotname); /* check if its actually a buffer */ if (!(slot->slottype > BMOP_OPSLOT_VEC)) @@ -490,9 +490,9 @@ int BMO_CountSlotBuf(struct BMesh *UNUSED(bm), struct BMOperator *op, const char return slot->len; } -int BMO_CountSlotMap(BMesh *UNUSED(bm), BMOperator *op, const char *slotname) +int BMO_slot_map_count(BMesh *UNUSED(bm), BMOperator *op, const char *slotname) { - BMOpSlot *slot = BMO_GetSlot(op, slotname); + BMOpSlot *slot = BMO_slot_get(op, slotname); /* check if its actually a buffer */ if (!(slot->slottype == BMOP_OPSLOT_MAPPING)) @@ -536,11 +536,11 @@ void *BMO_Grow_Array(BMesh *bm, BMOperator *op, int slotcode, int totadd) } #endif -void BMO_Mapping_To_Flag(struct BMesh *bm, struct BMOperator *op, - const char *slotname, const short oflag) +void BMO_slot_map_to_flag(struct BMesh *bm, struct BMOperator *op, + const char *slotname, const short oflag) { GHashIterator it; - BMOpSlot *slot = BMO_GetSlot(op, slotname); + BMOpSlot *slot = BMO_slot_get(op, slotname); BMHeader *ele; /* sanity check */ @@ -549,13 +549,13 @@ void BMO_Mapping_To_Flag(struct BMesh *bm, struct BMOperator *op, BLI_ghashIterator_init(&it, slot->data.ghash); for ( ; (ele = BLI_ghashIterator_getKey(&it)); BLI_ghashIterator_step(&it)) { - BMO_SetFlag(bm, ele, oflag); + BMO_elem_flag_set(bm, ele, oflag); } } static void *alloc_slot_buffer(BMOperator *op, const char *slotname, int len) { - BMOpSlot *slot = BMO_GetSlot(op, slotname); + BMOpSlot *slot = BMO_slot_get(op, slotname); /* check if its actually a buffer */ if (!(slot->slottype > BMOP_OPSLOT_VEC)) @@ -574,11 +574,11 @@ static void *alloc_slot_buffer(BMOperator *op, const char *slotname, int len) * */ -static void BMO_All_To_Slot(BMesh *bm, BMOperator *op, const char *slotname, const char htype) +static void BMO_slot_from_all(BMesh *bm, BMOperator *op, const char *slotname, const char htype) { BMIter elements; BMHeader *e; - BMOpSlot *output = BMO_GetSlot(op, slotname); + BMOpSlot *output = BMO_slot_get(op, slotname); int totelement = 0, i = 0; if (htype & BM_VERT) totelement += bm->totvert; @@ -589,21 +589,21 @@ static void BMO_All_To_Slot(BMesh *bm, BMOperator *op, const char *slotname, con alloc_slot_buffer(op, slotname, totelement); if (htype & BM_VERT) { - for (e = BMIter_New(&elements, bm, BM_VERTS_OF_MESH, bm); e; e = BMIter_Step(&elements)) { + for (e = BM_iter_new(&elements, bm, BM_VERTS_OF_MESH, bm); e; e = BM_iter_step(&elements)) { ((BMHeader **)output->data.p)[i] = e; i++; } } if (htype & BM_EDGE) { - for (e = BMIter_New(&elements, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&elements)) { + for (e = BM_iter_new(&elements, bm, BM_EDGES_OF_MESH, bm); e; e = BM_iter_step(&elements)) { ((BMHeader **)output->data.p)[i] = e; i++; } } if (htype & BM_FACE) { - for (e = BMIter_New(&elements, bm, BM_FACES_OF_MESH, bm); e; e = BMIter_Step(&elements)) { + for (e = BM_iter_new(&elements, bm, BM_FACES_OF_MESH, bm); e; e = BM_iter_step(&elements)) { ((BMHeader **)output->data.p)[i] = e; i++; } @@ -618,22 +618,22 @@ static void BMO_All_To_Slot(BMesh *bm, BMOperator *op, const char *slotname, con * into a slot for an operator. */ -void BMO_HeaderFlag_To_Slot(BMesh *bm, BMOperator *op, const char *slotname, +void BMO_slot_from_hflag(BMesh *bm, BMOperator *op, const char *slotname, const char hflag, const char htype) { BMIter elements; BMHeader *e; - BMOpSlot *output = BMO_GetSlot(op, slotname); + BMOpSlot *output = BMO_slot_get(op, slotname); int totelement = 0, i = 0; - totelement = BM_CountFlag(bm, htype, hflag, 1); + totelement = BM_mesh_count_flag(bm, htype, hflag, 1); if (totelement) { alloc_slot_buffer(op, slotname, totelement); if (htype & BM_VERT) { - for (e = BMIter_New(&elements, bm, BM_VERTS_OF_MESH, bm); e; e = BMIter_Step(&elements)) { - if (!BM_TestHFlag(e, BM_ELEM_HIDDEN) && BM_TestHFlag(e, hflag)) { + for (e = BM_iter_new(&elements, bm, BM_VERTS_OF_MESH, bm); e; e = BM_iter_step(&elements)) { + if (!BM_elem_flag_test(e, BM_ELEM_HIDDEN) && BM_elem_flag_test(e, hflag)) { ((BMHeader **)output->data.p)[i] = e; i++; } @@ -641,8 +641,8 @@ void BMO_HeaderFlag_To_Slot(BMesh *bm, BMOperator *op, const char *slotname, } if (htype & BM_EDGE) { - for (e = BMIter_New(&elements, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&elements)) { - if (!BM_TestHFlag(e, BM_ELEM_HIDDEN) && BM_TestHFlag(e, hflag)) { + for (e = BM_iter_new(&elements, bm, BM_EDGES_OF_MESH, bm); e; e = BM_iter_step(&elements)) { + if (!BM_elem_flag_test(e, BM_ELEM_HIDDEN) && BM_elem_flag_test(e, hflag)) { ((BMHeader **)output->data.p)[i] = e; i++; } @@ -650,8 +650,8 @@ void BMO_HeaderFlag_To_Slot(BMesh *bm, BMOperator *op, const char *slotname, } if (htype & BM_FACE) { - for (e = BMIter_New(&elements, bm, BM_FACES_OF_MESH, bm); e; e = BMIter_Step(&elements)) { - if (!BM_TestHFlag(e, BM_ELEM_HIDDEN) && BM_TestHFlag(e, hflag)) { + for (e = BM_iter_new(&elements, bm, BM_FACES_OF_MESH, bm); e; e = BM_iter_step(&elements)) { + if (!BM_elem_flag_test(e, BM_ELEM_HIDDEN) && BM_elem_flag_test(e, hflag)) { ((BMHeader **)output->data.p)[i] = e; i++; } @@ -669,20 +669,20 @@ void BMO_HeaderFlag_To_Slot(BMesh *bm, BMOperator *op, const char *slotname, * Copies elements of a certain type, which have a certain flag set * into an output slot for an operator. */ -void BMO_Flag_To_Slot(BMesh *bm, BMOperator *op, const char *slotname, - const short oflag, const char htype) +void BMO_slot_from_flag(BMesh *bm, BMOperator *op, const char *slotname, + const short oflag, const char htype) { BMIter elements; BMHeader *e; - BMOpSlot *output = BMO_GetSlot(op, slotname); - int totelement = BMO_CountFlag(bm, oflag, htype), i = 0; + BMOpSlot *output = BMO_slot_get(op, slotname); + int totelement = BMO_mesh_flag_count(bm, oflag, htype), i = 0; if (totelement) { alloc_slot_buffer(op, slotname, totelement); if (htype & BM_VERT) { - for (e = BMIter_New(&elements, bm, BM_VERTS_OF_MESH, bm); e; e = BMIter_Step(&elements)) { - if (BMO_TestFlag(bm, e, oflag)) { + for (e = BM_iter_new(&elements, bm, BM_VERTS_OF_MESH, bm); e; e = BM_iter_step(&elements)) { + if (BMO_elem_flag_test(bm, e, oflag)) { ((BMHeader **)output->data.p)[i] = e; i++; } @@ -690,8 +690,8 @@ void BMO_Flag_To_Slot(BMesh *bm, BMOperator *op, const char *slotname, } if (htype & BM_EDGE) { - for (e = BMIter_New(&elements, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&elements)) { - if (BMO_TestFlag(bm, e, oflag)) { + for (e = BM_iter_new(&elements, bm, BM_EDGES_OF_MESH, bm); e; e = BM_iter_step(&elements)) { + if (BMO_elem_flag_test(bm, e, oflag)) { ((BMHeader **)output->data.p)[i] = e; i++; } @@ -699,8 +699,8 @@ void BMO_Flag_To_Slot(BMesh *bm, BMOperator *op, const char *slotname, } if (htype & BM_FACE) { - for (e = BMIter_New(&elements, bm, BM_FACES_OF_MESH, bm); e; e = BMIter_Step(&elements)) { - if (BMO_TestFlag(bm, e, oflag)) { + for (e = BM_iter_new(&elements, bm, BM_FACES_OF_MESH, bm); e; e = BM_iter_step(&elements)) { + if (BMO_elem_flag_test(bm, e, oflag)) { ((BMHeader **)output->data.p)[i] = e; i++; } @@ -719,10 +719,10 @@ void BMO_Flag_To_Slot(BMesh *bm, BMOperator *op, const char *slotname, * Header Flags elements in a slots buffer, automatically * using the selection API where appropriate. */ -void BMO_HeaderFlag_Buffer(BMesh *bm, BMOperator *op, const char *slotname, +void BMO_slot_buffer_hflag(BMesh *bm, BMOperator *op, const char *slotname, const char hflag, const char htype) { - BMOpSlot *slot = BMO_GetSlot(op, slotname); + BMOpSlot *slot = BMO_slot_get(op, slotname); BMHeader **data = slot->data.p; int i; @@ -731,9 +731,9 @@ void BMO_HeaderFlag_Buffer(BMesh *bm, BMOperator *op, const char *slotname, continue; if (hflag & BM_ELEM_SELECT) { - BM_Select(bm, data[i], TRUE); + BM_elem_select_set(bm, data[i], TRUE); } - BM_SetHFlag(data[i], hflag); + BM_elem_flag_set(data[i], hflag); } } @@ -744,10 +744,10 @@ void BMO_HeaderFlag_Buffer(BMesh *bm, BMOperator *op, const char *slotname, * Removes flags from elements in a slots buffer, automatically * using the selection API where appropriate. */ -void BMO_UnHeaderFlag_Buffer(BMesh *bm, BMOperator *op, const char *slotname, +void BMO_slot_buffer_hflag_clear(BMesh *bm, BMOperator *op, const char *slotname, const char hflag, const char htype) { - BMOpSlot *slot = BMO_GetSlot(op, slotname); + BMOpSlot *slot = BMO_slot_get(op, slotname); BMHeader **data = slot->data.p; int i; @@ -756,13 +756,13 @@ void BMO_UnHeaderFlag_Buffer(BMesh *bm, BMOperator *op, const char *slotname, continue; if (hflag & BM_ELEM_SELECT) { - BM_Select(bm, data[i], FALSE); + BM_elem_select_set(bm, data[i], FALSE); } - BM_ClearHFlag(data[i], hflag); + BM_elem_flag_clear(data[i], hflag); } } -int BMO_Vert_CountEdgeFlags(BMesh *bm, BMVert *v, const short oflag) +int BMO_vert_edge_flags_count(BMesh *bm, BMVert *v, const short oflag) { int count = 0; @@ -772,7 +772,7 @@ int BMO_Vert_CountEdgeFlags(BMesh *bm, BMVert *v, const short oflag) int i; for (i = 0, curedge = v->e; i < len; i++) { - if (BMO_TestFlag(bm, curedge, oflag)) + if (BMO_elem_flag_test(bm, curedge, oflag)) count++; curedge = bmesh_disk_nextedge(curedge, v); } @@ -787,10 +787,10 @@ int BMO_Vert_CountEdgeFlags(BMesh *bm, BMVert *v, const short oflag) * * Flags elements in a slots buffer */ -void BMO_Flag_Buffer(BMesh *bm, BMOperator *op, const char *slotname, +void BMO_slot_buffer_flag(BMesh *bm, BMOperator *op, const char *slotname, const short oflag, const char htype) { - BMOpSlot *slot = BMO_GetSlot(op, slotname); + BMOpSlot *slot = BMO_slot_get(op, slotname); BMHeader **data = slot->data.p; int i; @@ -798,7 +798,7 @@ void BMO_Flag_Buffer(BMesh *bm, BMOperator *op, const char *slotname, if (!(htype & data[i]->htype)) continue; - BMO_SetFlag(bm, data[i], oflag); + BMO_elem_flag_set(bm, data[i], oflag); } } @@ -808,10 +808,10 @@ void BMO_Flag_Buffer(BMesh *bm, BMOperator *op, const char *slotname, * * Removes flags from elements in a slots buffer */ -void BMO_Unflag_Buffer(BMesh *bm, BMOperator *op, const char *slotname, +void BMO_slot_buffer_flag_clear(BMesh *bm, BMOperator *op, const char *slotname, const short oflag, const char htype) { - BMOpSlot *slot = BMO_GetSlot(op, slotname); + BMOpSlot *slot = BMO_slot_get(op, slotname); BMHeader **data = slot->data.p; int i; @@ -819,7 +819,7 @@ void BMO_Unflag_Buffer(BMesh *bm, BMOperator *op, const char *slotname, if (!(htype & data[i]->htype)) continue; - BMO_ClearFlag(bm, data[i], oflag); + BMO_elem_flag_clear(bm, data[i], oflag); } } @@ -859,23 +859,23 @@ static void alloc_flag_layer(BMesh *bm) bm->toolflagpool = newpool = BLI_mempool_create(sizeof(BMFlagLayer)*bm->totflags, 512, 512, FALSE, FALSE); /* now go through and memcpy all the flags. Loops don't get a flag layer at this time.. */ - for (ele = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, bm), i = 0; ele; ele = BMIter_Step(&iter), i++) { + for (ele = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, bm), i = 0; ele; ele = BM_iter_step(&iter), i++) { oldflags = ele->flags; ele->flags = BLI_mempool_calloc(newpool); memcpy(ele->flags, oldflags, old_totflags_size); - BM_SetIndex(ele, i); /* set_inline */ + BM_elem_index_set(ele, i); /* set_inline */ } - for (ele = BMIter_New(&iter, bm, BM_EDGES_OF_MESH, bm), i = 0; ele; ele = BMIter_Step(&iter), i++) { + for (ele = BM_iter_new(&iter, bm, BM_EDGES_OF_MESH, bm), i = 0; ele; ele = BM_iter_step(&iter), i++) { oldflags = ele->flags; ele->flags = BLI_mempool_calloc(newpool); memcpy(ele->flags, oldflags, old_totflags_size); - BM_SetIndex(ele, i); /* set_inline */ + BM_elem_index_set(ele, i); /* set_inline */ } - for (ele = BMIter_New(&iter, bm, BM_FACES_OF_MESH, bm), i = 0; ele; ele = BMIter_Step(&iter), i++) { + for (ele = BM_iter_new(&iter, bm, BM_FACES_OF_MESH, bm), i = 0; ele; ele = BM_iter_step(&iter), i++) { oldflags = ele->flags; ele->flags = BLI_mempool_calloc(newpool); memcpy(ele->flags, oldflags, old_totflags_size); - BM_SetIndex(ele, i); /* set_inline */ + BM_elem_index_set(ele, i); /* set_inline */ } bm->elem_index_dirty &= ~(BM_VERT|BM_EDGE|BM_FACE); @@ -904,23 +904,23 @@ static void free_flag_layer(BMesh *bm) bm->toolflagpool = newpool = BLI_mempool_create(new_totflags_size, 512, 512, TRUE, FALSE); /* now go through and memcpy all the flag */ - for (ele = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, bm), i = 0; ele; ele = BMIter_Step(&iter), i++) { + for (ele = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, bm), i = 0; ele; ele = BM_iter_step(&iter), i++) { oldflags = ele->flags; ele->flags = BLI_mempool_calloc(newpool); memcpy(ele->flags, oldflags, new_totflags_size); - BM_SetIndex(ele, i); /* set_inline */ + BM_elem_index_set(ele, i); /* set_inline */ } - for (ele = BMIter_New(&iter, bm, BM_EDGES_OF_MESH, bm), i = 0; ele; ele = BMIter_Step(&iter), i++) { + for (ele = BM_iter_new(&iter, bm, BM_EDGES_OF_MESH, bm), i = 0; ele; ele = BM_iter_step(&iter), i++) { oldflags = ele->flags; ele->flags = BLI_mempool_calloc(newpool); memcpy(ele->flags, oldflags, new_totflags_size); - BM_SetIndex(ele, i); /* set_inline */ + BM_elem_index_set(ele, i); /* set_inline */ } - for (ele = BMIter_New(&iter, bm, BM_FACES_OF_MESH, bm), i = 0; ele; ele = BMIter_Step(&iter), i++) { + for (ele = BM_iter_new(&iter, bm, BM_FACES_OF_MESH, bm), i = 0; ele; ele = BM_iter_step(&iter), i++) { oldflags = ele->flags; ele->flags = BLI_mempool_calloc(newpool); memcpy(ele->flags, oldflags, new_totflags_size); - BM_SetIndex(ele, i); /* set_inline */ + BM_elem_index_set(ele, i); /* set_inline */ } bm->elem_index_dirty &= ~(BM_VERT|BM_EDGE|BM_FACE); @@ -939,25 +939,25 @@ static void clear_flag_layer(BMesh *bm) const int totflags_offset = bm->totflags - 1; /* now go through and memcpy all the flag */ - for (ele = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, bm), i = 0; ele; ele = BMIter_Step(&iter), i++) { + for (ele = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, bm), i = 0; ele; ele = BM_iter_step(&iter), i++) { memset(ele->flags + totflags_offset, 0, sizeof(BMFlagLayer)); - BM_SetIndex(ele, i); /* set_inline */ + BM_elem_index_set(ele, i); /* set_inline */ } - for (ele = BMIter_New(&iter, bm, BM_EDGES_OF_MESH, bm), i = 0; ele; ele = BMIter_Step(&iter), i++) { + for (ele = BM_iter_new(&iter, bm, BM_EDGES_OF_MESH, bm), i = 0; ele; ele = BM_iter_step(&iter), i++) { memset(ele->flags + totflags_offset, 0, sizeof(BMFlagLayer)); - BM_SetIndex(ele, i); /* set_inline */ + BM_elem_index_set(ele, i); /* set_inline */ } - for (ele = BMIter_New(&iter, bm, BM_FACES_OF_MESH, bm), i = 0; ele; ele = BMIter_Step(&iter), i++) { + for (ele = BM_iter_new(&iter, bm, BM_FACES_OF_MESH, bm), i = 0; ele; ele = BM_iter_step(&iter), i++) { memset(ele->flags + totflags_offset, 0, sizeof(BMFlagLayer)); - BM_SetIndex(ele, i); /* set_inline */ + BM_elem_index_set(ele, i); /* set_inline */ } bm->elem_index_dirty &= ~(BM_VERT|BM_EDGE|BM_FACE); } -void *BMO_FirstElem(BMOperator *op, const char *slotname) +void *BMO_slot_elem_first(BMOperator *op, const char *slotname) { - BMOpSlot *slot = BMO_GetSlot(op, slotname); + BMOpSlot *slot = BMO_slot_get(op, slotname); if (slot->slottype != BMOP_OPSLOT_ELEMENT_BUF) return NULL; @@ -965,10 +965,10 @@ void *BMO_FirstElem(BMOperator *op, const char *slotname) return slot->data.buf ? *(void **)slot->data.buf : NULL; } -void *BMO_IterNew(BMOIter *iter, BMesh *UNUSED(bm), BMOperator *op, +void *BMO_iter_new(BMOIter *iter, BMesh *UNUSED(bm), BMOperator *op, const char *slotname, const char restrictmask) { - BMOpSlot *slot = BMO_GetSlot(op, slotname); + BMOpSlot *slot = BMO_slot_get(op, slotname); memset(iter, 0, sizeof(BMOIter)); @@ -985,10 +985,10 @@ void *BMO_IterNew(BMOIter *iter, BMesh *UNUSED(bm), BMOperator *op, } } - return BMO_IterStep(iter); + return BMO_iter_step(iter); } -void *BMO_IterStep(BMOIter *iter) +void *BMO_iter_step(BMOIter *iter) { if (iter->slot->slottype == BMOP_OPSLOT_ELEMENT_BUF) { BMHeader *h; @@ -1024,17 +1024,17 @@ void *BMO_IterStep(BMOIter *iter) } /* used for iterating over mapping */ -void *BMO_IterMapVal(BMOIter *iter) +void *BMO_iter_map_value(BMOIter *iter) { return iter->val; } -void *BMO_IterMapValp(BMOIter *iter) +void *BMO_iter_map_value_p(BMOIter *iter) { return *((void **)iter->val); } -float BMO_IterMapValf(BMOIter *iter) +float BMO_iter_map_value_f(BMOIter *iter) { return *((float *)iter->val); } @@ -1047,12 +1047,12 @@ typedef struct BMOpError { const char *msg; } BMOpError; -void BMO_ClearStack(BMesh *bm) +void BMO_error_clear(BMesh *bm) { - while (BMO_PopError(bm, NULL, NULL)); + while (BMO_error_pop(bm, NULL, NULL)); } -void BMO_RaiseError(BMesh *bm, BMOperator *owner, int errcode, const char *msg) +void BMO_error_raise(BMesh *bm, BMOperator *owner, int errcode, const char *msg) { BMOpError *err = MEM_callocN(sizeof(BMOpError), "bmop_error"); @@ -1064,13 +1064,13 @@ void BMO_RaiseError(BMesh *bm, BMOperator *owner, int errcode, const char *msg) BLI_addhead(&bm->errorstack, err); } -int BMO_HasError(BMesh *bm) +int BMO_error_occurred(BMesh *bm) { return bm->errorstack.first != NULL; } /* returns error code or 0 if no erro */ -int BMO_GetError(BMesh *bm, const char **msg, BMOperator **op) +int BMO_error_get(BMesh *bm, const char **msg, BMOperator **op) { BMOpError *err = bm->errorstack.first; if (!err) { @@ -1083,9 +1083,9 @@ int BMO_GetError(BMesh *bm, const char **msg, BMOperator **op) return err->errorcode; } -int BMO_PopError(BMesh *bm, const char **msg, BMOperator **op) +int BMO_error_pop(BMesh *bm, const char **msg, BMOperator **op) { - int errorcode = BMO_GetError(bm, msg, op); + int errorcode = BMO_error_get(bm, msg, op); if (errorcode) { BMOpError *err = bm->errorstack.first; @@ -1150,7 +1150,7 @@ static int bmesh_opname_to_opcode(const char *opname) return -1; } -int BMO_VInitOpf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist) +int BMO_op_vinitf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist) { BMOpDefine *def; char *opname, *ofmt, *fmt; @@ -1183,7 +1183,7 @@ int BMO_VInitOpf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist) return FALSE; } - BMO_Init_Op(bm, op, opname); + BMO_op_init(bm, op, opname); def = opdefines[i]; i = 0; @@ -1231,18 +1231,18 @@ int BMO_VInitOpf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist) else if (c == '4') size = 4; else GOTO_ERROR; - BMO_Set_Mat(op, slotname, va_arg(vlist, void *), size); + BMO_slot_mat_set(op, slotname, va_arg(vlist, void *), size); state = 1; break; } case 'v': { - BMO_Set_Vec(op, slotname, va_arg(vlist, float *)); + BMO_slot_vec_set(op, slotname, va_arg(vlist, float *)); state = 1; break; } case 'e': { BMHeader *ele = va_arg(vlist, void *); - BMOpSlot *slot = BMO_GetSlot(op, slotname); + BMOpSlot *slot = BMO_slot_get(op, slotname); slot->data.buf = BLI_memarena_alloc(op->arena, sizeof(void *) * 4); slot->len = 1; @@ -1255,17 +1255,17 @@ int BMO_VInitOpf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist) BMOperator *op2 = va_arg(vlist, void *); const char *slotname2 = va_arg(vlist, char *); - BMO_CopySlot(op2, op, slotname2, slotname); + BMO_slot_copy(op2, op, slotname2, slotname); state = 1; break; } case 'i': case 'd': - BMO_Set_Int(op, slotname, va_arg(vlist, int)); + BMO_slot_int_set(op, slotname, va_arg(vlist, int)); state = 1; break; case 'p': - BMO_Set_Pnt(op, slotname, va_arg(vlist, void *)); + BMO_slot_ptr_set(op, slotname, va_arg(vlist, void *)); state = 1; break; case 'f': @@ -1274,7 +1274,7 @@ int BMO_VInitOpf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist) type = *fmt; if (NEXT_CHAR(fmt) == ' ' || NEXT_CHAR(fmt) == '\t' || NEXT_CHAR(fmt) == '\0') { - BMO_Set_Float(op, slotname, va_arg(vlist, double)); + BMO_slot_float_set(op, slotname, va_arg(vlist, double)); } else { ret = 0; @@ -1296,13 +1296,13 @@ int BMO_VInitOpf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist) } if (type == 'h') { - BMO_HeaderFlag_To_Slot(bm, op, slotname, va_arg(vlist, int), ret); + BMO_slot_from_hflag(bm, op, slotname, va_arg(vlist, int), ret); } else if (type == 'a') { - BMO_All_To_Slot(bm, op, slotname, ret); + BMO_slot_from_all(bm, op, slotname, ret); } else { - BMO_Flag_To_Slot(bm, op, slotname, va_arg(vlist, int), ret); + BMO_slot_from_flag(bm, op, slotname, va_arg(vlist, int), ret); } } @@ -1328,7 +1328,7 @@ error: __func__, (int)(fmt - ofmt), _fmt, __FILE__, lineno); MEM_freeN(ofmt); - BMO_Finish_Op(bm, op); + BMO_op_finish(bm, op); return FALSE; #undef GOTO_ERROR @@ -1336,12 +1336,12 @@ error: } -int BMO_InitOpf(BMesh *bm, BMOperator *op, const char *fmt, ...) +int BMO_op_initf(BMesh *bm, BMOperator *op, const char *fmt, ...) { va_list list; va_start(list, fmt); - if (!BMO_VInitOpf(bm, op, fmt, list)) { + if (!BMO_op_vinitf(bm, op, fmt, list)) { printf("%s: failed\n", __func__); va_end(list); return FALSE; @@ -1351,20 +1351,20 @@ int BMO_InitOpf(BMesh *bm, BMOperator *op, const char *fmt, ...) return TRUE; } -int BMO_CallOpf(BMesh *bm, const char *fmt, ...) +int BMO_op_callf(BMesh *bm, const char *fmt, ...) { va_list list; BMOperator op; va_start(list, fmt); - if (!BMO_VInitOpf(bm, &op, fmt, list)) { + if (!BMO_op_vinitf(bm, &op, fmt, list)) { printf("%s: failed, format is:\n \"%s\"\n", __func__, fmt); va_end(list); return FALSE; } - BMO_Exec_Op(bm, &op); - BMO_Finish_Op(bm, &op); + BMO_op_exec(bm, &op); + BMO_op_finish(bm, &op); va_end(list); return TRUE; @@ -1375,10 +1375,10 @@ int BMO_CallOpf(BMesh *bm, const char *fmt, ...) * * Toggles a flag for a certain element */ -#ifdef BMO_ToggleFlag -#undef BMO_ToggleFlag +#ifdef BMO_elem_flag_toggle +#undef BMO_elem_flag_toggle #endif -static void BMO_ToggleFlag(BMesh *bm, void *element, const short oflag) +static void BMO_elem_flag_toggle(BMesh *bm, void *element, const short oflag) { BMHeader *head = element; head->flags[bm->stackdepth - 1].f ^= oflag; @@ -1389,10 +1389,10 @@ static void BMO_ToggleFlag(BMesh *bm, void *element, const short oflag) * * Sets a flag for a certain element */ -#ifdef BMO_SetFlag -#undef BMO_SetFlag +#ifdef BMO_elem_flag_set +#undef BMO_elem_flag_set #endif -static void BMO_SetFlag(BMesh *bm, void *element, const short oflag) +static void BMO_elem_flag_set(BMesh *bm, void *element, const short oflag) { BMHeader *head = element; head->flags[bm->stackdepth - 1].f |= oflag; @@ -1403,10 +1403,10 @@ static void BMO_SetFlag(BMesh *bm, void *element, const short oflag) * * Clears a specific flag from a given element */ -#ifdef BMO_ClearFlag -#undef BMO_ClearFlag +#ifdef BMO_elem_flag_clear +#undef BMO_elem_flag_clear #endif -static void BMO_ClearFlag(BMesh *bm, void *element, const short oflag) +static void BMO_elem_flag_clear(BMesh *bm, void *element, const short oflag) { BMHeader *head = element; head->flags[bm->stackdepth - 1].f &= ~oflag; @@ -1418,10 +1418,10 @@ static void BMO_ClearFlag(BMesh *bm, void *element, const short oflag) * Tests whether or not a flag is set for a specific element * */ -#ifdef BMO_TestFlag -#undef BMO_TestFlag +#ifdef BMO_elem_flag_test +#undef BMO_elem_flag_test #endif -static int BMO_TestFlag(BMesh *bm, void *element, const short oflag) +static int BMO_elem_flag_test(BMesh *bm, void *element, const short oflag) { BMHeader *head = element; if (head->flags[bm->stackdepth - 1].f & oflag) diff --git a/source/blender/bmesh/intern/bmesh_polygon.c b/source/blender/bmesh/intern/bmesh_polygon.c index 62d6e8bf928..f26f942e2ac 100644 --- a/source/blender/bmesh/intern/bmesh_polygon.c +++ b/source/blender/bmesh/intern/bmesh_polygon.c @@ -221,7 +221,7 @@ static int compute_poly_center(float center[3], float *r_area, float (*verts)[3] return FALSE; } -float BM_Compute_Face_Area(BMesh *bm, BMFace *f) +float BM_face_area_calc(BMesh *bm, BMFace *f) { BMLoop *l; BMIter iter; @@ -248,7 +248,7 @@ float BM_Compute_Face_Area(BMesh *bm, BMFace *f) /* * computes center of face in 3d. uses center of bounding box. */ -void BM_Compute_Face_CenterBounds(BMesh *bm, BMFace *f, float r_cent[3]) +void BM_face_center_bounds_calc(BMesh *bm, BMFace *f, float r_cent[3]) { BMIter iter; BMLoop *l; @@ -256,15 +256,15 @@ void BM_Compute_Face_CenterBounds(BMesh *bm, BMFace *f, float r_cent[3]) int i; INIT_MINMAX(min, max); - l = BMIter_New(&iter, bm, BM_LOOPS_OF_FACE, f); - for (i = 0; l; l = BMIter_Step(&iter), i++) { + l = BM_iter_new(&iter, bm, BM_LOOPS_OF_FACE, f); + for (i = 0; l; l = BM_iter_step(&iter), i++) { DO_MINMAX(l->v->co, min, max); } mid_v3_v3v3(r_cent, min, max); } -void BM_Compute_Face_CenterMean(BMesh *bm, BMFace *f, float r_cent[3]) +void BM_face_center_mean_calc(BMesh *bm, BMFace *f, float r_cent[3]) { BMIter iter; BMLoop *l; @@ -272,8 +272,8 @@ void BM_Compute_Face_CenterMean(BMesh *bm, BMFace *f, float r_cent[3]) zero_v3(r_cent); - l = BMIter_New(&iter, bm, BM_LOOPS_OF_FACE, f); - for (i = 0; l; l = BMIter_Step(&iter), i++) { + l = BM_iter_new(&iter, bm, BM_LOOPS_OF_FACE, f); + for (i = 0; l; l = BM_iter_step(&iter), i++) { add_v3_v3(r_cent, l->v->co); } @@ -415,7 +415,7 @@ void poly_rotate_plane(const float normal[3], float (*verts)[3], const int nvert * */ -void BM_Face_UpdateNormal(BMesh *bm, BMFace *f) +void BM_face_normal_update(BMesh *bm, BMFace *f) { if (f->len >= 3) { float (*proj)[3]; @@ -427,8 +427,8 @@ void BM_Face_UpdateNormal(BMesh *bm, BMFace *f) BLI_array_fixedstack_free(proj); } } -/* same as BM_Face_UpdateNormal but takes vertex coords */ -void BM_Face_UpdateNormal_VertexCos(BMesh *bm, BMFace *f, float no[3], float (*vertexCos)[3]) +/* same as BM_face_normal_update but takes vertex coords */ +void BM_face_normal_update_vcos(BMesh *bm, BMFace *f, float no[3], float (*vertexCos)[3]) { if (f->len >= 3) { float (*proj)[3]; @@ -441,21 +441,21 @@ void BM_Face_UpdateNormal_VertexCos(BMesh *bm, BMFace *f, float no[3], float (*v } } -void BM_Edge_UpdateNormals(BMesh *bm, BMEdge *e) +void BM_edge_normals_update(BMesh *bm, BMEdge *e) { BMIter iter; BMFace *f; - f = BMIter_New(&iter, bm, BM_FACES_OF_EDGE, e); - for ( ; f; f = BMIter_Step(&iter)) { - BM_Face_UpdateNormal(bm, f); + f = BM_iter_new(&iter, bm, BM_FACES_OF_EDGE, e); + for ( ; f; f = BM_iter_step(&iter)) { + BM_face_normal_update(bm, f); } - BM_Vert_UpdateNormal(bm, e->v1); - BM_Vert_UpdateNormal(bm, e->v2); + BM_vert_normal_update(bm, e->v1); + BM_vert_normal_update(bm, e->v2); } -void BM_Vert_UpdateNormal(BMesh *bm, BMVert *v) +void BM_vert_normal_update(BMesh *bm, BMVert *v) { BMIter eiter, liter; BMEdge *e; @@ -468,7 +468,7 @@ void BM_Vert_UpdateNormal(BMesh *bm, BMVert *v) BM_ITER(e, &eiter, bm, BM_EDGES_OF_VERT, v) { BM_ITER(l, &liter, bm, BM_LOOPS_OF_EDGE, e) { if (l->v == v) { - /* Same calculation used in BM_Compute_Normals */ + /* 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); normalize_v3(vec1); @@ -488,18 +488,18 @@ void BM_Vert_UpdateNormal(BMesh *bm, BMVert *v) } } -void BM_Vert_UpdateAllNormals(BMesh *bm, BMVert *v) +void BM_vert_normal_update_all(BMesh *bm, BMVert *v) { BMIter iter; BMFace *f; int len = 0; - f = BMIter_New(&iter, bm, BM_FACES_OF_VERT, v); - for ( ; f; f = BMIter_Step(&iter), len++) { - BM_Face_UpdateNormal(bm, f); + f = BM_iter_new(&iter, bm, BM_FACES_OF_VERT, v); + for ( ; f; f = BM_iter_step(&iter), len++) { + BM_face_normal_update(bm, f); } - BM_Vert_UpdateNormal(bm, v); + BM_vert_normal_update(bm, v); } void bmesh_update_face_normal(BMesh *bm, BMFace *f, float no[3], @@ -562,10 +562,10 @@ void bmesh_update_face_normal_vertex_cos(BMesh *bm, BMFace *f, float no[3], BMVert *v3 = (l = l->next)->v; BMVert *v4 = (l->next)->v; normal_quad_v3(no, - vertexCos[BM_GetIndex(v1)], - vertexCos[BM_GetIndex(v2)], - vertexCos[BM_GetIndex(v3)], - vertexCos[BM_GetIndex(v4)]); + vertexCos[BM_elem_index_get(v1)], + vertexCos[BM_elem_index_get(v2)], + vertexCos[BM_elem_index_get(v3)], + vertexCos[BM_elem_index_get(v4)]); break; } case 3: @@ -574,9 +574,9 @@ void bmesh_update_face_normal_vertex_cos(BMesh *bm, BMFace *f, float no[3], BMVert *v2 = (l = l->next)->v; BMVert *v3 = (l->next)->v; normal_tri_v3(no, - vertexCos[BM_GetIndex(v1)], - vertexCos[BM_GetIndex(v2)], - vertexCos[BM_GetIndex(v3)]); + vertexCos[BM_elem_index_get(v1)], + vertexCos[BM_elem_index_get(v2)], + vertexCos[BM_elem_index_get(v3)]); break; } case 0: @@ -589,7 +589,7 @@ void bmesh_update_face_normal_vertex_cos(BMesh *bm, BMFace *f, float no[3], BMIter iter; int i = 0; BM_ITER(l, &iter, bm, BM_LOOPS_OF_FACE, f) { - copy_v3_v3(projectverts[i], vertexCos[BM_GetIndex(l->v)]); + copy_v3_v3(projectverts[i], vertexCos[BM_elem_index_get(l->v)]); i += 1; } compute_poly_normal(no, projectverts, f->len); @@ -605,7 +605,7 @@ void bmesh_update_face_normal_vertex_cos(BMesh *bm, BMFace *f, float no[3], * Note that this updates the calculated * normal. */ -void BM_flip_normal(BMesh *bm, BMFace *f) +void BM_face_normal_flip(BMesh *bm, BMFace *f) { bmesh_loop_reverse(bm, f); negate_v3(f->no); @@ -685,7 +685,7 @@ static int linecrossesf(const float v1[2], const float v2[2], const float v3[2], * test, instead of projecting co directly into f's orientation * space, so there might be accuracy issues. */ -int BM_Point_In_Face(BMesh *bm, BMFace *f, const float co[3]) +int BM_face_point_inside_test(BMesh *bm, BMFace *f, const float co[3]) { int ax, ay; float co2[3], cent[3] = {0.0f, 0.0f, 0.0f}, out[3] = {FLT_MAX * 0.5f, FLT_MAX * 0.5f, 0}; @@ -695,7 +695,7 @@ int BM_Point_In_Face(BMesh *bm, BMFace *f, const float co[3]) float eps = 1.0f + (float)FLT_EPSILON * 150.0f; if (dot_v3v3(f->no, f->no) <= FLT_EPSILON * 10) - BM_Face_UpdateNormal(bm, f); + BM_face_normal_update(bm, f); /* find best projection of face XY, XZ or YZ: barycentric weights of * the 2d projected coords are the same and faster to compute @@ -754,13 +754,13 @@ static int goodline(float (*projectverts)[3], BMFace *f, int v1i, //for (i = 0; i < nvert; i++) { l_iter = l_first = BM_FACE_FIRST_LOOP(f); do { - i = BM_GetIndex(l_iter->v); + i = BM_elem_index_get(l_iter->v); if (i == v1i || i == v2i || i == v3i) { continue; } - VECCOPY(pv1, projectverts[BM_GetIndex(l_iter->v)]); - VECCOPY(pv2, projectverts[BM_GetIndex(l_iter->next->v)]); + VECCOPY(pv1, projectverts[BM_elem_index_get(l_iter->v)]); + VECCOPY(pv2, projectverts[BM_elem_index_get(l_iter->next->v)]); //if (linecrosses(pv1, pv2, v1, v3)) return FALSE; @@ -799,10 +799,10 @@ static BMLoop *find_ear(BMesh *UNUSED(bm), BMFace *f, float (*verts)[3], const i v2 = l_iter->v; v3 = l_iter->next->v; - if (BM_Edge_Exist(v1, v3)) { + if (BM_edge_exists(v1, v3)) { isear = 0; } - else if (!goodline(verts, f, BM_GetIndex(v1), BM_GetIndex(v2), BM_GetIndex(v3), nvert)) { + else if (!goodline(verts, f, BM_elem_index_get(v1), BM_elem_index_get(v2), BM_elem_index_get(v3), nvert)) { isear = 0; } @@ -857,7 +857,7 @@ void BM_Triangulate_Face(BMesh *bm, BMFace *f, float (*projectverts)[3], l_iter = l_first = BM_FACE_FIRST_LOOP(f); do { copy_v3_v3(projectverts[i], l_iter->v->co); - BM_SetIndex(l_iter->v, i); /* set dirty! */ + BM_elem_index_set(l_iter->v, i); /* set dirty! */ i++; } while ((l_iter = l_iter->next) != l_first); @@ -882,7 +882,7 @@ void BM_Triangulate_Face(BMesh *bm, BMFace *f, float (*projectverts)[3], if (l_iter) { done = 0; /* v = l->v; */ /* UNUSED */ - f = BM_Split_Face(bm, l_iter->f, l_iter->prev->v, + f = BM_face_split(bm, l_iter->f, l_iter->prev->v, l_iter->next->v, &newl, NULL); copy_v3_v3(f->no, l_iter->f->no); @@ -892,8 +892,8 @@ void BM_Triangulate_Face(BMesh *bm, BMFace *f, float (*projectverts)[3], break; } - BMO_SetFlag(bm, newl->e, newedge_oflag); - BMO_SetFlag(bm, f, newface_oflag); + BMO_elem_flag_set(bm, newl->e, newedge_oflag); + BMO_elem_flag_set(bm, f, newface_oflag); if (newfaces) newfaces[nf_i++] = f; @@ -912,7 +912,7 @@ void BM_Triangulate_Face(BMesh *bm, BMFace *f, float (*projectverts)[3], l_iter = BM_FACE_FIRST_LOOP(f); while (l_iter->f->len > 3) { nextloop = l_iter->next->next; - f = BM_Split_Face(bm, l_iter->f, l_iter->v, nextloop->v, + f = BM_face_split(bm, l_iter->f, l_iter->v, nextloop->v, &newl, NULL); if (!f) { printf("triangle fan step of triangulator failed.\n"); @@ -924,8 +924,8 @@ void BM_Triangulate_Face(BMesh *bm, BMFace *f, float (*projectverts)[3], if (newfaces) newfaces[nf_i++] = f; - BMO_SetFlag(bm, newl->e, newedge_oflag); - BMO_SetFlag(bm, f, newface_oflag); + BMO_elem_flag_set(bm, newl->e, newedge_oflag); + BMO_elem_flag_set(bm, f, newface_oflag); l_iter = nextloop; } } @@ -940,7 +940,7 @@ void BM_Triangulate_Face(BMesh *bm, BMFace *f, float (*projectverts)[3], * edges in the face, or it intersects another split. in the case of * intersecting splits, only the first of the set of intersecting * splits survives */ -void BM_LegalSplits(BMesh *bm, BMFace *f, BMLoop *(*loops)[2], int len) +void BM_face_legal_splits(BMesh *bm, BMFace *f, BMLoop *(*loops)[2], int len) { BMIter iter; BMLoop *l; @@ -951,13 +951,13 @@ void BM_LegalSplits(BMesh *bm, BMFace *f, BMLoop *(*loops)[2], int len) float fac1 = 1.0000001f, fac2 = 0.9f; //9999f; //0.999f; int i, j, a = 0, clen; - BLI_array_fixedstack_declare(projverts, BM_NGON_STACK_SIZE, f->len, "projvertsb"); + BLI_array_fixedstack_declare(projverts, BM_NGON_STACK_SIZE, f->len, "projvertsb"); BLI_array_fixedstack_declare(edgeverts, BM_NGON_STACK_SIZE * 2, len * 2, "edgevertsb"); i = 0; - l = BMIter_New(&iter, bm, BM_LOOPS_OF_FACE, f); - for ( ; l; l = BMIter_Step(&iter)) { - BM_SetIndex(l, i); /* set_loop */ + l = BM_iter_new(&iter, bm, BM_LOOPS_OF_FACE, f); + for ( ; l; l = BM_iter_step(&iter)) { + BM_elem_index_set(l, i); /* set_loop */ copy_v3_v3(projverts[i], l->v->co); i++; } diff --git a/source/blender/bmesh/intern/bmesh_queries.c b/source/blender/bmesh/intern/bmesh_queries.c index b2b9dd5a5fb..e4582e7a02f 100644 --- a/source/blender/bmesh/intern/bmesh_queries.c +++ b/source/blender/bmesh/intern/bmesh_queries.c @@ -45,7 +45,7 @@ * type 'type' in a given bmesh. */ -int BM_Count_Element(BMesh *bm, const char htype) +int BM_mesh_elem_count(BMesh *bm, const char htype) { if (htype == BM_VERT) return bm->totvert; else if (htype == BM_EDGE) return bm->totedge; @@ -63,7 +63,7 @@ int BM_Count_Element(BMesh *bm, const char htype) * */ -int BM_Vert_In_Edge(BMEdge *e, BMVert *v) +int BM_vert_in_edge(BMEdge *e, BMVert *v) { return bmesh_vert_in_edge(e, v); } @@ -75,7 +75,7 @@ int BM_Vert_In_Edge(BMEdge *e, BMVert *v) * */ -BMLoop *BM_OtherFaceLoop(BMEdge *e, BMFace *f, BMVert *v) +BMLoop *BM_face_other_loop(BMEdge *e, BMFace *f, BMVert *v) { BMLoop *l_iter; BMLoop *l_first; @@ -99,7 +99,7 @@ BMLoop *BM_OtherFaceLoop(BMEdge *e, BMFace *f, BMVert *v) * */ -int BM_Vert_In_Face(BMFace *f, BMVert *v) +int BM_vert_in_face(BMFace *f, BMVert *v) { BMLoopList *lst; BMLoop *l_iter; @@ -123,26 +123,26 @@ int BM_Vert_In_Face(BMFace *f, BMVert *v) * that appear in a given face * */ -int BM_Verts_In_Face(BMesh *bm, BMFace *f, BMVert **varr, int len) +int BM_verts_in_face(BMesh *bm, BMFace *f, BMVert **varr, int len) { BMLoopList *lst; BMLoop *curloop = NULL; int i, count = 0; - for (i = 0; i < len; i++) BMO_SetFlag(bm, varr[i], BM_OVERLAP); + for (i = 0; i < len; i++) BMO_elem_flag_set(bm, varr[i], BM_OVERLAP); for (lst = f->loops.first; lst; lst = lst->next) { curloop = lst->first; do { - if (BMO_TestFlag(bm, curloop->v, BM_OVERLAP)) + if (BMO_elem_flag_test(bm, curloop->v, BM_OVERLAP)) count++; curloop = curloop->next; } while (curloop != lst->first); } - for (i = 0; i < len; i++) BMO_ClearFlag(bm, varr[i], BM_OVERLAP); + for (i = 0; i < len; i++) BMO_elem_flag_clear(bm, varr[i], BM_OVERLAP); return count; } @@ -155,7 +155,7 @@ int BM_Verts_In_Face(BMesh *bm, BMFace *f, BMVert **varr, int len) * */ -int BM_Edge_In_Face(BMFace *f, BMEdge *e) +int BM_edge_in_face(BMFace *f, BMEdge *e) { BMLoop *l_iter; BMLoop *l_first; @@ -179,7 +179,7 @@ int BM_Edge_In_Face(BMFace *f, BMEdge *e) * */ -int BM_Verts_In_Edge(BMVert *v1, BMVert *v2, BMEdge *e) +int BM_verts_in_edge(BMVert *v1, BMVert *v2, BMEdge *e) { return bmesh_verts_in_edge(v1, v2, e); } @@ -192,7 +192,7 @@ int BM_Verts_In_Edge(BMVert *v1, BMVert *v2, BMEdge *e) * */ -BMVert *BM_OtherEdgeVert(BMEdge *e, BMVert *v) +BMVert *BM_edge_other_vert(BMEdge *e, BMVert *v) { return bmesh_edge_getothervert(e, v); } @@ -203,7 +203,7 @@ BMVert *BM_OtherEdgeVert(BMEdge *e, BMVert *v) * Returns the number of edges around this vertex. */ -int BM_Vert_EdgeCount(BMVert *v) +int BM_vert_edge_count(BMVert *v) { return bmesh_disk_count(v); } @@ -214,7 +214,7 @@ int BM_Vert_EdgeCount(BMVert *v) * Returns the number of faces around this edge */ -int BM_Edge_FaceCount(BMEdge *e) +int BM_edge_face_count(BMEdge *e) { int count = 0; BMLoop *curloop = NULL; @@ -236,7 +236,7 @@ int BM_Edge_FaceCount(BMEdge *e) * Returns the number of faces around this vert */ -int BM_Vert_FaceCount(BMVert *v) +int BM_vert_face_count(BMVert *v) { int count = 0; BMLoop *l; @@ -253,7 +253,7 @@ int BM_Vert_FaceCount(BMVert *v) if (v->e) { curedge = v->e; do { - if (curedge->l) count += BM_Edge_FaceCount(curedge); + if (curedge->l) count += BM_edge_face_count(curedge); curedge = bmesh_disk_nextedge(curedge, v); } while (curedge != v->e); } @@ -271,7 +271,7 @@ int BM_Vert_FaceCount(BMVert *v) * 1 for true, 0 for false. */ -int BM_Wire_Vert(BMesh *UNUSED(bm), BMVert *v) +int BM_vert_is_wire(BMesh *UNUSED(bm), BMVert *v) { BMEdge *curedge; @@ -301,7 +301,7 @@ int BM_Wire_Vert(BMesh *UNUSED(bm), BMVert *v) * 1 for true, 0 for false. */ -int BM_Wire_Edge(BMesh *UNUSED(bm), BMEdge *e) +int BM_edge_is_wire(BMesh *UNUSED(bm), BMEdge *e) { return (e->l) ? FALSE : TRUE; } @@ -319,7 +319,7 @@ int BM_Wire_Edge(BMesh *UNUSED(bm), BMEdge *e) * 1 for true, 0 for false. */ -int BM_Nonmanifold_Vert(BMesh *UNUSED(bm), BMVert *v) +int BM_vert_is_nonmanifold(BMesh *UNUSED(bm), BMVert *v) { BMEdge *e, *oe; BMLoop *l; @@ -390,9 +390,9 @@ int BM_Nonmanifold_Vert(BMesh *UNUSED(bm), BMVert *v) * 1 for true, 0 for false. */ -int BM_Nonmanifold_Edge(BMesh *UNUSED(bm), BMEdge *e) +int BM_edge_is_nonmanifold(BMesh *UNUSED(bm), BMEdge *e) { - int count = BM_Edge_FaceCount(e); + int count = BM_edge_face_count(e); if (count != 2 && count != 1) { return TRUE; } @@ -409,9 +409,9 @@ int BM_Nonmanifold_Edge(BMesh *UNUSED(bm), BMEdge *e) * 1 for true, 0 for false. */ -int BM_Boundary_Edge(BMEdge *e) +int BM_edge_is_boundry(BMEdge *e) { - int count = BM_Edge_FaceCount(e); + int count = BM_edge_face_count(e); if (count == 1) { return TRUE; } @@ -430,7 +430,7 @@ int BM_Boundary_Edge(BMEdge *e) * Integer */ -int BM_Face_Share_Edges(BMFace *f1, BMFace *f2) +int BM_face_share_edges(BMFace *f1, BMFace *f2) { BMLoop *l_iter; BMLoop *l_first; @@ -454,7 +454,7 @@ int BM_Face_Share_Edges(BMFace *f1, BMFace *f2) * */ -int BM_Edge_Share_Faces(BMEdge *e1, BMEdge *e2) +int BM_edge_share_faces(BMEdge *e1, BMEdge *e2) { BMLoop *l; BMFace *f; @@ -480,7 +480,7 @@ int BM_Edge_Share_Faces(BMEdge *e1, BMEdge *e2) * */ -int BM_Edge_Share_Vert(struct BMEdge *e1, struct BMEdge *e2) +int BM_edge_share_vert(struct BMEdge *e1, struct BMEdge *e2) { return (e1->v1 == e2->v1 || e1->v1 == e2->v2 || @@ -496,12 +496,12 @@ int BM_Edge_Share_Vert(struct BMEdge *e1, struct BMEdge *e2) * if used in a face at all, otherwise just assign as used in the edge. * * Useful to get a determanistic winding order when calling - * BM_Make_Ngon() on an arbitrary array of verts, + * BM_face_create_ngon() on an arbitrary array of verts, * though be sure to pick an edge which has a face. * */ -void BM_Edge_OrderedVerts(BMEdge *edge, BMVert **r_v1, BMVert **r_v2) +void BM_edge_ordered_verts(BMEdge *edge, BMVert **r_v1, BMVert **r_v2) { if ( (edge->l == NULL) || ( ((edge->l->prev->v == edge->v1) && (edge->l->v == edge->v2)) || @@ -527,9 +527,9 @@ void BM_Edge_OrderedVerts(BMEdge *edge, BMVert **r_v1, BMVert **r_v2) * Float. */ -float BM_Face_Angle(BMesh *UNUSED(bm), BMEdge *e) +float BM_edge_face_angle(BMesh *UNUSED(bm), BMEdge *e) { - if (BM_Edge_FaceCount(e) == 2) { + if (BM_edge_face_count(e) == 2) { BMLoop *l1 = e->l; BMLoop *l2 = e->l->radial_next; return acosf(dot_v3v3(l1->f->no, l2->f->no)); @@ -552,7 +552,7 @@ float BM_Face_Angle(BMesh *UNUSED(bm), BMEdge *e) * */ -int BM_Exist_Face_Overlaps(BMesh *bm, BMVert **varr, int len, BMFace **overlapface) +int BM_face_exists_overlap(BMesh *bm, BMVert **varr, int len, BMFace **overlapface) { BMIter vertfaces; BMFace *f; @@ -561,14 +561,14 @@ int BM_Exist_Face_Overlaps(BMesh *bm, BMVert **varr, int len, BMFace **overlapfa if (overlapface) *overlapface = NULL; for (i = 0; i < len; i++) { - f = BMIter_New(&vertfaces, bm, BM_FACES_OF_VERT, varr[i]); + f = BM_iter_new(&vertfaces, bm, BM_FACES_OF_VERT, varr[i]); while (f) { - amount = BM_Verts_In_Face(bm, f, varr, len); + amount = BM_verts_in_face(bm, f, varr, len); if (amount >= len) { if (overlapface) *overlapface = f; return TRUE; } - f = BMIter_Step(&vertfaces); + f = BM_iter_step(&vertfaces); } } return FALSE; @@ -586,7 +586,7 @@ int BM_Exist_Face_Overlaps(BMesh *bm, BMVert **varr, int len, BMFace **overlapfa * 1 for face found */ -int BM_Face_Exists(BMesh *bm, BMVert **varr, int len, BMFace **existface) +int BM_face_exists(BMesh *bm, BMVert **varr, int len, BMFace **existface) { BMIter vertfaces; BMFace *f; @@ -595,14 +595,14 @@ int BM_Face_Exists(BMesh *bm, BMVert **varr, int len, BMFace **existface) if (existface) *existface = NULL; for (i = 0; i < len; i++) { - f = BMIter_New(&vertfaces, bm, BM_FACES_OF_VERT, varr[i]); + f = BM_iter_new(&vertfaces, bm, BM_FACES_OF_VERT, varr[i]); while (f) { - amount = BM_Verts_In_Face(bm, f, varr, len); + amount = BM_verts_in_face(bm, f, varr, len); if (amount == len && amount == f->len) { if (existface) *existface = f; return TRUE; } - f = BMIter_Step(&vertfaces); + f = BM_iter_step(&vertfaces); } } return FALSE; diff --git a/source/blender/bmesh/intern/bmesh_structure.c b/source/blender/bmesh/intern/bmesh_structure.c index d2a54f2ea27..19f20c9cc89 100644 --- a/source/blender/bmesh/intern/bmesh_structure.c +++ b/source/blender/bmesh/intern/bmesh_structure.c @@ -263,7 +263,7 @@ int bmesh_disk_validate(int len, BMEdge *e, BMVert *v) { BMEdge *e2; - if (!BM_Vert_In_Edge(e, v)) + if (!BM_vert_in_edge(e, v)) return FALSE; if (bmesh_disk_count(v) != len || len == 0) return FALSE; diff --git a/source/blender/bmesh/intern/bmesh_walkers.c b/source/blender/bmesh/intern/bmesh_walkers.c index 94ce7c2a5dd..9cba90c1bf5 100644 --- a/source/blender/bmesh/intern/bmesh_walkers.c +++ b/source/blender/bmesh/intern/bmesh_walkers.c @@ -57,11 +57,11 @@ * for if walkers fail. */ -void *BMW_Begin(BMWalker *walker, void *start) +void *BMW_begin(BMWalker *walker, void *start) { walker->begin(walker, start); - return BMW_currentstate(walker) ? walker->step(walker) : NULL; + return BMW_current_state(walker) ? walker->step(walker) : NULL; } /* @@ -72,7 +72,7 @@ void *BMW_Begin(BMWalker *walker, void *start) * by the bitmask 'searchmask'. */ -void BMW_Init(BMWalker *walker, BMesh *bm, int type, +void BMW_init(BMWalker *walker, BMesh *bm, int type, short mask_vert, short mask_edge, short mask_loop, short mask_face, int layer) { @@ -91,7 +91,7 @@ void BMW_Init(BMWalker *walker, BMesh *bm, int type, if (type >= BMW_MAXWALKERS || type < 0) { bmesh_error(); fprintf(stderr, - "Invalid walker type in BMW_Init; type: %d, " + "Invalid walker type in BMW_init; type: %d, " "searchmask: (v:%d, e:%d, l:%d, f:%d), flag: %d\n", type, mask_vert, mask_edge, mask_loop, mask_face, layer); } @@ -118,12 +118,12 @@ void BMW_Init(BMWalker *walker, BMesh *bm, int type, } /* - * BMW_End + * BMW_end * * Frees a walker's worklist. */ -void BMW_End(BMWalker *walker) +void BMW_end(BMWalker *walker) { BLI_mempool_destroy(walker->worklist); BLI_ghash_free(walker->visithash, NULL, NULL); @@ -131,10 +131,10 @@ void BMW_End(BMWalker *walker) /* - * BMW_Step + * BMW_step */ -void *BMW_Step(BMWalker *walker) +void *BMW_step(BMWalker *walker) { BMHeader *head; @@ -144,12 +144,12 @@ void *BMW_Step(BMWalker *walker) } /* - * BMW_CurrentDepth + * BMW_current_depth * * Returns the current depth of the walker. */ -int BMW_CurrentDepth(BMWalker *walker) +int BMW_current_depth(BMWalker *walker) { return walker->depth; } @@ -167,7 +167,7 @@ void *BMW_walk(BMWalker *walker) { void *current = NULL; - while (BMW_currentstate(walker)) { + while (BMW_current_state(walker)) { current = walker->step(walker); if (current) { return current; @@ -177,14 +177,14 @@ void *BMW_walk(BMWalker *walker) } /* - * BMW_currentstate + * BMW_current_state * * Returns the first state from the walker state * worklist. This state is the the next in the * worklist for processing. */ -void *BMW_currentstate(BMWalker *walker) +void *BMW_current_state(BMWalker *walker) { bmesh_walkerGeneric *currentstate = walker->states.first; if (currentstate) { @@ -204,16 +204,16 @@ void *BMW_currentstate(BMWalker *walker) } /* - * BMW_removestate + * BMW_state_remove * * Remove and free an item from the end of the walker state * worklist. */ -void BMW_removestate(BMWalker *walker) +void BMW_state_remove(BMWalker *walker) { void *oldstate; - oldstate = BMW_currentstate(walker); + oldstate = BMW_current_state(walker); BLI_remlink(&walker->states, oldstate); BLI_mempool_free(walker->worklist, oldstate); } @@ -228,7 +228,7 @@ void BMW_removestate(BMWalker *walker) * breadth-first walks. */ -void *BMW_addstate(BMWalker *walker) +void *BMW_state_add(BMWalker *walker) { bmesh_walkerGeneric *newstate; newstate = BLI_mempool_alloc(walker->worklist); @@ -257,8 +257,8 @@ void *BMW_addstate(BMWalker *walker) void BMW_reset(BMWalker *walker) { - while (BMW_currentstate(walker)) { - BMW_removestate(walker); + while (BMW_current_state(walker)) { + BMW_state_remove(walker); } walker->depth = 0; BLI_ghash_free(walker->visithash, NULL, NULL); diff --git a/source/blender/bmesh/intern/bmesh_walkers_impl.c b/source/blender/bmesh/intern/bmesh_walkers_impl.c index 6e5258e70df..ddb45dff4d7 100644 --- a/source/blender/bmesh/intern/bmesh_walkers_impl.c +++ b/source/blender/bmesh/intern/bmesh_walkers_impl.c @@ -51,11 +51,11 @@ static void shellWalker_visitEdge(BMWalker *walker, BMEdge *e) return; } - if (walker->mask_edge && !BMO_TestFlag(walker->bm, e, walker->mask_edge)) { + if (walker->mask_edge && !BMO_elem_flag_test(walker->bm, e, walker->mask_edge)) { return; } - shellWalk = BMW_addstate(walker); + shellWalk = BMW_state_add(walker); shellWalk->curedge = e; BLI_ghash_insert(walker->visithash, e, NULL); } @@ -97,20 +97,20 @@ static void shellWalker_begin(BMWalker *walker, void *data) static void *shellWalker_yield(BMWalker *walker) { - shellWalker *shellWalk = BMW_currentstate(walker); + shellWalker *shellWalk = BMW_current_state(walker); return shellWalk->curedge; } static void *shellWalker_step(BMWalker *walker) { - shellWalker *swalk = BMW_currentstate(walker); + shellWalker *swalk = BMW_current_state(walker); BMEdge *e, *e2; BMVert *v; BMIter iter; int i; e = swalk->curedge; - BMW_removestate(walker); + BMW_state_remove(walker); for (i = 0; i < 2; i++) { v = i ? e->v2 : e->v1; @@ -128,13 +128,13 @@ static void *shellWalker_step(BMWalker *walker) BMEdge *curedge, *next = NULL; BMVert *ov = NULL; int restrictpass = 1; - shellWalker shellWalk = *((shellWalker *)BMW_currentstate(walker)); + shellWalker shellWalk = *((shellWalker *)BMW_current_state(walker)); if (!BLI_ghash_haskey(walker->visithash, shellWalk.base)) { BLI_ghash_insert(walker->visithash, shellWalk.base, NULL); } - BMW_removestate(walker); + BMW_state_remove(walker); /* find the next edge whose other vertex has not been visite */ @@ -142,14 +142,14 @@ static void *shellWalker_step(BMWalker *walker) do { if (!BLI_ghash_haskey(walker->visithash, curedge)) { if (!walker->restrictflag || - (walker->restrictflag && BMO_TestFlag(walker->bm, curedge, walker->restrictflag))) + (walker->restrictflag && BMO_elem_flag_test(walker->bm, curedge, walker->restrictflag))) { shellWalker *newstate; - ov = BM_OtherEdgeVert(curedge, shellWalk.base); + ov = BM_edge_other_vert(curedge, shellWalk.base); /* push a new state onto the stac */ - newState = BMW_addstate(walker); + newState = BMW_state_add(walker); BLI_ghash_insert(walker->visithash, curedge, NULL); /* populate the new stat */ @@ -179,12 +179,12 @@ static void connectedVertexWalker_visitVertex(BMWalker *walker, BMVert *v) /* already visited */ return; } - if (walker->mask_vert && !BMO_TestFlag(walker->bm, v, walker->mask_vert)) { + if (walker->mask_vert && !BMO_elem_flag_test(walker->bm, v, walker->mask_vert)) { /* not flagged for walk */ return; } - vwalk = BMW_addstate(walker); + vwalk = BMW_state_add(walker); vwalk->curvert = v; BLI_ghash_insert(walker->visithash, v, NULL); } @@ -197,23 +197,23 @@ static void connectedVertexWalker_begin(BMWalker *walker, void *data) static void *connectedVertexWalker_yield(BMWalker *walker) { - connectedVertexWalker *vwalk = BMW_currentstate(walker); + connectedVertexWalker *vwalk = BMW_current_state(walker); return vwalk->curvert; } static void *connectedVertexWalker_step(BMWalker *walker) { - connectedVertexWalker *vwalk = BMW_currentstate(walker); + connectedVertexWalker *vwalk = BMW_current_state(walker); BMVert *v, *v2; BMEdge *e; BMIter iter; v = vwalk->curvert; - BMW_removestate(walker); + BMW_state_remove(walker); BM_ITER(e, &iter, walker->bm, BM_EDGES_OF_VERT, v) { - v2 = BM_OtherEdgeVert(e, v); + v2 = BM_edge_other_vert(e, v); if (!BLI_ghash_haskey(walker->visithash, v2)) { connectedVertexWalker_visitVertex(walker, v2); } @@ -238,7 +238,7 @@ static void islandboundWalker_begin(BMWalker *walker, void *data) BMLoop *l = data; islandboundWalker *iwalk = NULL; - iwalk = BMW_addstate(walker); + iwalk = BMW_state_add(walker); iwalk->base = iwalk->curloop = l; iwalk->lastv = l->v; @@ -249,14 +249,14 @@ static void islandboundWalker_begin(BMWalker *walker, void *data) static void *islandboundWalker_yield(BMWalker *walker) { - islandboundWalker *iwalk = BMW_currentstate(walker); + islandboundWalker *iwalk = BMW_current_state(walker); return iwalk->curloop; } static void *islandboundWalker_step(BMWalker *walker) { - islandboundWalker *iwalk = BMW_currentstate(walker), owalk; + islandboundWalker *iwalk = BMW_current_state(walker), owalk; BMVert *v; BMEdge *e = iwalk->curloop->e; BMFace *f; @@ -268,26 +268,26 @@ static void *islandboundWalker_step(BMWalker *walker) if (iwalk->lastv == e->v1) v = e->v2; else v = e->v1; - if (BM_Nonmanifold_Vert(walker->bm, v)) { + if (BM_vert_is_nonmanifold(walker->bm, v)) { BMW_reset(walker); - BMO_RaiseError(walker->bm, NULL, BMERR_WALKER_FAILED, + BMO_error_raise(walker->bm, NULL, BMERR_WALKER_FAILED, "Non-manifold vert " "while searching region boundary"); return NULL; } /* pop off current stat */ - BMW_removestate(walker); + BMW_state_remove(walker); f = l->f; while (1) { - l = BM_OtherFaceLoop(e, f, v); + l = BM_face_other_loop(e, f, v); if (bmesh_radial_nextloop(l) != l) { l = bmesh_radial_nextloop(l); f = l->f; e = l->e; - if (walker->mask_face && !BMO_TestFlag(walker->bm, f, walker->mask_face)) { + if (walker->mask_face && !BMO_elem_flag_test(walker->bm, f, walker->mask_face)) { l = l->radial_next; break; } @@ -307,10 +307,10 @@ static void *islandboundWalker_step(BMWalker *walker) } BLI_ghash_insert(walker->visithash, l, NULL); - iwalk = BMW_addstate(walker); + iwalk = BMW_state_add(walker); iwalk->base = owalk.base; - //if (!BMO_TestFlag(walker->bm, l->f, walker->restrictflag)) + //if (!BMO_elem_flag_test(walker->bm, l->f, walker->restrictflag)) // iwalk->curloop = l->radial_next; iwalk->curloop = l; //else iwalk->curloop = l; iwalk->lastv = v; @@ -333,11 +333,11 @@ static void islandWalker_begin(BMWalker *walker, void *data) { islandWalker *iwalk = NULL; - if (walker->mask_face && !BMO_TestFlag(walker->bm, data, walker->mask_face)) { + if (walker->mask_face && !BMO_elem_flag_test(walker->bm, data, walker->mask_face)) { return; } - iwalk = BMW_addstate(walker); + iwalk = BMW_state_add(walker); BLI_ghash_insert(walker->visithash, data, NULL); iwalk->cur = data; @@ -345,36 +345,36 @@ static void islandWalker_begin(BMWalker *walker, void *data) static void *islandWalker_yield(BMWalker *walker) { - islandWalker *iwalk = BMW_currentstate(walker); + islandWalker *iwalk = BMW_current_state(walker); return iwalk->cur; } static void *islandWalker_step(BMWalker *walker) { - islandWalker *iwalk = BMW_currentstate(walker); + islandWalker *iwalk = BMW_current_state(walker); /* islandWalker *owalk = iwalk; */ /* UNUSED */ BMIter iter, liter; BMFace *f, *curf = iwalk->cur; BMLoop *l; - BMW_removestate(walker); + BMW_state_remove(walker); - l = BMIter_New(&liter, walker->bm, BM_LOOPS_OF_FACE, iwalk->cur); - for ( ; l; l = BMIter_Step(&liter)) { + l = BM_iter_new(&liter, walker->bm, BM_LOOPS_OF_FACE, iwalk->cur); + for ( ; l; l = BM_iter_step(&liter)) { /* could skip loop here too, but dont add unless we need it */ - if (walker->mask_edge && !BMO_TestFlag(walker->bm, l->e, walker->mask_edge)) { + if (walker->mask_edge && !BMO_elem_flag_test(walker->bm, l->e, walker->mask_edge)) { continue; } - f = BMIter_New(&iter, walker->bm, BM_FACES_OF_EDGE, l->e); - for ( ; f; f = BMIter_Step(&iter)) { - if (walker->mask_face && !BMO_TestFlag(walker->bm, f, walker->mask_face)) { + f = BM_iter_new(&iter, walker->bm, BM_FACES_OF_EDGE, l->e); + for ( ; f; f = BM_iter_step(&iter)) { + if (walker->mask_face && !BMO_elem_flag_test(walker->bm, f, walker->mask_face)) { continue; } if (BLI_ghash_haskey(walker->visithash, f)) continue; - iwalk = BMW_addstate(walker); + iwalk = BMW_state_add(walker); iwalk->cur = f; BLI_ghash_insert(walker->visithash, f, NULL); break; @@ -400,23 +400,23 @@ static void loopWalker_begin(BMWalker *walker, void *data) v = e->v1; - /* val = BM_Vert_EdgeCount(v); */ /* UNUSED */ + /* val = BM_vert_edge_count(v); */ /* UNUSED */ - lwalk = BMW_addstate(walker); + lwalk = BMW_state_add(walker); BLI_ghash_insert(walker->visithash, e, NULL); lwalk->cur = lwalk->start = e; lwalk->lastv = lwalk->startv = v; lwalk->stage2 = 0; - lwalk->startrad = BM_Edge_FaceCount(e); + lwalk->startrad = BM_edge_face_count(e); /* rewin */ - while (BMW_currentstate(walker)) { - owalk = *((loopWalker *)BMW_currentstate(walker)); + while (BMW_current_state(walker)) { + owalk = *((loopWalker *)BMW_current_state(walker)); BMW_walk(walker); } - lwalk = BMW_addstate(walker); + lwalk = BMW_state_add(walker); *lwalk = owalk; if (lwalk->lastv == owalk.cur->v1) lwalk->lastv = owalk.cur->v2; @@ -431,14 +431,14 @@ static void loopWalker_begin(BMWalker *walker, void *data) static void *loopWalker_yield(BMWalker *walker) { - loopWalker *lwalk = BMW_currentstate(walker); + loopWalker *lwalk = BMW_current_state(walker); return lwalk->cur; } static void *loopWalker_step(BMWalker *walker) { - loopWalker *lwalk = BMW_currentstate(walker), owalk; + loopWalker *lwalk = BMW_current_state(walker), owalk; BMIter eiter; BMEdge *e = lwalk->cur, *nexte = NULL; BMLoop *l, *l2; @@ -446,7 +446,7 @@ static void *loopWalker_step(BMWalker *walker) int val, rlen /* , found = 0 */, i = 0, stopi; owalk = *lwalk; - BMW_removestate(walker); + BMW_state_remove(walker); l = e->l; @@ -459,7 +459,7 @@ static void *loopWalker_step(BMWalker *walker) BM_ITER(nexte, &eiter, walker->bm, BM_EDGES_OF_VERT, v) { if ((nexte->l == NULL) && !BLI_ghash_haskey(walker->visithash, nexte)) { - lwalk = BMW_addstate(walker); + lwalk = BMW_state_add(walker); lwalk->cur = nexte; lwalk->lastv = v; lwalk->startrad = owalk.startrad; @@ -474,7 +474,7 @@ static void *loopWalker_step(BMWalker *walker) v = (e->v1 == lwalk->lastv) ? e->v2 : e->v1; - val = BM_Vert_EdgeCount(v); + val = BM_vert_edge_count(v); rlen = owalk.startrad; @@ -484,7 +484,7 @@ static void *loopWalker_step(BMWalker *walker) while (1) { if (rlen != 1 && i == stopi) break; - l = BM_OtherFaceLoop(l->e, l->f, v); + l = BM_face_other_loop(l->e, l->f, v); if (!l) break; @@ -506,7 +506,7 @@ static void *loopWalker_step(BMWalker *walker) if (l != e->l && !BLI_ghash_haskey(walker->visithash, l->e)) { if (!(rlen != 1 && i != stopi)) { - lwalk = BMW_addstate(walker); + lwalk = BMW_state_add(walker); lwalk->cur = l->e; lwalk->lastv = v; lwalk->startrad = owalk.startrad; @@ -548,20 +548,20 @@ static int faceloopWalker_edge_begins_loop(BMWalker *walker, BMEdge *e) BMesh *bm = walker->bm; /* There is no face loop starting from a wire edge */ - if (BM_Wire_Edge(bm, e)) { + if (BM_edge_is_wire(bm, e)) { return FALSE; } /* Don't start a loop from a boundary edge if it cannot * be extended to cover any faces */ - if (BM_Edge_FaceCount(e) == 1) { + if (BM_edge_face_count(e) == 1) { if (!faceloopWalker_include_face(walker, e->l)) { return FALSE; } } /* Don't start a face loop from non-manifold edges */ - if (BM_Nonmanifold_Edge(bm, e)) { + if (BM_edge_is_nonmanifold(bm, e)) { return FALSE; } @@ -573,23 +573,23 @@ static void faceloopWalker_begin(BMWalker *walker, void *data) faceloopWalker *lwalk, owalk; BMEdge *e = data; /* BMesh *bm = walker->bm; */ /* UNUSED */ - /* int fcount = BM_Edge_FaceCount(e); */ /* UNUSED */ + /* int fcount = BM_edge_face_count(e); */ /* UNUSED */ if (!faceloopWalker_edge_begins_loop(walker, e)) return; - lwalk = BMW_addstate(walker); + lwalk = BMW_state_add(walker); lwalk->l = e->l; lwalk->nocalc = 0; BLI_ghash_insert(walker->visithash, lwalk->l->f, NULL); /* rewin */ - while (BMW_currentstate(walker)) { - owalk = *((faceloopWalker *)BMW_currentstate(walker)); + while (BMW_current_state(walker)) { + owalk = *((faceloopWalker *)BMW_current_state(walker)); BMW_walk(walker); } - lwalk = BMW_addstate(walker); + lwalk = BMW_state_add(walker); *lwalk = owalk; lwalk->nocalc = 0; @@ -600,7 +600,7 @@ static void faceloopWalker_begin(BMWalker *walker, void *data) static void *faceloopWalker_yield(BMWalker *walker) { - faceloopWalker *lwalk = BMW_currentstate(walker); + faceloopWalker *lwalk = BMW_current_state(walker); if (!lwalk) { return NULL; @@ -611,11 +611,11 @@ static void *faceloopWalker_yield(BMWalker *walker) static void *faceloopWalker_step(BMWalker *walker) { - faceloopWalker *lwalk = BMW_currentstate(walker); + faceloopWalker *lwalk = BMW_current_state(walker); BMFace *f = lwalk->l->f; BMLoop *l = lwalk->l, *origl = lwalk->l; - BMW_removestate(walker); + BMW_state_remove(walker); l = l->radial_next; @@ -625,14 +625,14 @@ static void *faceloopWalker_step(BMWalker *walker) if (!faceloopWalker_include_face(walker, l)) { l = lwalk->l; l = l->next->next; - if (BM_Edge_FaceCount(l->e) != 2) { + if (BM_edge_face_count(l->e) != 2) { l = l->prev->prev; } l = l->radial_next; } if (faceloopWalker_include_face(walker, l)) { - lwalk = BMW_addstate(walker); + lwalk = BMW_state_add(walker); lwalk->l = l; if (l->f->len != 4) { @@ -662,7 +662,7 @@ static void edgeringWalker_begin(BMWalker *walker, void *data) edgeringWalker *lwalk, owalk; BMEdge *e = data; - lwalk = BMW_addstate(walker); + lwalk = BMW_state_add(walker); lwalk->l = e->l; if (!lwalk->l) { @@ -676,12 +676,12 @@ static void edgeringWalker_begin(BMWalker *walker, void *data) BLI_ghash_insert(walker->visithash, lwalk->l->e, NULL); /* rewin */ - while (BMW_currentstate(walker)) { - owalk = *((edgeringWalker *)BMW_currentstate(walker)); + while (BMW_current_state(walker)) { + owalk = *((edgeringWalker *)BMW_current_state(walker)); BMW_walk(walker); } - lwalk = BMW_addstate(walker); + lwalk = BMW_state_add(walker); *lwalk = owalk; if (lwalk->l->f->len != 4) @@ -694,7 +694,7 @@ static void edgeringWalker_begin(BMWalker *walker, void *data) static void *edgeringWalker_yield(BMWalker *walker) { - edgeringWalker *lwalk = BMW_currentstate(walker); + edgeringWalker *lwalk = BMW_current_state(walker); if (!lwalk) { return NULL; @@ -708,18 +708,18 @@ static void *edgeringWalker_yield(BMWalker *walker) static void *edgeringWalker_step(BMWalker *walker) { - edgeringWalker *lwalk = BMW_currentstate(walker); + edgeringWalker *lwalk = BMW_current_state(walker); BMEdge *e; BMLoop *l = lwalk->l /* , *origl = lwalk->l */; BMesh *bm = walker->bm; - BMW_removestate(walker); + BMW_state_remove(walker); if (!l) return lwalk->wireedge; e = l->e; - if (BM_Nonmanifold_Edge(bm, e)) { + if (BM_edge_is_nonmanifold(bm, e)) { /* walker won't traverse to a non-manifold edge, but may * be started on one, and should not traverse *away* from * a non-manfold edge (non-manifold edges are never in an @@ -730,14 +730,14 @@ static void *edgeringWalker_step(BMWalker *walker) l = l->radial_next; l = l->next->next; - if ((l->f->len != 4) || BM_Nonmanifold_Edge(bm, l->e)) { + if ((l->f->len != 4) || BM_edge_is_nonmanifold(bm, l->e)) { l = lwalk->l->next->next; } /* only walk to manifold edge */ - if ((l->f->len == 4) && !BM_Nonmanifold_Edge(bm, l->e) && + if ((l->f->len == 4) && !BM_edge_is_nonmanifold(bm, l->e) && !BLI_ghash_haskey(walker->visithash, l->e)) { - lwalk = BMW_addstate(walker); + lwalk = BMW_state_add(walker); lwalk->l = l; lwalk->wireedge = NULL; @@ -755,14 +755,14 @@ static void uvedgeWalker_begin(BMWalker *walker, void *data) if (BLI_ghash_haskey(walker->visithash, l)) return; - lwalk = BMW_addstate(walker); + lwalk = BMW_state_add(walker); lwalk->l = l; BLI_ghash_insert(walker->visithash, l, NULL); } static void *uvedgeWalker_yield(BMWalker *walker) { - uvedgeWalker *lwalk = BMW_currentstate(walker); + uvedgeWalker *lwalk = BMW_current_state(walker); if (!lwalk) { return NULL; @@ -773,7 +773,7 @@ static void *uvedgeWalker_yield(BMWalker *walker) static void *uvedgeWalker_step(BMWalker *walker) { - uvedgeWalker *lwalk = BMW_currentstate(walker); + uvedgeWalker *lwalk = BMW_current_state(walker); BMLoop *l, *l2, *l3, *nl, *cl; BMIter liter; void *d1, *d2; @@ -783,9 +783,9 @@ static void *uvedgeWalker_step(BMWalker *walker) nl = l->next; type = walker->bm->ldata.layers[walker->layer].type; - BMW_removestate(walker); + BMW_state_remove(walker); - if (walker->mask_edge && !BMO_TestFlag(walker->bm, l->e, walker->mask_edge)) + if (walker->mask_edge && !BMO_elem_flag_test(walker->bm, l->e, walker->mask_edge)) return l; /* go over loops around l->v and nl->v and see which ones share l and nl's @@ -796,11 +796,11 @@ static void *uvedgeWalker_step(BMWalker *walker) d1 = CustomData_bmesh_get_layer_n(&walker->bm->ldata, cl->head.data, walker->layer); - rlen = BM_Edge_FaceCount(l2->e); + rlen = BM_edge_face_count(l2->e); for (j = 0; j < rlen; j++) { if (BLI_ghash_haskey(walker->visithash, l2)) continue; - if (walker->mask_edge && !(BMO_TestFlag(walker->bm, l2->e, walker->mask_edge))) + if (walker->mask_edge && !(BMO_elem_flag_test(walker->bm, l2->e, walker->mask_edge))) { if (l2->v != cl->v) continue; @@ -813,7 +813,7 @@ static void *uvedgeWalker_step(BMWalker *walker) if (!CustomData_data_equals(type, d1, d2)) continue; - lwalk = BMW_addstate(walker); + lwalk = BMW_state_add(walker); BLI_ghash_insert(walker->visithash, l2, NULL); lwalk->l = l2; diff --git a/source/blender/bmesh/operators/bevel.c b/source/blender/bmesh/operators/bevel.c index 173fba15ee8..928fd6b2fe8 100644 --- a/source/blender/bmesh/operators/bevel.c +++ b/source/blender/bmesh/operators/bevel.c @@ -76,7 +76,7 @@ static void calc_corner_co(BMesh *bm, BMLoop *l, const float fac, float r_co[3], BM_ITER(l2, &iter, bm, BM_LOOPS_OF_VERT, l->v) { if (l2->f != l->f) { - copy_v3_v3(l_co_next, BM_OtherEdgeVert(l2->e, l2->next->v)->co); + copy_v3_v3(l_co_next, BM_edge_other_vert(l2->e, l2->next->v)->co); break; } } @@ -147,14 +147,14 @@ static void calc_corner_co(BMesh *bm, BMLoop *l, const float fac, float r_co[3], #define ETAG_SET(e, v, nv) ( \ (v) == (e)->v1 ? \ - (etags[BM_GetIndex((e))].newv1 = (nv)) : \ - (etags[BM_GetIndex((e))].newv2 = (nv)) \ + (etags[BM_elem_index_get((e))].newv1 = (nv)) : \ + (etags[BM_elem_index_get((e))].newv2 = (nv)) \ ) #define ETAG_GET(e, v) ( \ (v) == (e)->v1 ? \ - (etags[BM_GetIndex((e))].newv1) : \ - (etags[BM_GetIndex((e))].newv2) \ + (etags[BM_elem_index_get((e))].newv1) : \ + (etags[BM_elem_index_get((e))].newv2) \ ) void bmesh_bevel_exec(BMesh *bm, BMOperator *op) @@ -174,83 +174,83 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) BLI_array_declare(verts); BLI_array_declare(edges); SmallHash hash; - float fac = BMO_Get_Float(op, "percent"); - const short do_even = BMO_Get_Int(op, "use_even"); - const short do_dist = BMO_Get_Int(op, "use_dist"); + float fac = BMO_slot_float_get(op, "percent"); + const short do_even = BMO_slot_int_get(op, "use_even"); + const short do_dist = BMO_slot_int_get(op, "use_dist"); int i, li, has_elens, HasMDisps = CustomData_has_layer(&bm->ldata, CD_MDISPS); - has_elens = CustomData_has_layer(&bm->edata, CD_PROP_FLT) && BMO_Get_Int(op, "use_lengths"); + has_elens = CustomData_has_layer(&bm->edata, CD_PROP_FLT) && BMO_slot_int_get(op, "use_lengths"); if (has_elens) { - li = BMO_Get_Int(op, "lengthlayer"); + li = BMO_slot_int_get(op, "lengthlayer"); } BLI_smallhash_init(&hash); BMO_ITER(e, &siter, bm, op, "geom", BM_EDGE) { - BMO_SetFlag(bm, e, BEVEL_FLAG|BEVEL_DEL); - BMO_SetFlag(bm, e->v1, BEVEL_FLAG|BEVEL_DEL); - BMO_SetFlag(bm, e->v2, BEVEL_FLAG|BEVEL_DEL); + BMO_elem_flag_set(bm, e, BEVEL_FLAG|BEVEL_DEL); + BMO_elem_flag_set(bm, e->v1, BEVEL_FLAG|BEVEL_DEL); + BMO_elem_flag_set(bm, e->v2, BEVEL_FLAG|BEVEL_DEL); - if (BM_Edge_FaceCount(e) < 2) { - BMO_ClearFlag(bm, e, BEVEL_DEL); - BMO_ClearFlag(bm, e->v1, BEVEL_DEL); - BMO_ClearFlag(bm, e->v2, BEVEL_DEL); + if (BM_edge_face_count(e) < 2) { + BMO_elem_flag_clear(bm, e, BEVEL_DEL); + BMO_elem_flag_clear(bm, e->v1, BEVEL_DEL); + BMO_elem_flag_clear(bm, e->v2, BEVEL_DEL); } #if 0 - if (BM_Edge_FaceCount(e) == 0) { + if (BM_edge_face_count(e) == 0) { BMVert *verts[2] = {e->v1, e->v2}; - BMEdge *edges[2] = {e, BM_Make_Edge(bm, e->v1, e->v2, e, 0)}; + BMEdge *edges[2] = {e, BM_edge_create(bm, e->v1, e->v2, e, 0)}; - BMO_SetFlag(bm, edges[1], BEVEL_FLAG); - BM_Make_Face(bm, verts, edges, 2, FALSE); + BMO_elem_flag_set(bm, edges[1], BEVEL_FLAG); + BM_face_create(bm, verts, edges, 2, FALSE); } #endif } BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) { - BMO_SetFlag(bm, v, VERT_OLD); + BMO_elem_flag_set(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) { - if (BMO_TestFlag(bm, e->v1, BEVEL_FLAG) || BMO_TestFlag(bm, e->v2, BEVEL_FLAG)) { + if (BMO_elem_flag_test(bm, e->v1, BEVEL_FLAG) || BMO_elem_flag_test(bm, e->v2, BEVEL_FLAG)) { BMIter liter; BMLoop *l; - if (!BMO_TestFlag(bm, e, EDGE_OLD)) { - BM_SetIndex(e, BLI_array_count(etags)); /* set_dirty! */ + if (!BMO_elem_flag_test(bm, e, EDGE_OLD)) { + BM_elem_index_set(e, BLI_array_count(etags)); /* set_dirty! */ BLI_array_growone(etags); - BMO_SetFlag(bm, e, EDGE_OLD); + BMO_elem_flag_set(bm, e, EDGE_OLD); } BM_ITER(l, &liter, bm, BM_LOOPS_OF_EDGE, e) { BMLoop *l2; BMIter liter2; - if (BMO_TestFlag(bm, l->f, BEVEL_FLAG)) + if (BMO_elem_flag_test(bm, l->f, BEVEL_FLAG)) continue; BM_ITER(l2, &liter2, bm, BM_LOOPS_OF_FACE, l->f) { - BM_SetIndex(l2, BLI_array_count(tags)); /* set_loop */ + BM_elem_index_set(l2, BLI_array_count(tags)); /* set_loop */ BLI_array_growone(tags); - if (!BMO_TestFlag(bm, l2->e, EDGE_OLD)) { - BM_SetIndex(l2->e, BLI_array_count(etags)); /* set_dirty! */ + if (!BMO_elem_flag_test(bm, l2->e, EDGE_OLD)) { + BM_elem_index_set(l2->e, BLI_array_count(etags)); /* set_dirty! */ BLI_array_growone(etags); - BMO_SetFlag(bm, l2->e, EDGE_OLD); + BMO_elem_flag_set(bm, l2->e, EDGE_OLD); } } - BMO_SetFlag(bm, l->f, BEVEL_FLAG); + BMO_elem_flag_set(bm, l->f, BEVEL_FLAG); BLI_array_append(faces, l->f); } } else { - BM_SetIndex(e, -1); /* set_dirty! */ + BM_elem_index_set(e, -1); /* set_dirty! */ } } #endif @@ -260,20 +260,20 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) BMLoop *l; BMIter liter; - BMO_SetFlag(bm, e->v1, BEVEL_FLAG|BEVEL_DEL); - BMO_SetFlag(bm, e->v2, BEVEL_FLAG|BEVEL_DEL); + BMO_elem_flag_set(bm, e->v1, BEVEL_FLAG|BEVEL_DEL); + BMO_elem_flag_set(bm, e->v2, BEVEL_FLAG|BEVEL_DEL); - if (BM_Edge_FaceCount(e) < 2) { - BMO_ClearFlag(bm, e, BEVEL_DEL); - BMO_ClearFlag(bm, e->v1, BEVEL_DEL); - BMO_ClearFlag(bm, e->v2, BEVEL_DEL); + if (BM_edge_face_count(e) < 2) { + BMO_elem_flag_clear(bm, e, BEVEL_DEL); + BMO_elem_flag_clear(bm, e->v1, BEVEL_DEL); + BMO_elem_flag_clear(bm, e->v2, BEVEL_DEL); } if (!BLI_smallhash_haskey(&hash, (intptr_t)e)) { BLI_array_growone(etags); - BM_SetIndex(e, BLI_array_count(etags) - 1); /* set_dirty! */ + BM_elem_index_set(e, BLI_array_count(etags) - 1); /* set_dirty! */ BLI_smallhash_insert(&hash, (intptr_t)e, NULL); - BMO_SetFlag(bm, e, EDGE_OLD); + BMO_elem_flag_set(bm, e, EDGE_OLD); } /* find all faces surrounding e->v1 and, e->v2 */ @@ -289,18 +289,18 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) /* create tags for all loops in l-> */ BM_ITER(l2, &liter2, bm, BM_LOOPS_OF_FACE, l->f) { BLI_array_growone(tags); - BM_SetIndex(l2, BLI_array_count(tags) - 1); /* set_loop */ + BM_elem_index_set(l2, BLI_array_count(tags) - 1); /* set_loop */ if (!BLI_smallhash_haskey(&hash, (intptr_t)l2->e)) { BLI_array_growone(etags); - BM_SetIndex(l2->e, BLI_array_count(etags) - 1); /* set_dirty! */ + BM_elem_index_set(l2->e, BLI_array_count(etags) - 1); /* set_dirty! */ BLI_smallhash_insert(&hash, (intptr_t)l2->e, NULL); - BMO_SetFlag(bm, l2->e, EDGE_OLD); + BMO_elem_flag_set(bm, l2->e, EDGE_OLD); } } BLI_smallhash_insert(&hash, (intptr_t)l->f, NULL); - BMO_SetFlag(bm, l->f, BEVEL_FLAG); + BMO_elem_flag_set(bm, l->f, BEVEL_FLAG); BLI_array_append(faces, l->f); } } @@ -311,15 +311,15 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) { BMIter eiter; - if (!BMO_TestFlag(bm, v, BEVEL_FLAG)) + if (!BMO_elem_flag_test(bm, v, BEVEL_FLAG)) continue; BM_ITER(e, &eiter, bm, BM_EDGES_OF_VERT, v) { - if (!BMO_TestFlag(bm, e, BEVEL_FLAG) && !ETAG_GET(e, v)) { + if (!BMO_elem_flag_test(bm, e, BEVEL_FLAG) && !ETAG_GET(e, v)) { BMVert *v2; float co[3]; - v2 = BM_OtherEdgeVert(e, v); + v2 = BM_edge_other_vert(e, v); sub_v3_v3v3(co, v2->co, v->co); if (has_elens) { float elen = *(float *)CustomData_bmesh_get_n(&bm->edata, e->head.data, CD_PROP_FLT, li); @@ -331,7 +331,7 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) mul_v3_fl(co, fac); add_v3_v3(co, v->co); - v2 = BM_Make_Vert(bm, co, v); + v2 = BM_vert_create(bm, co, v); ETAG_SET(e, v, v2); } } @@ -341,20 +341,20 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) BMLoop *l; BMIter liter; - BMO_SetFlag(bm, faces[i], FACE_OLD); + BMO_elem_flag_set(bm, faces[i], FACE_OLD); BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, faces[i]) { float co[3]; - if (BMO_TestFlag(bm, l->e, BEVEL_FLAG)) { - if (BMO_TestFlag(bm, l->prev->e, BEVEL_FLAG)) + if (BMO_elem_flag_test(bm, l->e, BEVEL_FLAG)) { + if (BMO_elem_flag_test(bm, l->prev->e, BEVEL_FLAG)) { - tag = tags + BM_GetIndex(l); + tag = tags + BM_elem_index_get(l); calc_corner_co(bm, l, fac, co, do_dist, do_even); - tag->newv = BM_Make_Vert(bm, co, l->v); + tag->newv = BM_vert_create(bm, co, l->v); } else { - tag = tags + BM_GetIndex(l); + tag = tags + BM_elem_index_get(l); tag->newv = ETAG_GET(l->prev->e, l->v); if (!tag->newv) { @@ -369,14 +369,14 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) mul_v3_fl(co, fac); add_v3_v3(co, l->v->co); - tag->newv = BM_Make_Vert(bm, co, l->v); + tag->newv = BM_vert_create(bm, co, l->v); ETAG_SET(l->prev->e, l->v, tag->newv); } } } - else if (BMO_TestFlag(bm, l->v, BEVEL_FLAG)) { - tag = tags + BM_GetIndex(l); + else if (BMO_elem_flag_test(bm, l->v, BEVEL_FLAG)) { + tag = tags + BM_elem_index_get(l); tag->newv = ETAG_GET(l->e, l->v); if (!tag->newv) { @@ -391,16 +391,16 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) mul_v3_fl(co, fac); add_v3_v3(co, l->v->co); - tag = tags + BM_GetIndex(l); - tag->newv = BM_Make_Vert(bm, co, l->v); + tag = tags + BM_elem_index_get(l); + tag->newv = BM_vert_create(bm, co, l->v); ETAG_SET(l->e, l->v, tag->newv); } } else { - tag = tags + BM_GetIndex(l); + tag = tags + BM_elem_index_get(l); tag->newv = l->v; - BMO_ClearFlag(bm, l->v, BEVEL_DEL); + BMO_elem_flag_clear(bm, l->v, BEVEL_DEL); } } } @@ -412,7 +412,7 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) BMFace *f; BMVert *lastv = NULL, *firstv = NULL; - BMO_SetFlag(bm, faces[i], BEVEL_DEL); + BMO_elem_flag_set(bm, faces[i], BEVEL_DEL); BLI_array_empty(verts); BLI_array_empty(edges); @@ -420,46 +420,46 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, faces[i]) { BMVert *v2; - tag = tags + BM_GetIndex(l); + tag = tags + BM_elem_index_get(l); BLI_array_append(verts, tag->newv); if (!firstv) firstv = tag->newv; if (lastv) { - e = BM_Make_Edge(bm, lastv, tag->newv, l->e, TRUE); - BM_Copy_Attributes(bm, bm, l->prev->e, e); + e = BM_edge_create(bm, lastv, tag->newv, l->e, TRUE); + BM_elem_copy_attrs(bm, bm, l->prev->e, e); BLI_array_append(edges, e); } lastv = tag->newv; v2 = ETAG_GET(l->e, l->next->v); - tag = tags + BM_GetIndex(l->next); - if (!BMO_TestFlag(bm, l->e, BEVEL_FLAG) && v2 && v2 != tag->newv) { + tag = tags + BM_elem_index_get(l->next); + if (!BMO_elem_flag_test(bm, l->e, BEVEL_FLAG) && v2 && v2 != tag->newv) { BLI_array_append(verts, v2); - e = BM_Make_Edge(bm, lastv, v2, l->e, TRUE); - BM_Copy_Attributes(bm, bm, l->e, e); + e = BM_edge_create(bm, lastv, v2, l->e, TRUE); + BM_elem_copy_attrs(bm, bm, l->e, e); BLI_array_append(edges, e); lastv = v2; } } - e = BM_Make_Edge(bm, firstv, lastv, BM_FACE_FIRST_LOOP(faces[i])->e, TRUE); + e = BM_edge_create(bm, firstv, lastv, BM_FACE_FIRST_LOOP(faces[i])->e, TRUE); if (BM_FACE_FIRST_LOOP(faces[i])->prev->e != e) { - BM_Copy_Attributes(bm, bm, BM_FACE_FIRST_LOOP(faces[i])->prev->e, e); + BM_elem_copy_attrs(bm, bm, BM_FACE_FIRST_LOOP(faces[i])->prev->e, e); } BLI_array_append(edges, e); - f = BM_Make_Ngon(bm, verts[0], verts[1], edges, BLI_array_count(edges), FALSE); + f = BM_face_create_ngon(bm, verts[0], verts[1], edges, BLI_array_count(edges), FALSE); if (!f) { printf("%s: could not make face!\n", __func__); continue; } - BMO_SetFlag(bm, f, FACE_NEW); + BMO_elem_flag_set(bm, f, FACE_NEW); } for (i = 0; i < BLI_array_count(faces); i++) { @@ -471,19 +471,19 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, faces[i]) { BMVert *v1 = NULL, *v2 = NULL, *v3 = NULL, *v4 = NULL; - if (!BMO_TestFlag(bm, l->e, BEVEL_FLAG)) + if (!BMO_elem_flag_test(bm, l->e, BEVEL_FLAG)) continue; - v1 = tags[BM_GetIndex(l)].newv; - v2 = tags[BM_GetIndex(l->next)].newv; + v1 = tags[BM_elem_index_get(l)].newv; + v2 = tags[BM_elem_index_get(l->next)].newv; if (l->radial_next != l) { - v3 = tags[BM_GetIndex(l->radial_next)].newv; + v3 = tags[BM_elem_index_get(l->radial_next)].newv; if (l->radial_next->next->v == l->next->v) { v4 = v3; - v3 = tags[BM_GetIndex(l->radial_next->next)].newv; + v3 = tags[BM_elem_index_get(l->radial_next->next)].newv; } else { - v4 = tags[BM_GetIndex(l->radial_next->next)].newv; + v4 = tags[BM_elem_index_get(l->radial_next->next)].newv; } } else { @@ -496,14 +496,14 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) BMVert *v = j ? v4 : v3; BM_ITER(e, &eiter, bm, BM_EDGES_OF_VERT, v) { - if (!BM_Vert_In_Edge(e, v3) || !BM_Vert_In_Edge(e, v4)) + if (!BM_vert_in_edge(e, v3) || !BM_vert_in_edge(e, v4)) continue; - if (!BMO_TestFlag(bm, e, BEVEL_FLAG) && BMO_TestFlag(bm, e, EDGE_OLD)) { + if (!BMO_elem_flag_test(bm, e, BEVEL_FLAG) && BMO_elem_flag_test(bm, e, EDGE_OLD)) { BMVert *vv; vv = ETAG_GET(e, v); - if (!vv || BMO_TestFlag(bm, vv, BEVEL_FLAG)) + if (!vv || BMO_elem_flag_test(bm, vv, BEVEL_FLAG)) continue; if (j) @@ -515,8 +515,8 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) } } - BMO_ClearFlag(bm, v3, BEVEL_DEL); - BMO_ClearFlag(bm, v4, BEVEL_DEL); + BMO_elem_flag_clear(bm, v3, BEVEL_DEL); + BMO_elem_flag_clear(bm, v4, BEVEL_DEL); } if (v1 != v2 && v2 != v3 && v3 != v4) { @@ -525,12 +525,12 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) BMEdge *e1, *e2; float d1, d2, *d3; - f = BM_Make_Face_QuadTri(bm, v4, v3, v2, v1, l->f, TRUE); + f = BM_face_create_quad_tri(bm, v4, v3, v2, v1, l->f, TRUE); - e1 = BM_Edge_Exist(v4, v3); - e2 = BM_Edge_Exist(v2, v1); - BM_Copy_Attributes(bm, bm, l->e, e1); - BM_Copy_Attributes(bm, bm, l->e, e2); + e1 = BM_edge_exists(v4, v3); + e2 = BM_edge_exists(v2, v1); + BM_elem_copy_attrs(bm, bm, l->e, e1); + BM_elem_copy_attrs(bm, bm, l->e, e2); /* set edge lengths of cross edges as the average of the cross edges they're based o */ if (has_elens) { @@ -539,8 +539,8 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) #if 0 float ang; #endif - e1 = BM_Edge_Exist(v1, v4); - e2 = BM_Edge_Exist(v2, v3); + e1 = BM_edge_exists(v1, v4); + e2 = BM_edge_exists(v2, v3); if (l->radial_next->v == l->v) { l2 = l->radial_next->prev; @@ -555,7 +555,7 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) d1 = *(float *)CustomData_bmesh_get_n(&bm->edata, l->prev->e->head.data, CD_PROP_FLT, li); d2 = *(float *)CustomData_bmesh_get_n(&bm->edata, l2->e->head.data, CD_PROP_FLT, li); #if 0 - ang = angle_v3v3v3(l->prev->v->co, l->v->co, BM_OtherEdgeVert(l2->e, l->v)->co); + ang = angle_v3v3v3(l->prev->v->co, l->v->co, BM_edge_other_vert(l2->e, l->v)->co); #endif *d3 = (d1 + d2) * 0.5f; @@ -563,8 +563,8 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) d1 = *(float *)CustomData_bmesh_get_n(&bm->edata, l->next->e->head.data, CD_PROP_FLT, li); d2 = *(float *)CustomData_bmesh_get_n(&bm->edata, l3->e->head.data, CD_PROP_FLT, li); #if 0 - ang = angle_v3v3v3(BM_OtherEdgeVert(l->next->e, l->next->v)->co, l->next->v->co, - BM_OtherEdgeVert(l3->e, l->next->v)->co); + ang = angle_v3v3v3(BM_edge_other_vert(l->next->e, l->next->v)->co, l->next->v->co, + BM_edge_other_vert(l3->e, l->next->v)->co); #endif *d3 = (d1 + d2) * 0.5f; } @@ -574,11 +574,11 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) continue; } - BMO_SetFlag(bm, f, FACE_NEW|FACE_SPAN); + BMO_elem_flag_set(bm, f, FACE_NEW|FACE_SPAN); /* un-tag edges in f for deletio */ BM_ITER(l2, &liter2, bm, BM_LOOPS_OF_FACE, f) { - BMO_ClearFlag(bm, l2->e, BEVEL_DEL); + BMO_elem_flag_clear(bm, l2->e, BEVEL_DEL); } } else { @@ -596,7 +596,7 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) BLI_smallhash_init(&tmphash); - if (!BMO_TestFlag(bm, v, BEVEL_FLAG)) + if (!BMO_elem_flag_test(bm, v, BEVEL_FLAG)) continue; BLI_array_empty(verts); @@ -607,20 +607,20 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) BMVert *v1 = NULL, *v2 = NULL; BMLoop *l; - if (BM_Edge_FaceCount(e) < 2) + if (BM_edge_face_count(e) < 2) insorig = 1; - if (BM_GetIndex(e) == -1) + if (BM_elem_index_get(e) == -1) continue; rad = 0; BM_ITER(l, &liter, bm, BM_LOOPS_OF_EDGE, e) { - if (!BMO_TestFlag(bm, l->f, FACE_OLD)) + if (!BMO_elem_flag_test(bm, l->f, FACE_OLD)) continue; rad++; - tag = tags + BM_GetIndex((l->v == v) ? l : l->next); + tag = tags + BM_elem_index_get((l->v == v) ? l : l->next); if (!v1) v1 = tag->newv; @@ -663,7 +663,7 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) vv = vstart; do { BM_ITER(e, &eiter, bm, BM_EDGES_OF_VERT, vv) { - BMVert *vv2 = BM_OtherEdgeVert(e, vv); + BMVert *vv2 = BM_edge_other_vert(e, vv); if (vv2 != lastv && BLI_smallhash_haskey(&tmphash, (intptr_t)vv2)) { /* if we've go over the same vert twice, break out of outer loop */ @@ -708,7 +708,7 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) BLI_array_empty(edges); do { BM_ITER(e, &eiter, bm, BM_EDGES_OF_VERT, vv) { - BMVert *vv2 = BM_OtherEdgeVert(e, vv); + BMVert *vv2 = BM_edge_other_vert(e, vv); if (vv2 != lastv && BLI_smallhash_haskey(&tmphash, (intptr_t)vv2)) { /* if we've go over the same vert twice, break out of outer loo */ @@ -733,7 +733,7 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) } while (vv != vstart); if (!err) { - e = BM_Make_Edge(bm, vv, vstart, NULL, TRUE); + e = BM_edge_create(bm, vv, vstart, NULL, TRUE); BLI_array_append(edges, e); } } @@ -744,15 +744,15 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) if (BLI_array_count(edges) >= 3) { BMFace *f; - if (BM_Face_Exists(bm, verts, BLI_array_count(verts), &f)) + if (BM_face_exists(bm, verts, BLI_array_count(verts), &f)) continue; - f = BM_Make_Ngon(bm, lastv, vstart, edges, BLI_array_count(edges), FALSE); + f = BM_face_create_ngon(bm, lastv, vstart, edges, BLI_array_count(edges), FALSE); if (!f) { fprintf(stderr, "%s: in bevel vert fill! (bmesh internal error)\n", __func__); } else { - BMO_SetFlag(bm, f, FACE_NEW|FACE_HOLE); + BMO_elem_flag_set(bm, f, FACE_NEW|FACE_HOLE); } } BLI_smallhash_release(&tmphash); @@ -768,21 +768,21 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) BMLoop *l2; BMIter liter2; - tag = tags + BM_GetIndex(l); + tag = tags + BM_elem_index_get(l); if (!tag->newv) continue; BM_ITER(l2, &liter2, bm, BM_LOOPS_OF_VERT, tag->newv) { - if (!BMO_TestFlag(bm, l2->f, FACE_NEW) || (l2->v != tag->newv && l2->v != l->v)) + if (!BMO_elem_flag_test(bm, l2->f, FACE_NEW) || (l2->v != tag->newv && l2->v != l->v)) continue; if (tag->newv != l->v || HasMDisps) { - BM_Copy_Attributes(bm, bm, l->f, l2->f); + BM_elem_copy_attrs(bm, bm, l->f, l2->f); BM_loop_interp_from_face(bm, l2, l->f, TRUE, TRUE); } else { - BM_Copy_Attributes(bm, bm, l->f, l2->f); - BM_Copy_Attributes(bm, bm, l, l2); + BM_elem_copy_attrs(bm, bm, l->f, l2->f); + BM_elem_copy_attrs(bm, bm, l, l2); } if (HasMDisps) { @@ -799,7 +799,7 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) /* handle vertices along boundary edge */ BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) { - if (BMO_TestFlag(bm, v, VERT_OLD) && BMO_TestFlag(bm, v, BEVEL_FLAG) && !BMO_TestFlag(bm, v, BEVEL_DEL)) { + 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)) { BMLoop *l; BMLoop *lorig = NULL; BMIter liter; @@ -808,7 +808,7 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) // BMIter liter2; // BMLoop *l2 = l->v == v ? l : l->next, *l3; - if (BMO_TestFlag(bm, l->f, FACE_OLD)) { + if (BMO_elem_flag_test(bm, l->f, FACE_OLD)) { lorig = l; break; } @@ -820,8 +820,8 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) BM_ITER(l, &liter, bm, BM_LOOPS_OF_VERT, v) { BMLoop *l2 = l->v == v ? l : l->next; - BM_Copy_Attributes(bm, bm, lorig->f, l2->f); - BM_Copy_Attributes(bm, bm, lorig, l2); + BM_elem_copy_attrs(bm, bm, lorig->f, l2->f); + BM_elem_copy_attrs(bm, bm, lorig, l2); } } } @@ -832,23 +832,23 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) BMFace *faces[2] = {f, BM_FACE_FIRST_LOOP(f)->radial_next->f}; if (faces[0] == faces[1]) - BM_Kill_Face(bm, f); + BM_face_kill(bm, f); else - BM_Join_Faces(bm, faces, 2); + BM_faces_join(bm, faces, 2); } } #endif - BMO_CallOpf(bm, "del geom=%fv context=%i", BEVEL_DEL, DEL_VERTS); + 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) { - if (BMO_TestFlag(bm, e, EDGE_OLD) && !e->l) - BMO_SetFlag(bm, e, BEVEL_DEL); + if (BMO_elem_flag_test(bm, e, EDGE_OLD) && !e->l) + BMO_elem_flag_set(bm, e, BEVEL_DEL); } - BMO_CallOpf(bm, "del geom=%fe context=%i", BEVEL_DEL, DEL_EDGES); - BMO_CallOpf(bm, "del geom=%ff context=%i", BEVEL_DEL, DEL_FACES); + BMO_op_callf(bm, "del geom=%fe context=%i", BEVEL_DEL, DEL_EDGES); + BMO_op_callf(bm, "del geom=%ff context=%i", BEVEL_DEL, DEL_FACES); BLI_smallhash_release(&hash); BLI_array_free(tags); @@ -857,6 +857,6 @@ void bmesh_bevel_exec(BMesh *bm, BMOperator *op) BLI_array_free(edges); BLI_array_free(faces); - BMO_Flag_To_Slot(bm, op, "face_spans", FACE_SPAN, BM_FACE); - BMO_Flag_To_Slot(bm, op, "face_holes", FACE_HOLE, BM_FACE); + BMO_slot_from_flag(bm, op, "face_spans", FACE_SPAN, BM_FACE); + BMO_slot_from_flag(bm, op, "face_holes", FACE_HOLE, BM_FACE); } diff --git a/source/blender/bmesh/operators/bmesh_dupeops.c b/source/blender/bmesh/operators/bmesh_dupeops.c index 28dd9e25315..a4cad447204 100644 --- a/source/blender/bmesh/operators/bmesh_dupeops.c +++ b/source/blender/bmesh/operators/bmesh_dupeops.c @@ -45,16 +45,16 @@ static BMVert *copy_vertex(BMesh *source_mesh, BMVert *source_vertex, BMesh *tar BMVert *target_vertex = NULL; /* Create a new verte */ - target_vertex = BM_Make_Vert(target_mesh, source_vertex->co, NULL); + target_vertex = BM_vert_create(target_mesh, source_vertex->co, NULL); /* Insert new vertex into the vert has */ BLI_ghash_insert(vhash, source_vertex, target_vertex); /* Copy attribute */ - BM_Copy_Attributes(source_mesh, target_mesh, source_vertex, target_vertex); + BM_elem_copy_attrs(source_mesh, target_mesh, source_vertex, target_vertex); /* Set internal op flag */ - BMO_SetFlag(target_mesh, (BMHeader *)target_vertex, DUPE_NEW); + BMO_elem_flag_set(target_mesh, (BMHeader *)target_vertex, DUPE_NEW); return target_vertex; } @@ -79,11 +79,11 @@ static BMEdge *copy_edge(BMOperator *op, BMesh *source_mesh, * not being duplicated. in that case, * add it to the new/old map. */ rlen = 0; - for (face = BMIter_New(&fiter, source_mesh, BM_FACES_OF_EDGE, source_edge); + for (face = BM_iter_new(&fiter, source_mesh, BM_FACES_OF_EDGE, source_edge); face; - face = BMIter_Step(&fiter)) + face = BM_iter_step(&fiter)) { - if (BMO_TestFlag(source_mesh, face, DUPE_INPUT)) { + if (BMO_elem_flag_test(source_mesh, face, DUPE_INPUT)) { rlen++; } } @@ -93,13 +93,13 @@ static BMEdge *copy_edge(BMOperator *op, BMesh *source_mesh, target_vert2 = BLI_ghash_lookup(vhash, source_edge->v2); /* Create a new edg */ - target_edge = BM_Make_Edge(target_mesh, target_vert1, target_vert2, NULL, FALSE); + target_edge = BM_edge_create(target_mesh, target_vert1, target_vert2, NULL, FALSE); /* add to new/old edge map if necassar */ if (rlen < 2) { /* not sure what non-manifold cases of greater then three * radial should do. */ - BMO_Insert_MapPointer(source_mesh, op, "boundarymap", + BMO_slot_map_ptr_insert(source_mesh, op, "boundarymap", source_edge, target_edge); } @@ -107,10 +107,10 @@ static BMEdge *copy_edge(BMOperator *op, BMesh *source_mesh, BLI_ghash_insert(ehash, source_edge, target_edge); /* Copy attributes */ - BM_Copy_Attributes(source_mesh, target_mesh, source_edge, target_edge); + BM_elem_copy_attrs(source_mesh, target_mesh, source_edge, target_edge); /* Set internal op flags */ - BMO_SetFlag(target_mesh, (BMHeader *)target_edge, DUPE_NEW); + BMO_elem_flag_set(target_mesh, (BMHeader *)target_edge, DUPE_NEW); return target_edge; } @@ -133,39 +133,39 @@ static BMFace *copy_face(BMOperator *op, BMesh *source_mesh, /* lookup the first and second vert */ #if 0 /* UNUSED */ - target_vert1 = BLI_ghash_lookup(vhash, BMIter_New(&iter, source_mesh, BM_VERTS_OF_FACE, source_face)); - target_vert2 = BLI_ghash_lookup(vhash, BMIter_Step(&iter)); + target_vert1 = BLI_ghash_lookup(vhash, BM_iter_new(&iter, source_mesh, BM_VERTS_OF_FACE, source_face)); + target_vert2 = BLI_ghash_lookup(vhash, BM_iter_step(&iter)); #else - BMIter_New(&iter, source_mesh, BM_VERTS_OF_FACE, source_face); - BMIter_Step(&iter); + BM_iter_new(&iter, source_mesh, BM_VERTS_OF_FACE, source_face); + BM_iter_step(&iter); #endif /* lookup edge */ - for (i = 0, source_loop = BMIter_New(&iter, source_mesh, BM_LOOPS_OF_FACE, source_face); + for (i = 0, source_loop = BM_iter_new(&iter, source_mesh, BM_LOOPS_OF_FACE, source_face); source_loop; - source_loop = BMIter_Step(&iter), i++) + source_loop = BM_iter_step(&iter), i++) { vtar[i] = BLI_ghash_lookup(vhash, source_loop->v); edar[i] = BLI_ghash_lookup(ehash, source_loop->e); } /* create new fac */ - target_face = BM_Make_Face(target_mesh, vtar, edar, source_face->len, FALSE); - BMO_Insert_MapPointer(source_mesh, op, + target_face = BM_face_create(target_mesh, vtar, edar, source_face->len, FALSE); + BMO_slot_map_ptr_insert(source_mesh, op, "facemap", source_face, target_face); - BMO_Insert_MapPointer(source_mesh, op, + BMO_slot_map_ptr_insert(source_mesh, op, "facemap", target_face, source_face); - BM_Copy_Attributes(source_mesh, target_mesh, source_face, target_face); + BM_elem_copy_attrs(source_mesh, target_mesh, source_face, target_face); /* mark the face for outpu */ - BMO_SetFlag(target_mesh, (BMHeader *)target_face, DUPE_NEW); + BMO_elem_flag_set(target_mesh, (BMHeader *)target_face, DUPE_NEW); /* copy per-loop custom dat */ 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) { if (BLI_ghash_lookup(vhash, source_loop->v) == target_loop->v) { - BM_Copy_Attributes(source_mesh, target_mesh, source_loop, target_loop); + BM_elem_copy_attrs(source_mesh, target_mesh, source_loop, target_loop); break; } } @@ -202,15 +202,15 @@ static void copy_mesh(BMOperator *op, BMesh *source, BMesh *target) vhash = BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, "bmesh dupeops v"); ehash = BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, "bmesh dupeops e"); - for (v = BMIter_New(&verts, source, BM_VERTS_OF_MESH, source); v; v = BMIter_Step(&verts)) { - if (BMO_TestFlag(source, (BMHeader *)v, DUPE_INPUT) && (!BMO_TestFlag(source, (BMHeader *)v, DUPE_DONE))) { + for (v = BM_iter_new(&verts, source, BM_VERTS_OF_MESH, source); v; v = BM_iter_step(&verts)) { + if (BMO_elem_flag_test(source, (BMHeader *)v, DUPE_INPUT) && (!BMO_elem_flag_test(source, (BMHeader *)v, DUPE_DONE))) { BMIter iter; int iso = 1; v2 = copy_vertex(source, v, target, vhash); BM_ITER(f, &iter, source, BM_FACES_OF_VERT, v) { - if (BMO_TestFlag(source, f, DUPE_INPUT)) { + if (BMO_elem_flag_test(source, f, DUPE_INPUT)) { iso = 0; break; } @@ -218,7 +218,7 @@ static void copy_mesh(BMOperator *op, BMesh *source, BMesh *target) if (iso) { BM_ITER(e, &iter, source, BM_EDGES_OF_VERT, v) { - if (BMO_TestFlag(source, e, DUPE_INPUT)) { + if (BMO_elem_flag_test(source, e, DUPE_INPUT)) { iso = 0; break; } @@ -226,47 +226,47 @@ static void copy_mesh(BMOperator *op, BMesh *source, BMesh *target) } if (iso) { - BMO_Insert_MapPointer(source, op, "isovertmap", v, v2); + BMO_slot_map_ptr_insert(source, op, "isovertmap", v, v2); } - BMO_SetFlag(source, (BMHeader *)v, DUPE_DONE); + BMO_elem_flag_set(source, (BMHeader *)v, DUPE_DONE); } } /* now we dupe all the edge */ - for (e = BMIter_New(&edges, source, BM_EDGES_OF_MESH, source); e; e = BMIter_Step(&edges)) { - if (BMO_TestFlag(source, (BMHeader *)e, DUPE_INPUT) && (!BMO_TestFlag(source, (BMHeader *)e, DUPE_DONE))) { + for (e = BM_iter_new(&edges, source, BM_EDGES_OF_MESH, source); e; e = BM_iter_step(&edges)) { + if (BMO_elem_flag_test(source, (BMHeader *)e, DUPE_INPUT) && (!BMO_elem_flag_test(source, (BMHeader *)e, DUPE_DONE))) { /* make sure that verts are copie */ - if (!BMO_TestFlag(source, (BMHeader *)e->v1, DUPE_DONE)) { + if (!BMO_elem_flag_test(source, (BMHeader *)e->v1, DUPE_DONE)) { copy_vertex(source, e->v1, target, vhash); - BMO_SetFlag(source, (BMHeader *)e->v1, DUPE_DONE); + BMO_elem_flag_set(source, (BMHeader *)e->v1, DUPE_DONE); } - if (!BMO_TestFlag(source, (BMHeader *)e->v2, DUPE_DONE)) { + if (!BMO_elem_flag_test(source, (BMHeader *)e->v2, DUPE_DONE)) { copy_vertex(source, e->v2, target, vhash); - BMO_SetFlag(source, (BMHeader *)e->v2, DUPE_DONE); + BMO_elem_flag_set(source, (BMHeader *)e->v2, DUPE_DONE); } /* now copy the actual edg */ copy_edge(op, source, e, target, vhash, ehash); - BMO_SetFlag(source, (BMHeader *)e, DUPE_DONE); + BMO_elem_flag_set(source, (BMHeader *)e, DUPE_DONE); } } /* first we dupe all flagged faces and their elements from sourc */ - for (f = BMIter_New(&faces, source, BM_FACES_OF_MESH, source); f; f = BMIter_Step(&faces)) { - if (BMO_TestFlag(source, (BMHeader *)f, DUPE_INPUT)) { + for (f = BM_iter_new(&faces, source, BM_FACES_OF_MESH, source); f; f = BM_iter_step(&faces)) { + if (BMO_elem_flag_test(source, (BMHeader *)f, DUPE_INPUT)) { /* vertex pas */ - for (v = BMIter_New(&verts, source, BM_VERTS_OF_FACE, f); v; v = BMIter_Step(&verts)) { - if (!BMO_TestFlag(source, (BMHeader *)v, DUPE_DONE)) { + for (v = BM_iter_new(&verts, source, BM_VERTS_OF_FACE, f); v; v = BM_iter_step(&verts)) { + if (!BMO_elem_flag_test(source, (BMHeader *)v, DUPE_DONE)) { copy_vertex(source, v, target, vhash); - BMO_SetFlag(source, (BMHeader *)v, DUPE_DONE); + BMO_elem_flag_set(source, (BMHeader *)v, DUPE_DONE); } } /* edge pas */ - for (e = BMIter_New(&edges, source, BM_EDGES_OF_FACE, f); e; e = BMIter_Step(&edges)) { - if (!BMO_TestFlag(source, (BMHeader *)e, DUPE_DONE)) { + for (e = BM_iter_new(&edges, source, BM_EDGES_OF_FACE, f); e; e = BM_iter_step(&edges)) { + if (!BMO_elem_flag_test(source, (BMHeader *)e, DUPE_DONE)) { copy_edge(op, source, e, target, vhash, ehash); - BMO_SetFlag(source, (BMHeader *)e, DUPE_DONE); + BMO_elem_flag_set(source, (BMHeader *)e, DUPE_DONE); } } @@ -278,7 +278,7 @@ static void copy_mesh(BMOperator *op, BMesh *source, BMesh *target) BLI_array_growitems(edar, f->len); copy_face(op, source, f, target, vtar, edar, vhash, ehash); - BMO_SetFlag(source, (BMHeader *)f, DUPE_DONE); + BMO_elem_flag_set(source, (BMHeader *)f, DUPE_DONE); } } @@ -315,39 +315,41 @@ static void copy_mesh(BMOperator *op, BMesh *source, BMesh *target) void dupeop_exec(BMesh *bm, BMOperator *op) { BMOperator *dupeop = op; - BMesh *bm2 = BMO_Get_Pnt(op, "dest"); + BMesh *bm2 = BMO_slot_ptr_get(op, "dest"); if (!bm2) bm2 = bm; /* flag inpu */ - BMO_Flag_Buffer(bm, dupeop, "geom", DUPE_INPUT, BM_ALL); + BMO_slot_buffer_flag(bm, dupeop, "geom", DUPE_INPUT, BM_ALL); /* use the internal copy functio */ copy_mesh(dupeop, bm, bm2); /* Outpu */ /* First copy the input buffers to output buffers - original dat */ - BMO_CopySlot(dupeop, dupeop, "geom", "origout"); + BMO_slot_copy(dupeop, dupeop, "geom", "origout"); /* Now alloc the new output buffer */ - BMO_Flag_To_Slot(bm, dupeop, "newout", DUPE_NEW, BM_ALL); + BMO_slot_from_flag(bm, dupeop, "newout", DUPE_NEW, BM_ALL); } +#if 0 /* UNUSED */ /* executes the duplicate operation, feeding elements of * type flag etypeflag and header flag flag to it. note, * to get more useful information (such as the mapping from * original to new elements) you should run the dupe op manually */ -void BMOP_DupeFromFlag(BMesh *bm, int etypeflag, const char hflag) +void BMO_dupe_from_flag(BMesh *bm, int etypeflag, const char hflag) { BMOperator dupeop; - BMO_Init_Op(bm, &dupeop, "dupe"); - BMO_HeaderFlag_To_Slot(bm, &dupeop, "geom", hflag, etypeflag); + BMO_op_init(bm, &dupeop, "dupe"); + BMO_slot_from_hflag(bm, &dupeop, "geom", hflag, etypeflag); - BMO_Exec_Op(bm, &dupeop); - BMO_Finish_Op(bm, &dupeop); + BMO_op_exec(bm, &dupeop); + BMO_op_finish(bm, &dupeop); } +#endif /* * Split Operator @@ -380,56 +382,56 @@ void splitop_exec(BMesh *bm, BMOperator *op) int found; /* initialize our sub-operator */ - BMO_Init_Op(bm, &dupeop, "dupe"); - BMO_Init_Op(bm, &delop, "del"); + BMO_op_init(bm, &dupeop, "dupe"); + BMO_op_init(bm, &delop, "del"); - BMO_CopySlot(splitop, &dupeop, "geom", "geom"); - BMO_Exec_Op(bm, &dupeop); + BMO_slot_copy(splitop, &dupeop, "geom", "geom"); + BMO_op_exec(bm, &dupeop); - BMO_Flag_Buffer(bm, splitop, "geom", SPLIT_INPUT, BM_ALL); + BMO_slot_buffer_flag(bm, splitop, "geom", SPLIT_INPUT, BM_ALL); /* make sure to remove edges and verts we don't need */ - for (e = BMIter_New(&iter, bm, BM_EDGES_OF_MESH, NULL); e; e = BMIter_Step(&iter)) { + for (e = BM_iter_new(&iter, bm, BM_EDGES_OF_MESH, NULL); e; e = BM_iter_step(&iter)) { found = 0; - f = BMIter_New(&iter2, bm, BM_FACES_OF_EDGE, e); - for ( ; f; f = BMIter_Step(&iter2)) { - if (!BMO_TestFlag(bm, f, SPLIT_INPUT)) { + f = BM_iter_new(&iter2, bm, BM_FACES_OF_EDGE, e); + for ( ; f; f = BM_iter_step(&iter2)) { + if (!BMO_elem_flag_test(bm, f, SPLIT_INPUT)) { found = 1; break; } } - if (!found) BMO_SetFlag(bm, e, SPLIT_INPUT); + if (!found) BMO_elem_flag_set(bm, e, SPLIT_INPUT); } - for (v = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL); v; v = BMIter_Step(&iter)) { + for (v = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL); v; v = BM_iter_step(&iter)) { found = 0; - e = BMIter_New(&iter2, bm, BM_EDGES_OF_VERT, v); - for ( ; e; e = BMIter_Step(&iter2)) { - if (!BMO_TestFlag(bm, e, SPLIT_INPUT)) { + e = BM_iter_new(&iter2, bm, BM_EDGES_OF_VERT, v); + for ( ; e; e = BM_iter_step(&iter2)) { + if (!BMO_elem_flag_test(bm, e, SPLIT_INPUT)) { found = 1; break; } } - if (!found) BMO_SetFlag(bm, v, SPLIT_INPUT); + if (!found) BMO_elem_flag_set(bm, v, SPLIT_INPUT); } /* connect outputs of dupe to delete, exluding keep geometr */ - BMO_Set_Int(&delop, "context", DEL_FACES); - BMO_Flag_To_Slot(bm, &delop, "geom", SPLIT_INPUT, BM_ALL); + BMO_slot_int_set(&delop, "context", DEL_FACES); + BMO_slot_from_flag(bm, &delop, "geom", SPLIT_INPUT, BM_ALL); - BMO_Exec_Op(bm, &delop); + BMO_op_exec(bm, &delop); /* now we make our outputs by copying the dupe output */ - BMO_CopySlot(&dupeop, splitop, "newout", "geomout"); - BMO_CopySlot(&dupeop, splitop, "boundarymap", + BMO_slot_copy(&dupeop, splitop, "newout", "geomout"); + BMO_slot_copy(&dupeop, splitop, "boundarymap", "boundarymap"); - BMO_CopySlot(&dupeop, splitop, "isovertmap", + BMO_slot_copy(&dupeop, splitop, "isovertmap", "isovertmap"); /* cleanu */ - BMO_Finish_Op(bm, &delop); - BMO_Finish_Op(bm, &dupeop); + BMO_op_finish(bm, &delop); + BMO_op_finish(bm, &dupeop); } @@ -440,9 +442,9 @@ void delop_exec(BMesh *bm, BMOperator *op) BMOperator *delop = op; /* Mark Buffer */ - BMO_Flag_Buffer(bm, delop, "geom", DEL_INPUT, BM_ALL); + BMO_slot_buffer_flag(bm, delop, "geom", DEL_INPUT, BM_ALL); - BMO_remove_tagged_context(bm, DEL_INPUT, BMO_Get_Int(op, "context")); + BMO_remove_tagged_context(bm, DEL_INPUT, BMO_slot_int_get(op, "context")); #undef DEL_INPUT } @@ -464,14 +466,14 @@ void spinop_exec(BMesh *bm, BMOperator *op) float phi, si; int steps, dupli, a, usedvec; - BMO_Get_Vec(op, "cent", cent); - BMO_Get_Vec(op, "axis", axis); + BMO_slot_vec_get(op, "cent", cent); + BMO_slot_vec_get(op, "axis", axis); normalize_v3(axis); - BMO_Get_Vec(op, "dvec", dvec); + BMO_slot_vec_get(op, "dvec", dvec); usedvec = !is_zero_v3(dvec); - steps = BMO_Get_Int(op, "steps"); - phi = BMO_Get_Float(op, "ang") * (float)M_PI / (360.0f * steps); - dupli = BMO_Get_Int(op, "dupli"); + steps = BMO_slot_int_get(op, "steps"); + phi = BMO_slot_float_get(op, "ang") * (float)M_PI / (360.0f * steps); + dupli = BMO_slot_int_get(op, "dupli"); si = (float)sin(phi); q[0] = (float)cos(phi); @@ -480,27 +482,27 @@ void spinop_exec(BMesh *bm, BMOperator *op) q[3] = axis[2]*si; quat_to_mat3(rmat, q); - BMO_CopySlot(op, op, "geom", "lastout"); + BMO_slot_copy(op, op, "geom", "lastout"); for (a = 0; a < steps; a++) { if (dupli) { - BMO_InitOpf(bm, &dupop, "dupe geom=%s", op, "lastout"); - BMO_Exec_Op(bm, &dupop); - BMO_CallOpf(bm, "rotate cent=%v mat=%m3 verts=%s", + BMO_op_initf(bm, &dupop, "dupe geom=%s", op, "lastout"); + BMO_op_exec(bm, &dupop); + BMO_op_callf(bm, "rotate cent=%v mat=%m3 verts=%s", cent, rmat, &dupop, "newout"); - BMO_CopySlot(&dupop, op, "newout", "lastout"); - BMO_Finish_Op(bm, &dupop); + BMO_slot_copy(&dupop, op, "newout", "lastout"); + BMO_op_finish(bm, &dupop); } else { - BMO_InitOpf(bm, &extop, "extrudefaceregion edgefacein=%s", + BMO_op_initf(bm, &extop, "extrudefaceregion edgefacein=%s", op, "lastout"); - BMO_Exec_Op(bm, &extop); - BMO_CallOpf(bm, "rotate cent=%v mat=%m3 verts=%s", + BMO_op_exec(bm, &extop); + BMO_op_callf(bm, "rotate cent=%v mat=%m3 verts=%s", cent, rmat, &extop, "geomout"); - BMO_CopySlot(&extop, op, "geomout", "lastout"); - BMO_Finish_Op(bm, &extop); + BMO_slot_copy(&extop, op, "geomout", "lastout"); + BMO_op_finish(bm, &extop); } if (usedvec) - BMO_CallOpf(bm, "translate vec=%v verts=%s", dvec, op, "lastout"); + BMO_op_callf(bm, "translate vec=%v verts=%s", dvec, op, "lastout"); } } diff --git a/source/blender/bmesh/operators/connectops.c b/source/blender/bmesh/operators/connectops.c index 5054b351f15..0ef6ecffb06 100644 --- a/source/blender/bmesh/operators/connectops.c +++ b/source/blender/bmesh/operators/connectops.c @@ -45,18 +45,18 @@ void connectverts_exec(BMesh *bm, BMOperator *op) BLI_array_declare(verts); int i; - BMO_Flag_Buffer(bm, op, "verts", VERT_INPUT, BM_VERT); + BMO_slot_buffer_flag(bm, op, "verts", VERT_INPUT, BM_VERT); - for (f = BMIter_New(&iter, bm, BM_FACES_OF_MESH, NULL); f; f = BMIter_Step(&iter)) { + for (f = BM_iter_new(&iter, bm, BM_FACES_OF_MESH, NULL); f; f = BM_iter_step(&iter)) { BLI_array_empty(loops); BLI_array_empty(verts); - if (BMO_TestFlag(bm, f, FACE_NEW)) continue; + if (BMO_elem_flag_test(bm, f, FACE_NEW)) continue; - l = BMIter_New(&liter, bm, BM_LOOPS_OF_FACE, f); + l = BM_iter_new(&liter, bm, BM_LOOPS_OF_FACE, f); lastl = NULL; - for ( ; l; l = BMIter_Step(&liter)) { - if (BMO_TestFlag(bm, l->v, VERT_INPUT)) { + for ( ; l; l = BM_iter_step(&liter)) { + if (BMO_elem_flag_test(bm, l->v, VERT_INPUT)) { if (!lastl) { lastl = l; continue; @@ -84,7 +84,7 @@ void connectverts_exec(BMesh *bm, BMOperator *op) loops[BLI_array_count(loops) - 1] = loops[0]; } - BM_LegalSplits(bm, f, (BMLoop *(*)[2])loops, BLI_array_count(loops) / 2); + BM_face_legal_splits(bm, f, (BMLoop *(*)[2])loops, BLI_array_count(loops) / 2); for (i = 0; i < BLI_array_count(loops) / 2; i++) { if (loops[i * 2] == NULL) continue; @@ -97,20 +97,20 @@ void connectverts_exec(BMesh *bm, BMOperator *op) } for (i = 0; i < BLI_array_count(verts) / 2; i++) { - nf = BM_Split_Face(bm, f, verts[i * 2], verts[i * 2 + 1], &nl, NULL); + nf = BM_face_split(bm, f, verts[i * 2], verts[i * 2 + 1], &nl, NULL); f = nf; if (!nl || !nf) { - BMO_RaiseError(bm, op, BMERR_CONNECTVERT_FAILED, NULL); + BMO_error_raise(bm, op, BMERR_CONNECTVERT_FAILED, NULL); BLI_array_free(loops); return; } - BMO_SetFlag(bm, nf, FACE_NEW); - BMO_SetFlag(bm, nl->e, EDGE_OUT); + BMO_elem_flag_set(bm, nf, FACE_NEW); + BMO_elem_flag_set(bm, nl->e, EDGE_OUT); } } - BMO_Flag_To_Slot(bm, op, "edgeout", EDGE_OUT, BM_EDGE); + BMO_slot_from_flag(bm, op, "edgeout", EDGE_OUT, BM_EDGE); BLI_array_free(loops); BLI_array_free(verts); @@ -124,7 +124,7 @@ static BMVert *get_outer_vert(BMesh *bm, BMEdge *e) i = 0; BM_ITER(e2, &iter, bm, BM_EDGES_OF_VERT, e->v1) { - if (BMO_TestFlag(bm, e2, EDGE_MARK)) { + if (BMO_elem_flag_test(bm, e2, EDGE_MARK)) { i++; } } @@ -172,33 +172,33 @@ void bmesh_bridge_loops_exec(BMesh *bm, BMOperator *op) BMEdge *e, *nexte; int c = 0, cl1 = 0, cl2 = 0; - BMO_Flag_Buffer(bm, op, "edges", EDGE_MARK, BM_EDGE); + BMO_slot_buffer_flag(bm, op, "edges", EDGE_MARK, BM_EDGE); BMO_ITER(e, &siter, bm, op, "edges", BM_EDGE) { - if (!BMO_TestFlag(bm, e, EDGE_DONE)) { + if (!BMO_elem_flag_test(bm, e, EDGE_DONE)) { BMVert *v, *ov; /* BMEdge *e2, *e3, *oe = e; */ /* UNUSED */ BMEdge *e2, *e3; if (c > 2) { - BMO_RaiseError(bm, op, BMERR_INVALID_SELECTION, "Select only two edge loops"); + BMO_error_raise(bm, op, BMERR_INVALID_SELECTION, "Select only two edge loops"); goto cleanup; } e2 = e; v = e->v1; do { - v = BM_OtherEdgeVert(e2, v); + v = BM_edge_other_vert(e2, v); nexte = NULL; BM_ITER(e3, &iter, bm, BM_EDGES_OF_VERT, v) { - if (e3 != e2 && BMO_TestFlag(bm, e3, EDGE_MARK)) { + if (e3 != e2 && BMO_elem_flag_test(bm, e3, EDGE_MARK)) { if (nexte == NULL) { nexte = e3; } else { /* edges do not form a loop: there is a disk * with more than two marked edges. */ - BMO_RaiseError(bm, op, BMERR_INVALID_SELECTION, + BMO_error_raise(bm, op, BMERR_INVALID_SELECTION, "Selection must only contain edges from two edge loops"); goto cleanup; } @@ -224,11 +224,11 @@ void bmesh_bridge_loops_exec(BMesh *bm, BMOperator *op) BLI_array_append(vv2, v); } - BMO_SetFlag(bm, e2, EDGE_DONE); + BMO_elem_flag_set(bm, e2, EDGE_DONE); - v = BM_OtherEdgeVert(e2, v); + v = BM_edge_other_vert(e2, v); BM_ITER(e3, &iter, bm, BM_EDGES_OF_VERT, v) { - if (e3 != e2 && BMO_TestFlag(bm, e3, EDGE_MARK) && !BMO_TestFlag(bm, e3, EDGE_DONE)) { + if (e3 != e2 && BMO_elem_flag_test(bm, e3, EDGE_MARK) && !BMO_elem_flag_test(bm, e3, EDGE_DONE)) { break; } } @@ -284,7 +284,7 @@ void bmesh_bridge_loops_exec(BMesh *bm, BMOperator *op) * have different edge counts by generating triangles & quads for * the bridge instead of quads only. */ if (BLI_array_count(ee1) != BLI_array_count(ee2)) { - BMO_RaiseError(bm, op, BMERR_INVALID_SELECTION, + BMO_error_raise(bm, op, BMERR_INVALID_SELECTION, "Selected loops must have equal edge counts"); goto cleanup; } @@ -394,7 +394,7 @@ void bmesh_bridge_loops_exec(BMesh *bm, BMOperator *op) SWAP(int, i2, i2next); } - f = BM_Make_Face_QuadTri(bm, + f = BM_face_create_quad_tri(bm, vv1[i1], vv2[i2], vv2[i2next], diff --git a/source/blender/bmesh/operators/createops.c b/source/blender/bmesh/operators/createops.c index 51912a25d1a..af0758b153f 100644 --- a/source/blender/bmesh/operators/createops.c +++ b/source/blender/bmesh/operators/createops.c @@ -92,8 +92,8 @@ static int count_edge_faces(BMesh *bm, BMEdge *e); static int rotsys_append_edge(struct BMEdge *e, struct BMVert *v, EdgeData *edata, VertData *vdata) { - EdgeData *ed = &edata[BM_GetIndex(e)]; - VertData *vd = &vdata[BM_GetIndex(v)]; + EdgeData *ed = &edata[BM_elem_index_get(e)]; + VertData *vd = &vdata[BM_elem_index_get(v)]; if (!vd->e) { Link *e1 = (Link *)RS_GET_EDGE_LINK(e, v, ed); @@ -103,11 +103,11 @@ static int rotsys_append_edge(struct BMEdge *e, struct BMVert *v, } else { Link *e1, *e2, *e3; - EdgeData *ved = &edata[BM_GetIndex(vd->e)]; + EdgeData *ved = &edata[BM_elem_index_get(vd->e)]; e1 = RS_GET_EDGE_LINK(e, v, ed); e2 = RS_GET_EDGE_LINK(vd->e, v, ved); - e3 = e2->prev ? RS_GET_EDGE_LINK(e2->prev, v, &edata[BM_GetIndex(e2->prev)]) : NULL; + e3 = e2->prev ? RS_GET_EDGE_LINK(e2->prev, v, &edata[BM_elem_index_get(e2->prev)]) : NULL; e1->next = (Link *)vd->e; e1->prev = e2->prev; @@ -123,8 +123,8 @@ static int rotsys_append_edge(struct BMEdge *e, struct BMVert *v, static void UNUSED_FUNCTION(rotsys_remove_edge)(struct BMEdge *e, struct BMVert *v, EdgeData *edata, VertData *vdata) { - EdgeData *ed = edata + BM_GetIndex(e); - VertData *vd = vdata + BM_GetIndex(v); + EdgeData *ed = edata + BM_elem_index_get(e); + VertData *vd = vdata + BM_elem_index_get(v); Link *e1, *e2; e1 = RS_GET_EDGE_LINK(e, v, ed); @@ -148,9 +148,9 @@ static struct BMEdge *rotsys_nextedge(struct BMEdge *e, struct BMVert *v, EdgeData *edata, VertData *UNUSED(vdata)) { if (v == e->v1) - return edata[BM_GetIndex(e)].dlink1.next; + return edata[BM_elem_index_get(e)].dlink1.next; if (v == e->v2) - return edata[BM_GetIndex(e)].dlink2.next; + return edata[BM_elem_index_get(e)].dlink2.next; return NULL; } @@ -158,9 +158,9 @@ static BMEdge *rotsys_prevedge(BMEdge *e, BMVert *v, EdgeData *edata, VertData *UNUSED(vdata)) { if (v == e->v1) - return edata[BM_GetIndex(e)].dlink1.prev; + return edata[BM_elem_index_get(e)].dlink1.prev; if (v == e->v2) - return edata[BM_GetIndex(e)].dlink2.prev; + return edata[BM_elem_index_get(e)].dlink2.prev; return NULL; } @@ -172,7 +172,7 @@ static void rotsys_reverse(struct BMEdge *UNUSED(e), struct BMVert *v, EdgeData BLI_array_staticdeclare(edges, BM_NGON_STACK_SIZE); int i, totedge; - e = e_first = vdata[BM_GetIndex(v)].e; + e = e_first = vdata[BM_elem_index_get(v)].e; do { BLI_array_append(edges, e); e = rotsys_nextedge(e, v, edata, vdata); @@ -183,7 +183,7 @@ static void rotsys_reverse(struct BMEdge *UNUSED(e), struct BMVert *v, EdgeData SWAP(BMEdge *, edges[i], edges[totedge - 1 - i]); } - vdata[BM_GetIndex(v)].e = NULL; + vdata[BM_elem_index_get(v)].e = NULL; for (i = 0; i < totedge; i++) { rotsys_append_edge(edges[i], v, edata, vdata); } @@ -193,7 +193,7 @@ static void rotsys_reverse(struct BMEdge *UNUSED(e), struct BMVert *v, EdgeData static int UNUSED_FUNCTION(rotsys_count)(struct BMVert *v, EdgeData *edata, VertData *vdata) { - BMEdge *e = vdata[BM_GetIndex(v)].e; + BMEdge *e = vdata[BM_elem_index_get(v)].e; int i = 0; if (!e) @@ -210,7 +210,7 @@ static int UNUSED_FUNCTION(rotsys_count)(struct BMVert *v, EdgeData *edata, Vert } i += 1; - } while (e != vdata[BM_GetIndex(v)].e); + } while (e != vdata[BM_elem_index_get(v)].e); return i; } @@ -264,7 +264,7 @@ static int UNUSED_FUNCTION(rotsys_fill_faces)(BMesh *bm, EdgeData *edata, VertDa BLI_smallhash_insert(hash, (intptr_t)e2, NULL); - v = BM_OtherEdgeVert(e2, v); + v = BM_edge_other_vert(e2, v); e2 = i ? rotsys_prevedge(e2, v, edata, vdata) : rotsys_nextedge(e2, v, edata, vdata); } while (e2 != starte && v != startv); @@ -273,7 +273,7 @@ static int UNUSED_FUNCTION(rotsys_fill_faces)(BMesh *bm, EdgeData *edata, VertDa if (!ok || BLI_array_count(edges) < 3) continue; - f = BM_Make_Ngon(bm, verts[0], verts[1], edges, BLI_array_count(edges), TRUE); + f = BM_face_create_ngon(bm, verts[0], verts[1], edges, BLI_array_count(edges), TRUE); if (!f) continue; } @@ -299,9 +299,9 @@ static void rotsys_make_consistent(BMesh *bm, EdgeData *edata, VertData *vdata) BMVert *startv = NULL; float dis; - v = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL); - for (i = 0; i < bm->totvert; i++, BMIter_Step(&iter)) { - vd = vdata + BM_GetIndex(v); + v = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL); + for (i = 0; i < bm->totvert; i++, BM_iter_step(&iter)) { + vd = vdata + BM_elem_index_get(v); if (vd->tag) continue; @@ -315,7 +315,7 @@ static void rotsys_make_consistent(BMesh *bm, EdgeData *edata, VertData *vdata) if (!startv) break; - vd = vdata + BM_GetIndex(startv); + vd = vdata + BM_elem_index_get(startv); BLI_array_empty(stack); BLI_array_append(stack, startv); @@ -324,15 +324,15 @@ static void rotsys_make_consistent(BMesh *bm, EdgeData *edata, VertData *vdata) while (BLI_array_count(stack)) { v = BLI_array_pop(stack); - vd = vdata + BM_GetIndex(v); + vd = vdata + BM_elem_index_get(v); if (!vd->e) continue; e = vd->e; do { - BMVert *v2 = BM_OtherEdgeVert(e, v); - VertData *vd2 = vdata + BM_GetIndex(v2); + BMVert *v2 = BM_edge_other_vert(e, v); + VertData *vd2 = vdata + BM_elem_index_get(v2); if (dot_v3v3(vd->no, vd2->no) < 0.0f + FLT_EPSILON * 2) { rotsys_reverse(e, v2, edata, vdata); @@ -370,13 +370,13 @@ static void init_rotsys(BMesh *bm, EdgeData *edata, VertData *vdata) float no[3], cent[3]; int j, k = 0, totedge = 0; - if (BM_GetIndex(v) == -1) + if (BM_elem_index_get(v) == -1) continue; BLI_array_empty(edges); BM_ITER(e, &eiter, bm, BM_EDGES_OF_VERT, v) { - if (BMO_TestFlag(bm, e, EDGE_MARK)) { + if (BMO_elem_flag_test(bm, e, EDGE_MARK)) { BLI_array_append(edges, e); totedge++; } @@ -392,8 +392,8 @@ static void init_rotsys(BMesh *bm, EdgeData *edata, VertData *vdata) e1 = edges[i]; e2 = edges[(i + 1) % totedge]; - sub_v3_v3v3(vec1, (BM_OtherEdgeVert(e1, v))->co, v->co); - sub_v3_v3v3(vec2, (BM_OtherEdgeVert(e2, v))->co, v->co); + sub_v3_v3v3(vec1, (BM_edge_other_vert(e1, v))->co, v->co); + sub_v3_v3v3(vec2, (BM_edge_other_vert(e2, v))->co, v->co); cross_v3_v3v3(cno, vec1, vec2); normalize_v3(cno); @@ -412,7 +412,7 @@ static void init_rotsys(BMesh *bm, EdgeData *edata, VertData *vdata) float cvec[3], vec1[3]; e1 = edges[i]; - v2 = BM_OtherEdgeVert(e1, v); + v2 = BM_edge_other_vert(e1, v); sub_v3_v3v3(vec1, v2->co, v->co); @@ -423,7 +423,7 @@ static void init_rotsys(BMesh *bm, EdgeData *edata, VertData *vdata) mul_v3_fl(vec1, len_v3v3(v2->co, v->co)); add_v3_v3(vec1, v->co); - copy_v3_v3(vdata[BM_GetIndex(v2)].sco, vec1); + copy_v3_v3(vdata[BM_elem_index_get(v2)].sco, vec1); } BLI_srandom(0); @@ -444,13 +444,13 @@ static void init_rotsys(BMesh *bm, EdgeData *edata, VertData *vdata) e2 = edges[i]; e3 = edges[(i + 1) % totedge]; - v1 = BM_OtherEdgeVert(e1, v); - v2 = BM_OtherEdgeVert(e2, v); - v3 = BM_OtherEdgeVert(e3, v); + v1 = BM_edge_other_vert(e1, v); + v2 = BM_edge_other_vert(e2, v); + v3 = BM_edge_other_vert(e3, v); - vd1 = vdata + BM_GetIndex(v1); - vd2 = vdata + BM_GetIndex(v2); - vd3 = vdata + BM_GetIndex(v3); + vd1 = vdata + BM_elem_index_get(v1); + vd2 = vdata + BM_elem_index_get(v2); + vd3 = vdata + BM_elem_index_get(v3); sub_v3_v3v3(vec1, vd1->sco, cent); sub_v3_v3v3(vec2, vd2->sco, cent); @@ -487,7 +487,7 @@ static void init_rotsys(BMesh *bm, EdgeData *edata, VertData *vdata) } } - copy_v3_v3(vdata[BM_GetIndex(v)].offco, cent); + copy_v3_v3(vdata[BM_elem_index_get(v)].offco, cent); //copy_v3_v3(v->co, cent); /* now, sort edges so the triangle fan of all edges @@ -505,13 +505,13 @@ static void init_rotsys(BMesh *bm, EdgeData *edata, VertData *vdata) e2 = edges[i]; e3 = edges[(i + 1) % totedge]; - v1 = BM_OtherEdgeVert(e1, v); - v2 = BM_OtherEdgeVert(e2, v); - v3 = BM_OtherEdgeVert(e3, v); + v1 = BM_edge_other_vert(e1, v); + v2 = BM_edge_other_vert(e2, v); + v3 = BM_edge_other_vert(e3, v); - vd1 = vdata + BM_GetIndex(v1); - vd2 = vdata + BM_GetIndex(v2); - vd3 = vdata + BM_GetIndex(v3); + vd1 = vdata + BM_elem_index_get(v1); + vd2 = vdata + BM_elem_index_get(v2); + vd3 = vdata + BM_elem_index_get(v3); sub_v3_v3v3(vec1, vd1->sco, cent); sub_v3_v3v3(vec2, vd2->sco, cent); @@ -553,14 +553,14 @@ static void init_rotsys(BMesh *bm, EdgeData *edata, VertData *vdata) BMEdge *e1 = edges[i], *e2 = edges[(i + 1) % totedge]; float eno[3]; - normal_tri_v3(eno, BM_OtherEdgeVert(e1, v)->co, v->co, BM_OtherEdgeVert(e2, v)->co); + normal_tri_v3(eno, BM_edge_other_vert(e1, v)->co, v->co, BM_edge_other_vert(e2, v)->co); add_v3_v3(no, eno); rotsys_append_edge(edges[i], v, edata, vdata); } normalize_v3(no); - copy_v3_v3(vdata[BM_GetIndex(v)].no, no); + copy_v3_v3(vdata[BM_elem_index_get(v)].no, no); } /* now, make sure rotation system is topologically consistent @@ -575,15 +575,15 @@ static void init_rotsys(BMesh *bm, EdgeData *edata, VertData *vdata) BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) { BMVert *v2; BMFace *f; - int totedge = BM_Vert_EdgeCount(v); + int totedge = BM_vert_edge_count(v); - if (BM_GetIndex(v) == -1) + if (BM_elem_index_get(v) == -1) continue; - //cv = BM_Make_Vert(bm, cent, v); - //BM_SetIndex(cv, -1); /* set_dirty! */ + //cv = BM_vert_create(bm, cent, v); + //BM_elem_index_set(cv, -1); /* set_dirty! */ i = 0; - e = vdata[BM_GetIndex(v)].e; + e = vdata[BM_elem_index_get(v)].e; lastv = NULL; do { BMEdge *e2; @@ -594,28 +594,28 @@ static void init_rotsys(BMesh *bm, EdgeData *edata, VertData *vdata) if (!e) break; - if (!BM_OtherEdgeVert(e, v)) + if (!BM_edge_other_vert(e, v)) continue; - sub_v3_v3v3(co, (BM_OtherEdgeVert(e, v))->co, vdata[BM_GetIndex(v)].offco); + sub_v3_v3v3(co, (BM_edge_other_vert(e, v))->co, vdata[BM_elem_index_get(v)].offco); mul_v3_fl(co, f); - add_v3_v3(co, vdata[BM_GetIndex(v)].offco); + add_v3_v3(co, vdata[BM_elem_index_get(v)].offco); - v2 = BM_Make_Vert(bm, co, NULL); - BM_SetIndex(v2, -1); /* set_dirty! */ - //BM_Make_Edge(bm, cv, v2, NULL, FALSE); + v2 = BM_vert_create(bm, co, NULL); + BM_elem_index_set(v2, -1); /* set_dirty! */ + //BM_edge_create(bm, cv, v2, NULL, FALSE); - BM_Select(bm, v2, TRUE); + BM_elem_select_set(bm, v2, TRUE); if (lastv) { - e2 = BM_Make_Edge(bm, lastv, v2, NULL, FALSE); - BM_Select(bm, e2, TRUE); + e2 = BM_edge_create(bm, lastv, v2, NULL, FALSE); + BM_elem_select_set(bm, e2, TRUE); } lastv = v2; e = rotsys_nextedge(e, v, edata, vdata); i++; - } while (e != vdata[BM_GetIndex(v)].e); + } while (e != vdata[BM_elem_index_get(v)].e); } #endif @@ -692,7 +692,7 @@ static float edge_weight_path(EPath *path, EdgeData *edata, VertData *UNUSED(vda for (node = path->nodes.first; node; node = node->next) { if (node->e && node != path->nodes.first) { - w += edata[BM_GetIndex(node->e)].ftag; + w += edata[BM_elem_index_get(node->e)].ftag; if (node->prev) { /* BMESH_TOD */ (void)first; @@ -733,10 +733,10 @@ static EPath *edge_find_shortest_path(BMesh *bm, BMOperator *op, BMEdge *edge, E BMVert *startv; BMVert *endv; EPathNode *node; - int i, use_restrict = BMO_Get_Int(op, "use_restrict"); + int i, use_restrict = BMO_slot_int_get(op, "use_restrict"); - startv = edata[BM_GetIndex(edge)].ftag ? edge->v2 : edge->v1; - endv = edata[BM_GetIndex(edge)].ftag ? edge->v1 : edge->v2; + startv = edata[BM_elem_index_get(edge)].ftag ? edge->v2 : edge->v1; + endv = edata[BM_elem_index_get(edge)].ftag ? edge->v1 : edge->v2; path = edge_path_new(pathbase, startv, edge); BLI_ghash_insert(gh, startv, NULL); @@ -761,8 +761,8 @@ static EPath *edge_find_shortest_path(BMesh *bm, BMOperator *op, BMEdge *edge, E verts[i] = node->v; } - if (BM_Face_Exists(bm, verts, i, &f)) { - if (!BMO_TestFlag(bm, f, FACE_IGNORE)) { + if (BM_face_exists(bm, verts, i, &f)) { + if (!BMO_elem_flag_test(bm, f, FACE_IGNORE)) { BLI_ghash_remove(gh, endv, NULL, NULL); continue; } @@ -770,36 +770,36 @@ static EPath *edge_find_shortest_path(BMesh *bm, BMOperator *op, BMEdge *edge, E break; } - vd = vdata + BM_GetIndex(v1); + vd = vdata + BM_elem_index_get(v1); if (!vd->e) continue; v2 = NULL; while (1) { if (!last->cure) { - last->cure = e = vdata[BM_GetIndex(last->v)].e; + last->cure = e = vdata[BM_elem_index_get(last->v)].e; } else { last->cure = e = rotsys_nextedge(last->cure, last->v, edata, vdata); - if (last->cure == vdata[BM_GetIndex(last->v)].e) { + if (last->cure == vdata[BM_elem_index_get(last->v)].e) { v2 = NULL; break; } } - if (e == edge || !BMO_TestFlag(bm, e, EDGE_MARK)) { + if (e == edge || !BMO_elem_flag_test(bm, e, EDGE_MARK)) { continue; } - v2 = BM_OtherEdgeVert(e, last->v); + v2 = BM_edge_other_vert(e, last->v); if (BLI_ghash_haskey(gh, v2)) { v2 = NULL; continue; } - if (use_restrict && BMO_InMap(bm, op, "restrict", e)) { - int group = BMO_Get_MapInt(bm, op, "restrict", e); + if (use_restrict && BMO_slot_map_contains(bm, op, "restrict", e)) { + int group = BMO_slot_map_int_get(bm, op, "restrict", e); if (!(group & path->group)) { v2 = NULL; @@ -852,7 +852,7 @@ static int count_edge_faces(BMesh *bm, BMEdge *e) } do { - if (!BMO_TestFlag(bm, l->f, FACE_IGNORE)) { + if (!BMO_elem_flag_test(bm, l->f, FACE_IGNORE)) { i++; } @@ -877,7 +877,7 @@ void bmesh_edgenet_fill_exec(BMesh *bm, BMOperator *op) BMEdge **edges = NULL; PathBase *pathbase = edge_pathbase_new(); BLI_array_declare(edges); - int use_restrict = BMO_Get_Int(op, "use_restrict"); + int use_restrict = BMO_slot_int_get(op, "use_restrict"); int i, j, group = 0; unsigned int winding[2]; /* accumulte winding directions for each edge which has a face */ @@ -887,20 +887,20 @@ void bmesh_edgenet_fill_exec(BMesh *bm, BMOperator *op) edata = MEM_callocN(sizeof(EdgeData)*bm->totedge, "EdgeData"); vdata = MEM_callocN(sizeof(VertData)*bm->totvert, "VertData"); - BMO_Flag_Buffer(bm, op, "edges", EDGE_MARK, BM_EDGE); - BMO_Flag_Buffer(bm, op, "excludefaces", FACE_IGNORE, BM_FACE); + BMO_slot_buffer_flag(bm, op, "edges", EDGE_MARK, BM_EDGE); + BMO_slot_buffer_flag(bm, op, "excludefaces", FACE_IGNORE, BM_FACE); - BM_ElemIndex_Ensure(bm, BM_VERT); + BM_mesh_elem_index_ensure(bm, BM_VERT); BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) { - BMO_SetFlag(bm, f, ELE_ORIG); + BMO_elem_flag_set(bm, f, ELE_ORIG); } i = 0; BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) { - BM_SetIndex(e, i); /* set_inline */ + BM_elem_index_set(e, i); /* set_inline */ - if (!BMO_TestFlag(bm, e, EDGE_MARK)) { + if (!BMO_elem_flag_test(bm, e, EDGE_MARK)) { edata[i].tag = 2; } @@ -916,23 +916,23 @@ void bmesh_edgenet_fill_exec(BMesh *bm, BMOperator *op) BMO_ITER(e, &siter, bm, op, "edges", BM_EDGE) { /* if restrict is on, only start on faces in the restrict map */ - if (use_restrict && !BMO_InMap(bm, op, "restrict", e)) + if (use_restrict && !BMO_slot_map_contains(bm, op, "restrict", e)) continue; - if (edata[BM_GetIndex(e)].tag < 2) { + if (edata[BM_elem_index_get(e)].tag < 2) { edge = e; if (use_restrict) { int i = 0, j = 0, gi = 0; - group = BMO_Get_MapInt(bm, op, "restrict", e); + group = BMO_slot_map_int_get(bm, op, "restrict", e); for (i = 0; i < 30; i++) { if (group & (1 << i)) { j++; gi = i; - if (j - 1 == edata[BM_GetIndex(e)].tag) { + if (j - 1 == edata[BM_elem_index_get(e)].tag) { break; } } @@ -948,7 +948,7 @@ void bmesh_edgenet_fill_exec(BMesh *bm, BMOperator *op) if (!edge) break; - edata[BM_GetIndex(edge)].tag += 1; + edata[BM_elem_index_get(edge)].tag += 1; path = edge_find_shortest_path(bm, op, edge, edata, vdata, pathbase, group); if (!path) @@ -963,7 +963,7 @@ void bmesh_edgenet_fill_exec(BMesh *bm, BMOperator *op) if (!node->next) continue; - e = BM_Edge_Exist(node->v, node->next->v); + e = BM_edge_exists(node->v, node->next->v); /* this should never happe */ if (!e) @@ -973,13 +973,13 @@ void bmesh_edgenet_fill_exec(BMesh *bm, BMOperator *op) if (e->l) { BMVert *test_v1, *test_v2; /* we want to use the reverse winding to the existing order */ - BM_Edge_OrderedVerts(edge, &test_v2, &test_v1); + BM_edge_ordered_verts(edge, &test_v2, &test_v1); /* edges vote on which winding wins out */ winding[(test_v1 == node->v)]++; } - edata[BM_GetIndex(e)].ftag++; + edata[BM_elem_index_get(e)].ftag++; BLI_array_growone(edges); edges[i++] = e; @@ -988,7 +988,7 @@ void bmesh_edgenet_fill_exec(BMesh *bm, BMOperator *op) BLI_array_growone(edges); edges[i++] = edge; - edata[BM_GetIndex(edge)].ftag++; + edata[BM_elem_index_get(edge)].ftag++; for (j = 0; j < i; j++) { if (count_edge_faces(bm, edges[j]) >= 2) { @@ -1019,19 +1019,19 @@ void bmesh_edgenet_fill_exec(BMesh *bm, BMOperator *op) v2 = verts[0]; } - f = BM_Make_Ngon(bm, v1, v2, edges, i, TRUE); - if (f && !BMO_TestFlag(bm, f, ELE_ORIG)) { - BMO_SetFlag(bm, f, FACE_NEW); + f = BM_face_create_ngon(bm, v1, v2, edges, i, TRUE); + if (f && !BMO_elem_flag_test(bm, f, ELE_ORIG)) { + BMO_elem_flag_set(bm, f, FACE_NEW); } if (use_restrict) - BMO_Insert_MapInt(bm, op, "faceout_groupmap", f, path->group); + BMO_slot_map_int_insert(bm, op, "faceout_groupmap", f, path->group); } edge_free_path(pathbase, path); } - BMO_Flag_To_Slot(bm, op, "faceout", FACE_NEW, BM_FACE); + BMO_slot_from_flag(bm, op, "faceout", FACE_NEW, BM_FACE); BLI_array_free(edges); BLI_array_free(verts); @@ -1048,8 +1048,8 @@ static BMEdge *edge_next(BMesh *bm, BMEdge *e) for (i = 0; i < 2; i++) { BM_ITER(e2, &iter, bm, BM_EDGES_OF_VERT, i ? e->v2 : e->v1) { - if ( (BMO_TestFlag(bm, e2, EDGE_MARK)) && - (!BMO_TestFlag(bm, e2, EDGE_VIS)) && + if ( (BMO_elem_flag_test(bm, e2, EDGE_MARK)) && + (!BMO_elem_flag_test(bm, e2, EDGE_VIS)) && (e2 != e)) { return e2; @@ -1071,13 +1071,13 @@ void bmesh_edgenet_prepare(BMesh *bm, BMOperator *op) int ok = 1; int i, count; - BMO_Flag_Buffer(bm, op, "edges", EDGE_MARK, BM_EDGE); + BMO_slot_buffer_flag(bm, op, "edges", EDGE_MARK, BM_EDGE); /* validate that each edge has at most one other tagged edge in the * disk cycle around each of it's vertices */ BMO_ITER(e, &siter, bm, op, "edges", BM_EDGE) { for (i = 0; i < 2; i++) { - count = BMO_Vert_CountEdgeFlags(bm, i ? e->v2 : e->v1, EDGE_MARK); + count = BMO_vert_edge_flags_count(bm, i ? e->v2 : e->v1, EDGE_MARK); if (count > 2) { ok = 0; break; @@ -1098,9 +1098,9 @@ void bmesh_edgenet_prepare(BMesh *bm, BMOperator *op) count = 0; while (1) { BMO_ITER(e, &siter, bm, op, "edges", BM_EDGE) { - if (!BMO_TestFlag(bm, e, EDGE_VIS)) { - if ( BMO_Vert_CountEdgeFlags(bm, e->v1, EDGE_MARK) == 1 || - BMO_Vert_CountEdgeFlags(bm, e->v2, EDGE_MARK) == 1) + if (!BMO_elem_flag_test(bm, e, EDGE_VIS)) { + if ( BMO_vert_edge_flags_count(bm, e->v1, EDGE_MARK) == 1 || + BMO_vert_edge_flags_count(bm, e->v2, EDGE_MARK) == 1) { break; } @@ -1123,7 +1123,7 @@ void bmesh_edgenet_prepare(BMesh *bm, BMOperator *op) i = 0; while (e) { - BMO_SetFlag(bm, e, EDGE_VIS); + BMO_elem_flag_set(bm, e, EDGE_VIS); BLI_array_growone(edges); edges[i] = e; @@ -1144,8 +1144,8 @@ void bmesh_edgenet_prepare(BMesh *bm, BMOperator *op) count++; } - if (edges1 && BLI_array_count(edges1) > 2 && BM_Edge_Share_Vert(edges1[0], edges1[BLI_array_count(edges1) - 1])) { - if (edges2 && BLI_array_count(edges2) > 2 && BM_Edge_Share_Vert(edges2[0], edges2[BLI_array_count(edges2) - 1])) { + if (edges1 && BLI_array_count(edges1) > 2 && BM_edge_share_vert(edges1[0], edges1[BLI_array_count(edges1) - 1])) { + if (edges2 && BLI_array_count(edges2) > 2 && BM_edge_share_vert(edges2[0], edges2[BLI_array_count(edges2) - 1])) { BLI_array_free(edges1); BLI_array_free(edges2); return; @@ -1156,7 +1156,7 @@ void bmesh_edgenet_prepare(BMesh *bm, BMOperator *op) } } - if (edges2 && BLI_array_count(edges2) > 2 && BM_Edge_Share_Vert(edges2[0], edges2[BLI_array_count(edges2) - 1])) { + if (edges2 && BLI_array_count(edges2) > 2 && BM_edge_share_vert(edges2[0], edges2[BLI_array_count(edges2) - 1])) { edges2 = NULL; } @@ -1169,12 +1169,12 @@ void bmesh_edgenet_prepare(BMesh *bm, BMOperator *op) v2 = edges1[0]->v2; } else { - if (BM_Vert_In_Edge(edges1[1], edges1[0]->v1)) + if (BM_vert_in_edge(edges1[1], edges1[0]->v1)) v1 = edges1[0]->v2; else v1 = edges1[0]->v1; i = BLI_array_count(edges1) - 1; - if (BM_Vert_In_Edge(edges1[i - 1], edges1[i]->v1)) + if (BM_vert_in_edge(edges1[i - 1], edges1[i]->v1)) v2 = edges1[i]->v2; else v2 = edges1[i]->v1; } @@ -1184,12 +1184,12 @@ void bmesh_edgenet_prepare(BMesh *bm, BMOperator *op) v4 = edges2[0]->v2; } else { - if (BM_Vert_In_Edge(edges2[1], edges2[0]->v1)) + if (BM_vert_in_edge(edges2[1], edges2[0]->v1)) v3 = edges2[0]->v2; else v3 = edges2[0]->v1; i = BLI_array_count(edges2) - 1; - if (BM_Vert_In_Edge(edges2[i - 1], edges2[i]->v1)) + if (BM_vert_in_edge(edges2[i - 1], edges2[i]->v1)) v4 = edges2[i]->v2; else v4 = edges2[i]->v1; } @@ -1204,30 +1204,30 @@ void bmesh_edgenet_prepare(BMesh *bm, BMOperator *op) v4 = v; } - e = BM_Make_Edge(bm, v1, v3, NULL, TRUE); - BMO_SetFlag(bm, e, ELE_NEW); - e = BM_Make_Edge(bm, v2, v4, NULL, TRUE); - BMO_SetFlag(bm, e, ELE_NEW); + e = BM_edge_create(bm, v1, v3, NULL, TRUE); + BMO_elem_flag_set(bm, e, ELE_NEW); + e = BM_edge_create(bm, v2, v4, NULL, TRUE); + BMO_elem_flag_set(bm, e, ELE_NEW); } else if (edges1) { BMVert *v1, *v2; if (BLI_array_count(edges1) > 1) { - if (BM_Vert_In_Edge(edges1[1], edges1[0]->v1)) + if (BM_vert_in_edge(edges1[1], edges1[0]->v1)) v1 = edges1[0]->v2; else v1 = edges1[0]->v1; i = BLI_array_count(edges1) - 1; - if (BM_Vert_In_Edge(edges1[i - 1], edges1[i]->v1)) + if (BM_vert_in_edge(edges1[i - 1], edges1[i]->v1)) v2 = edges1[i]->v2; else v2 = edges1[i]->v1; - e = BM_Make_Edge(bm, v1, v2, NULL, TRUE); - BMO_SetFlag(bm, e, ELE_NEW); + e = BM_edge_create(bm, v1, v2, NULL, TRUE); + BMO_elem_flag_set(bm, e, ELE_NEW); } } - BMO_Flag_To_Slot(bm, op, "edgeout", ELE_NEW, BM_EDGE); + BMO_slot_from_flag(bm, op, "edgeout", ELE_NEW, BM_EDGE); BLI_array_free(edges1); BLI_array_free(edges2); @@ -1253,7 +1253,7 @@ void bmesh_contextual_create_exec(BMesh *bm, BMOperator *op) case BM_FACE: totf++; break; } - BMO_SetFlag(bm, h, ELE_NEW); + BMO_elem_flag_set(bm, h, ELE_NEW); } /* --- Support for Special Case --- @@ -1284,7 +1284,7 @@ void bmesh_contextual_create_exec(BMesh *bm, BMOperator *op) /* count how many flagged edges this vertex uses */ int tot_edges = 0; BM_ITER(e, &iter, bm, BM_EDGES_OF_VERT, v) { - if (BMO_TestFlag(bm, e, ELE_NEW)) { + if (BMO_elem_flag_test(bm, e, ELE_NEW)) { tot_edges++; if (tot_edges > 2) { break; @@ -1315,11 +1315,11 @@ void bmesh_contextual_create_exec(BMesh *bm, BMOperator *op) } if (ok == TRUE && v_free && v_a && v_b) { - e = BM_Make_Edge(bm, v_free, v_a, NULL, TRUE); - BMO_SetFlag(bm, &e->head, ELE_NEW); + e = BM_edge_create(bm, v_free, v_a, NULL, TRUE); + BMO_elem_flag_set(bm, &e->head, ELE_NEW); - e = BM_Make_Edge(bm, v_free, v_b, NULL, TRUE); - BMO_SetFlag(bm, &e->head, ELE_NEW); + e = BM_edge_create(bm, v_free, v_b, NULL, TRUE); + BMO_elem_flag_set(bm, &e->head, ELE_NEW); } } /* --- end special case support, continue as normal --- */ @@ -1328,40 +1328,40 @@ void bmesh_contextual_create_exec(BMesh *bm, BMOperator *op) /* call edgenet creat */ /* call edgenet prepare op so additional face creation cases wor */ - BMO_InitOpf(bm, &op2, "edgenet_prepare edges=%fe", ELE_NEW); - BMO_Exec_Op(bm, &op2); - BMO_Flag_Buffer(bm, &op2, "edgeout", ELE_NEW, BM_EDGE); - BMO_Finish_Op(bm, &op2); + BMO_op_initf(bm, &op2, "edgenet_prepare edges=%fe", ELE_NEW); + BMO_op_exec(bm, &op2); + BMO_slot_buffer_flag(bm, &op2, "edgeout", ELE_NEW, BM_EDGE); + BMO_op_finish(bm, &op2); - BMO_InitOpf(bm, &op2, "edgenet_fill edges=%fe", ELE_NEW); - BMO_Exec_Op(bm, &op2); + BMO_op_initf(bm, &op2, "edgenet_fill edges=%fe", ELE_NEW); + BMO_op_exec(bm, &op2); /* return if edge net create did somethin */ - if (BMO_CountSlotBuf(bm, &op2, "faceout")) { - BMO_CopySlot(&op2, op, "faceout", "faceout"); - BMO_Finish_Op(bm, &op2); + if (BMO_slot_buf_count(bm, &op2, "faceout")) { + BMO_slot_copy(&op2, op, "faceout", "faceout"); + BMO_op_finish(bm, &op2); return; } - BMO_Finish_Op(bm, &op2); + BMO_op_finish(bm, &op2); /* now call dissolve face */ - BMO_InitOpf(bm, &op2, "dissolvefaces faces=%ff", ELE_NEW); - BMO_Exec_Op(bm, &op2); + BMO_op_initf(bm, &op2, "dissolvefaces faces=%ff", ELE_NEW); + BMO_op_exec(bm, &op2); /* if we dissolved anything, then return */ - if (BMO_CountSlotBuf(bm, &op2, "regionout")) { - BMO_CopySlot(&op2, op, "regionout", "faceout"); - BMO_Finish_Op(bm, &op2); + if (BMO_slot_buf_count(bm, &op2, "regionout")) { + BMO_slot_copy(&op2, op, "regionout", "faceout"); + BMO_op_finish(bm, &op2); return; } - BMO_Finish_Op(bm, &op2); + BMO_op_finish(bm, &op2); /* now, count how many verts we hav */ amount = 0; BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) { - if (BMO_TestFlag(bm, v, ELE_NEW)) { + if (BMO_elem_flag_test(bm, v, ELE_NEW)) { verts[amount] = v; amount++; @@ -1371,39 +1371,39 @@ void bmesh_contextual_create_exec(BMesh *bm, BMOperator *op) if (amount == 2) { /* create edg */ - e = BM_Make_Edge(bm, verts[0], verts[1], NULL, TRUE); - BMO_SetFlag(bm, e, ELE_OUT); + e = BM_edge_create(bm, verts[0], verts[1], NULL, TRUE); + BMO_elem_flag_set(bm, e, ELE_OUT); } else if (amount == 3) { /* create triangl */ - BM_Make_Face_QuadTri(bm, verts[0], verts[1], verts[2], NULL, NULL, TRUE); + BM_face_create_quad_tri(bm, verts[0], verts[1], verts[2], NULL, NULL, TRUE); } else if (amount == 4) { f = NULL; /* the order of vertices can be anything, 6 cases to check */ if (is_quad_convex_v3(verts[0]->co, verts[1]->co, verts[2]->co, verts[3]->co)) { - f = BM_Make_Face_QuadTri(bm, verts[0], verts[1], verts[2], verts[3], NULL, TRUE); + f = BM_face_create_quad_tri(bm, verts[0], verts[1], verts[2], verts[3], NULL, TRUE); } else if (is_quad_convex_v3(verts[0]->co, verts[2]->co, verts[3]->co, verts[1]->co)) { - f = BM_Make_Face_QuadTri(bm, verts[0], verts[2], verts[3], verts[1], NULL, TRUE); + f = BM_face_create_quad_tri(bm, verts[0], verts[2], verts[3], verts[1], NULL, TRUE); } else if (is_quad_convex_v3(verts[0]->co, verts[2]->co, verts[1]->co, verts[3]->co)) { - f = BM_Make_Face_QuadTri(bm, verts[0], verts[2], verts[1], verts[3], NULL, TRUE); + f = BM_face_create_quad_tri(bm, verts[0], verts[2], verts[1], verts[3], NULL, TRUE); } else if (is_quad_convex_v3(verts[0]->co, verts[1]->co, verts[3]->co, verts[2]->co)) { - f = BM_Make_Face_QuadTri(bm, verts[0], verts[1], verts[3], verts[2], NULL, TRUE); + f = BM_face_create_quad_tri(bm, verts[0], verts[1], verts[3], verts[2], NULL, TRUE); } else if (is_quad_convex_v3(verts[0]->co, verts[3]->co, verts[2]->co, verts[1]->co)) { - f = BM_Make_Face_QuadTri(bm, verts[0], verts[3], verts[2], verts[1], NULL, TRUE); + f = BM_face_create_quad_tri(bm, verts[0], verts[3], verts[2], verts[1], NULL, TRUE); } else if (is_quad_convex_v3(verts[0]->co, verts[3]->co, verts[1]->co, verts[2]->co)) { - f = BM_Make_Face_QuadTri(bm, verts[0], verts[3], verts[1], verts[2], NULL, TRUE); + f = BM_face_create_quad_tri(bm, verts[0], verts[3], verts[1], verts[2], NULL, TRUE); } else { printf("cannot find nice quad from concave set of vertices\n"); } - if (f) BMO_SetFlag(bm, f, ELE_OUT); + if (f) BMO_elem_flag_set(bm, f, ELE_OUT); } } diff --git a/source/blender/bmesh/operators/dissolveops.c b/source/blender/bmesh/operators/dissolveops.c index 20b9ffbb3c0..ad93670cf54 100644 --- a/source/blender/bmesh/operators/dissolveops.c +++ b/source/blender/bmesh/operators/dissolveops.c @@ -45,24 +45,24 @@ static int UNUSED_FUNCTION(check_hole_in_region)(BMesh *bm, BMFace *f) /* checks if there are any unmarked boundary edges in the face regio */ - BMW_Init(®walker, bm, BMW_ISLAND, + BMW_init(®walker, bm, BMW_ISLAND, BMW_MASK_NOP, BMW_MASK_NOP, BMW_MASK_NOP, FACE_MARK, BMW_NIL_LAY); - f2 = BMW_Begin(®walker, f); - for ( ; f2; f2 = BMW_Step(®walker)) { - l2 = BMIter_New(&liter2, bm, BM_LOOPS_OF_FACE, f2); - for ( ; l2; l2 = BMIter_Step(&liter2)) { + f2 = BMW_begin(®walker, f); + for ( ; f2; f2 = BMW_step(®walker)) { + l2 = BM_iter_new(&liter2, bm, BM_LOOPS_OF_FACE, f2); + for ( ; l2; l2 = BM_iter_step(&liter2)) { l3 = bmesh_radial_nextloop(l2); - if ( BMO_TestFlag(bm, l3->f, FACE_MARK) != - BMO_TestFlag(bm, l2->f, FACE_MARK)) + if ( BMO_elem_flag_test(bm, l3->f, FACE_MARK) != + BMO_elem_flag_test(bm, l2->f, FACE_MARK)) { - if (!BMO_TestFlag(bm, l2->e, EDGE_MARK)) { + if (!BMO_elem_flag_test(bm, l2->e, EDGE_MARK)) { return FALSE; } } } } - BMW_End(®walker); + BMW_end(®walker); return TRUE; } @@ -78,7 +78,7 @@ void dissolvefaces_exec(BMesh *bm, BMOperator *op) BMWalker regwalker; int i; - int use_verts = BMO_Get_Int(op, "use_verts"); + int use_verts = BMO_slot_int_get(op, "use_verts"); if (use_verts) { /* tag verts that start out with only 2 edges, @@ -87,44 +87,44 @@ void dissolvefaces_exec(BMesh *bm, BMOperator *op) BMVert *v; BM_ITER(v, &viter, bm, BM_VERTS_OF_MESH, NULL) { - if (BM_Vert_EdgeCount(v) == 2) { - BMO_ClearFlag(bm, v, VERT_MARK); + if (BM_vert_edge_count(v) == 2) { + BMO_elem_flag_clear(bm, v, VERT_MARK); } else { - BMO_SetFlag(bm, v, VERT_MARK); + BMO_elem_flag_set(bm, v, VERT_MARK); } } } - BMO_Flag_Buffer(bm, op, "faces", FACE_MARK, BM_FACE); + BMO_slot_buffer_flag(bm, op, "faces", FACE_MARK, BM_FACE); /* collect region */ BMO_ITER(f, &oiter, bm, op, "faces", BM_FACE) { - if (!BMO_TestFlag(bm, f, FACE_MARK)) continue; + if (!BMO_elem_flag_test(bm, f, FACE_MARK)) continue; BLI_array_empty(faces); faces = NULL; /* forces different allocatio */ /* yay, walk */ - BMW_Init(®walker, bm, BMW_ISLAND, + BMW_init(®walker, bm, BMW_ISLAND, BMW_MASK_NOP, BMW_MASK_NOP, BMW_MASK_NOP, FACE_MARK, BMW_NIL_LAY); - f2 = BMW_Begin(®walker, f); - for ( ; f2; f2 = BMW_Step(®walker)) { + f2 = BMW_begin(®walker, f); + for ( ; f2; f2 = BMW_step(®walker)) { BLI_array_append(faces, f2); } - BMW_End(®walker); + BMW_end(®walker); for (i = 0; i < BLI_array_count(faces); i++) { f2 = faces[i]; - BMO_ClearFlag(bm, f2, FACE_MARK); - BMO_SetFlag(bm, f2, FACE_ORIG); + BMO_elem_flag_clear(bm, f2, FACE_MARK); + BMO_elem_flag_set(bm, f2, FACE_ORIG); } - if (BMO_HasError(bm)) { - BMO_ClearStack(bm); - BMO_RaiseError(bm, op, BMERR_DISSOLVEFACES_FAILED, NULL); + if (BMO_error_occurred(bm)) { + BMO_error_clear(bm); + BMO_error_raise(bm, op, BMERR_DISSOLVEFACES_FAILED, NULL); goto cleanup; } @@ -137,7 +137,7 @@ void dissolvefaces_exec(BMesh *bm, BMOperator *op) faces = regions[i]; if (!faces[0]) { - BMO_RaiseError(bm, op, BMERR_DISSOLVEFACES_FAILED, + BMO_error_raise(bm, op, BMERR_DISSOLVEFACES_FAILED, "Could not find boundary of dissolve region"); goto cleanup; } @@ -145,21 +145,21 @@ void dissolvefaces_exec(BMesh *bm, BMOperator *op) while (faces[tot]) tot++; - f = BM_Join_Faces(bm, faces, tot); + f = BM_faces_join(bm, faces, tot); if (!f) { - BMO_RaiseError(bm, op, BMERR_DISSOLVEFACES_FAILED, + BMO_error_raise(bm, op, BMERR_DISSOLVEFACES_FAILED, "Could not create merged face"); goto cleanup; } /* if making the new face failed (e.g. overlapping test) * unmark the original faces for deletion */ - BMO_ClearFlag(bm, f, FACE_ORIG); - BMO_SetFlag(bm, f, FACE_NEW); + BMO_elem_flag_clear(bm, f, FACE_ORIG); + BMO_elem_flag_set(bm, f, FACE_NEW); } - BMO_CallOpf(bm, "del geom=%ff context=%d", FACE_ORIG, DEL_FACES); + BMO_op_callf(bm, "del geom=%ff context=%d", FACE_ORIG, DEL_FACES); if (use_verts) { @@ -167,17 +167,17 @@ void dissolvefaces_exec(BMesh *bm, BMOperator *op) BMVert *v; BM_ITER(v, &viter, bm, BM_VERTS_OF_MESH, NULL) { - if (BMO_TestFlag(bm, v, VERT_MARK)) { - if (BM_Vert_EdgeCount(v) == 2) { - BM_Collapse_Vert_Edges(bm, v->e, v); + if (BMO_elem_flag_test(bm, v, VERT_MARK)) { + if (BM_vert_edge_count(v) == 2) { + BM_vert_collapse_edges(bm, v->e, v); } } } } - if (BMO_HasError(bm)) goto cleanup; + if (BMO_error_occurred(bm)) goto cleanup; - BMO_Flag_To_Slot(bm, op, "regionout", FACE_NEW, BM_FACE); + BMO_slot_from_flag(bm, op, "regionout", FACE_NEW, BM_FACE); cleanup: /* free/cleanu */ @@ -201,18 +201,18 @@ void dissolve_edgeloop_exec(BMesh *bm, BMOperator *op) int i; BMO_ITER(e, &oiter, bm, op, "edges", BM_EDGE) { - if (BM_Edge_FaceCount(e) == 2) { - BMO_SetFlag(bm, e->v1, VERT_MARK); - BMO_SetFlag(bm, e->v2, VERT_MARK); + if (BM_edge_face_count(e) == 2) { + BMO_elem_flag_set(bm, e->v1, VERT_MARK); + BMO_elem_flag_set(bm, e->v2, VERT_MARK); - BM_Join_TwoFaces(bm, e->l->f, + BM_faces_join_pair(bm, e->l->f, e->l->radial_next->f, e); } } BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) { - if (BMO_TestFlag(bm, v, VERT_MARK) && BM_Vert_EdgeCount(v) == 2) { + if (BMO_elem_flag_test(bm, v, VERT_MARK) && BM_vert_edge_count(v) == 2) { BLI_array_append(verts, v); } } @@ -220,18 +220,18 @@ void dissolve_edgeloop_exec(BMesh *bm, BMOperator *op) /* clean up extreneous 2-valence vertice */ for (i = 0; i < BLI_array_count(verts); i++) { if (verts[i]->e) { - BM_Collapse_Vert_Edges(bm, verts[i]->e, verts[i]); + BM_vert_collapse_edges(bm, verts[i]->e, verts[i]); } } BLI_array_free(verts); - //BMO_InitOpf(bm, &fop, "dissolvefaces faces=%ff", FACE_MARK); - //BMO_Exec_Op(bm, &fop); + //BMO_op_initf(bm, &fop, "dissolvefaces faces=%ff", FACE_MARK); + //BMO_op_exec(bm, &fop); - //BMO_CopySlot(op, &fop, "regionout", "regionout"); + //BMO_slot_copy(op, &fop, "regionout", "regionout"); - //BMO_Finish_Op(bm, &fop); + //BMO_op_finish(bm, &fop); } @@ -246,25 +246,25 @@ void dissolveedges_exec(BMesh *bm, BMOperator *op) BMIter viter; BMVert *v; - int use_verts = BMO_Get_Int(op, "use_verts"); + int use_verts = BMO_slot_int_get(op, "use_verts"); if (use_verts) { BM_ITER(v, &viter, bm, BM_VERTS_OF_MESH, NULL) { - if (BM_Vert_EdgeCount(v) == 2) { - BMO_ClearFlag(bm, v, VERT_MARK); + if (BM_vert_edge_count(v) == 2) { + BMO_elem_flag_clear(bm, v, VERT_MARK); } else { - BMO_SetFlag(bm, v, VERT_MARK); + BMO_elem_flag_set(bm, v, VERT_MARK); } } } BMO_ITER(e, &eiter, bm, op, "edges", BM_EDGE) { - const int edge_face_count = BM_Edge_FaceCount(e); + const int edge_face_count = BM_edge_face_count(e); if (edge_face_count == 2) { /* join faces */ - BM_Join_TwoFaces(bm, e->l->f, + BM_faces_join_pair(bm, e->l->f, e->l->radial_next->f, e); } @@ -272,9 +272,9 @@ void dissolveedges_exec(BMesh *bm, BMOperator *op) if (use_verts) { BM_ITER(v, &viter, bm, BM_VERTS_OF_MESH, NULL) { - if (BMO_TestFlag(bm, v, VERT_MARK)) { - if (BM_Vert_EdgeCount(v) == 2) { - BM_Collapse_Vert_Edges(bm, v->e, v); + if (BMO_elem_flag_test(bm, v, VERT_MARK)) { + if (BM_vert_edge_count(v) == 2) { + BM_vert_collapse_edges(bm, v->e, v); } } } @@ -291,24 +291,24 @@ static int test_extra_verts(BMesh *bm, BMVert *v) /* test faces around verts for verts that would be wronly killed * by dissolve faces. */ - f = BMIter_New(&iter, bm, BM_FACES_OF_VERT, v); - for ( ; f; f = BMIter_Step(&iter)) { - l = BMIter_New(&liter, bm, BM_LOOPS_OF_FACE, f); - for ( ; l; l = BMIter_Step(&liter)) { - if (!BMO_TestFlag(bm, l->v, VERT_MARK)) { + f = BM_iter_new(&iter, bm, BM_FACES_OF_VERT, v); + for ( ; f; f = BM_iter_step(&iter)) { + l = BM_iter_new(&liter, bm, BM_LOOPS_OF_FACE, f); + for ( ; l; l = BM_iter_step(&liter)) { + if (!BMO_elem_flag_test(bm, l->v, VERT_MARK)) { /* if an edge around a vert is a boundary edge, * then dissolve faces won't destroy it. * also if it forms a boundary with one * of the face region */ found = FALSE; - e = BMIter_New(&iter2, bm, BM_EDGES_OF_VERT, l->v); - for ( ; e; e = BMIter_Step(&iter2)) { - if (BM_Edge_FaceCount(e) == 1) { + e = BM_iter_new(&iter2, bm, BM_EDGES_OF_VERT, l->v); + for ( ; e; e = BM_iter_step(&iter2)) { + if (BM_edge_face_count(e) == 1) { found = TRUE; } - f2 = BMIter_New(&iter3, bm, BM_FACES_OF_EDGE, e); - for ( ; f2; f2 = BMIter_Step(&iter3)) { - if (!BMO_TestFlag(bm, f2, FACE_MARK)) { + f2 = BM_iter_new(&iter3, bm, BM_FACES_OF_EDGE, e); + for ( ; f2; f2 = BM_iter_step(&iter3)) { + if (!BMO_elem_flag_test(bm, f2, FACE_MARK)) { found = TRUE; break; } @@ -334,59 +334,59 @@ void dissolveverts_exec(BMesh *bm, BMOperator *op) BMFace *f; /* int i; */ - vinput = BMO_GetSlot(op, "verts"); - BMO_Flag_Buffer(bm, op, "verts", VERT_MARK, BM_VERT); + vinput = BMO_slot_get(op, "verts"); + BMO_slot_buffer_flag(bm, op, "verts", VERT_MARK, BM_VERT); - for (v = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL); v; v = BMIter_Step(&iter)) { - if (BMO_TestFlag(bm, v, VERT_MARK)) { + for (v = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL); v; v = BM_iter_step(&iter)) { + if (BMO_elem_flag_test(bm, v, VERT_MARK)) { /* check if it's a two-valence ver */ - if (BM_Vert_EdgeCount(v) == 2) { + if (BM_vert_edge_count(v) == 2) { /* collapse the ver */ - BM_Collapse_Vert_Faces(bm, v->e, v, 1.0f, TRUE); + BM_vert_collapse_faces(bm, v->e, v, 1.0f, TRUE); continue; } - f = BMIter_New(&fiter, bm, BM_FACES_OF_VERT, v); - for ( ; f; f = BMIter_Step(&fiter)) { - BMO_SetFlag(bm, f, FACE_ORIG); - BMO_SetFlag(bm, f, FACE_MARK); + f = BM_iter_new(&fiter, bm, BM_FACES_OF_VERT, v); + for ( ; f; f = BM_iter_step(&fiter)) { + BMO_elem_flag_set(bm, f, FACE_ORIG); + BMO_elem_flag_set(bm, f, FACE_MARK); } /* check if our additions to the input to face dissolve * will destroy nonmarked vertices. */ if (!test_extra_verts(bm, v)) { - f = BMIter_New(&fiter, bm, BM_FACES_OF_VERT, v); - for ( ; f; f = BMIter_Step(&fiter)) { - if (BMO_TestFlag(bm, f, FACE_ORIG)) { - BMO_ClearFlag(bm, f, FACE_MARK); - BMO_ClearFlag(bm, f, FACE_ORIG); + f = BM_iter_new(&fiter, bm, BM_FACES_OF_VERT, v); + for ( ; f; f = BM_iter_step(&fiter)) { + if (BMO_elem_flag_test(bm, f, FACE_ORIG)) { + BMO_elem_flag_clear(bm, f, FACE_MARK); + BMO_elem_flag_clear(bm, f, FACE_ORIG); } } } else { - f = BMIter_New(&fiter, bm, BM_FACES_OF_VERT, v); - for ( ; f; f = BMIter_Step(&fiter)) { - BMO_ClearFlag(bm, f, FACE_ORIG); + f = BM_iter_new(&fiter, bm, BM_FACES_OF_VERT, v); + for ( ; f; f = BM_iter_step(&fiter)) { + BMO_elem_flag_clear(bm, f, FACE_ORIG); } } } } - BMO_CallOpf(bm, "dissolvefaces faces=%ff", FACE_MARK); - if (BMO_HasError(bm)) { + BMO_op_callf(bm, "dissolvefaces faces=%ff", FACE_MARK); + if (BMO_error_occurred(bm)) { const char *msg; - BMO_GetError(bm, &msg, NULL); - BMO_ClearStack(bm); - BMO_RaiseError(bm, op, BMERR_DISSOLVEVERTS_FAILED, msg); + BMO_error_get(bm, &msg, NULL); + BMO_error_clear(bm); + BMO_error_raise(bm, op, BMERR_DISSOLVEVERTS_FAILED, msg); } /* clean up any remainin */ - for (v = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL); v; v = BMIter_Step(&iter)) { - if (BMO_TestFlag(bm, v, VERT_MARK)) { - if (!BM_Dissolve_Vert(bm, v)) { - BMO_RaiseError(bm, op, BMERR_DISSOLVEVERTS_FAILED, NULL); + for (v = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL); v; v = BM_iter_step(&iter)) { + if (BMO_elem_flag_test(bm, v, VERT_MARK)) { + if (!BM_vert_dissolve(bm, v)) { + BMO_error_raise(bm, op, BMERR_DISSOLVEVERTS_FAILED, NULL); return; } } @@ -404,8 +404,8 @@ void dissolveverts_exec(BMesh *bm, BMOperator *op) found3 = 1; while (found3) { found3 = 0; - for (f = BMIter_New(&iter, bm, BM_FACES_OF_MESH, NULL); f; f = BMIter_Step(&iter)) { - if (!BM_Validate_Face(bm, f, stderr)) { + for (f = BM_iter_new(&iter, bm, BM_FACES_OF_MESH, NULL); f; f = BM_iter_step(&iter)) { + if (!BM_face_validate(bm, f, stderr)) { printf("error.\n"); } @@ -416,14 +416,14 @@ void dissolveverts_exec(BMesh *bm, BMOperator *op) //outermost loop. //found3 = 1; found2 = 0; - l = BMIter_New(&liter, bm, BM_LOOPS_OF_FACE, f); + l = BM_iter_new(&liter, bm, BM_LOOPS_OF_FACE, f); fe = l->e; - for ( ; l; l = BMIter_Step(&liter)) { - f2 = BMIter_New(&fiter, bm, + for ( ; l; l = BM_iter_step(&liter)) { + f2 = BM_iter_new(&fiter, bm, BM_FACES_OF_EDGE, l->e); - for ( ; f2; f2 = BMIter_Step(&fiter)) { + for ( ; f2; f2 = BM_iter_step(&fiter)) { if (f2 != f) { - BM_Join_TwoFaces(bm, f, f2, l->e); + BM_faces_join_pair(bm, f, f2, l->e); found2 = 1; break; } @@ -442,8 +442,8 @@ void dissolveverts_exec(BMesh *bm, BMOperator *op) int i = 0; //check for duplicate edges - l = BMIter_New(&liter, bm, BM_LOOPS_OF_FACE, f); - for ( ; l; l = BMIter_Step(&liter)) { + l = BM_iter_new(&liter, bm, BM_LOOPS_OF_FACE, f); + for ( ; l; l = BM_iter_step(&liter)) { ed[i] = l->e; lp[i] = l; vt[i++] = l->v; diff --git a/source/blender/bmesh/operators/edgesplitop.c b/source/blender/bmesh/operators/edgesplitop.c index d0ccf5ab123..41ad1c89e75 100644 --- a/source/blender/bmesh/operators/edgesplitop.c +++ b/source/blender/bmesh/operators/edgesplitop.c @@ -60,33 +60,33 @@ static BMFace *remake_face(BMesh *bm, EdgeTag *etags, BMFace *f, BMVert **verts, /* v1 = verts[0]; */ /* UNUSED */ /* v2 = verts[1]; */ /* UNUSED */ for (i = 0; i < f->len - 1; i++) { - e = BM_Make_Edge(bm, verts[i], verts[i + 1], NULL, TRUE); + e = BM_edge_create(bm, verts[i], verts[i + 1], NULL, TRUE); if (!e) { return NULL; } edges_tmp[i] = e; } - edges_tmp[i] = BM_Make_Edge(bm, lastv1, lastv2, NULL, TRUE); + edges_tmp[i] = BM_edge_create(bm, lastv1, lastv2, NULL, TRUE); - f2 = BM_Make_Face(bm, verts, edges_tmp, f->len, FALSE); + f2 = BM_face_create(bm, verts, edges_tmp, f->len, FALSE); if (!f2) { return NULL; } - BM_Copy_Attributes(bm, bm, f, f2); + BM_elem_copy_attrs(bm, bm, f, f2); - l = BMIter_New(&liter1, bm, BM_LOOPS_OF_FACE, f); - l2 = BMIter_New(&liter2, bm, BM_LOOPS_OF_FACE, f2); - for ( ; l && l2; l = BMIter_Step(&liter1), l2 = BMIter_Step(&liter2)) { - BM_Copy_Attributes(bm, bm, l, l2); + l = BM_iter_new(&liter1, bm, BM_LOOPS_OF_FACE, f); + l2 = BM_iter_new(&liter2, bm, BM_LOOPS_OF_FACE, f2); + for ( ; l && l2; l = BM_iter_step(&liter1), l2 = BM_iter_step(&liter2)) { + BM_elem_copy_attrs(bm, bm, l, l2); if (l->e != l2->e) { /* set up data for figuring out the two sides of * the split */ /* set edges index as dirty after running all */ - BM_SetIndex(l2->e, BM_GetIndex(l->e)); /* set_dirty! */ - et = &etags[BM_GetIndex(l->e)]; + BM_elem_index_set(l2->e, BM_elem_index_get(l->e)); /* set_dirty! */ + et = &etags[BM_elem_index_get(l->e)]; if (!et->newe1) { et->newe1 = l2->e; @@ -102,15 +102,15 @@ static BMFace *remake_face(BMesh *bm, EdgeTag *etags, BMFace *f, BMVert **verts, et->newe2 = l2->e; } - if (BMO_TestFlag(bm, l->e, EDGE_SEAM)) { - BMO_SetFlag(bm, l2->e, EDGE_SEAM); + if (BMO_elem_flag_test(bm, l->e, EDGE_SEAM)) { + BMO_elem_flag_set(bm, l2->e, EDGE_SEAM); } - BM_Copy_Attributes(bm, bm, l->e, l2->e); + BM_elem_copy_attrs(bm, bm, l->e, l2->e); } - BMO_SetFlag(bm, l->e, EDGE_MARK); - BMO_SetFlag(bm, l2->e, EDGE_MARK); + BMO_elem_flag_set(bm, l->e, EDGE_MARK); + BMO_elem_flag_set(bm, l2->e, EDGE_MARK); } return f2; @@ -128,10 +128,10 @@ static void tag_out_edges(BMesh *bm, EdgeTag *etags, BMOperator *UNUSED(op)) ok = 0; while (ok++ < 100000) { BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) { - if (!BMO_TestFlag(bm, e, EDGE_SEAM)) + if (!BMO_elem_flag_test(bm, e, EDGE_SEAM)) continue; - et = &etags[BM_GetIndex(e)]; + et = &etags[BM_elem_index_get(e)]; if (!et->tag && e->l) { break; } @@ -149,43 +149,43 @@ static void tag_out_edges(BMesh *bm, EdgeTag *etags, BMOperator *UNUSED(op)) v = i ? l->next->v : l->v; while (1) { - et = &etags[BM_GetIndex(l->e)]; + et = &etags[BM_elem_index_get(l->e)]; if (et->newe1 == l->e) { if (et->newe1) { - BMO_SetFlag(bm, et->newe1, EDGE_RET1); - BMO_ClearFlag(bm, et->newe1, EDGE_SEAM); + BMO_elem_flag_set(bm, et->newe1, EDGE_RET1); + BMO_elem_flag_clear(bm, et->newe1, EDGE_SEAM); } if (et->newe2) { - BMO_SetFlag(bm, et->newe2, EDGE_RET2); - BMO_ClearFlag(bm, et->newe2, EDGE_SEAM); + BMO_elem_flag_set(bm, et->newe2, EDGE_RET2); + BMO_elem_flag_clear(bm, et->newe2, EDGE_SEAM); } } else { if (et->newe1) { - BMO_SetFlag(bm, et->newe1, EDGE_RET2); - BMO_ClearFlag(bm, et->newe1, EDGE_SEAM); + BMO_elem_flag_set(bm, et->newe1, EDGE_RET2); + BMO_elem_flag_clear(bm, et->newe1, EDGE_SEAM); } if (et->newe2) { - BMO_SetFlag(bm, et->newe2, EDGE_RET1); - BMO_ClearFlag(bm, et->newe2, EDGE_SEAM); + BMO_elem_flag_set(bm, et->newe2, EDGE_RET1); + BMO_elem_flag_clear(bm, et->newe2, EDGE_SEAM); } } /* If the original edge was non-manifold edges, then it is * possible l->e is not et->newe1 or et->newe2. So always clear * the flag on l->e as well, to prevent infinite looping. */ - BMO_ClearFlag(bm, l->e, EDGE_SEAM); + BMO_elem_flag_clear(bm, l->e, EDGE_SEAM); startl = l; do { - l = BM_OtherFaceLoop(l->e, l->f, v); - if (l == startl || BM_Edge_FaceCount(l->e) != 2) { + l = BM_face_other_loop(l->e, l->f, v); + if (l == startl || BM_edge_face_count(l->e) != 2) { break; } l = l->radial_next; - } while (l != startl && !BMO_TestFlag(bm, l->e, EDGE_SEAM)); + } while (l != startl && !BMO_elem_flag_test(bm, l->e, EDGE_SEAM)); - if (l == startl || !BMO_TestFlag(bm, l->e, EDGE_SEAM)) { + if (l == startl || !BMO_elem_flag_test(bm, l->e, EDGE_SEAM)) { break; } @@ -209,14 +209,14 @@ void bmesh_edgesplitop_exec(BMesh *bm, BMOperator *op) BLI_array_declare(edges_tmp); int i, j; - BMO_Flag_Buffer(bm, op, "edges", EDGE_SEAM, BM_EDGE); + BMO_slot_buffer_flag(bm, op, "edges", EDGE_SEAM, BM_EDGE); /* single marked edges unconnected to any other marked edges * are illegal, go through and unmark them */ BMO_ITER(e, &siter, bm, op, "edges", BM_EDGE) { for (i = 0; i < 2; i++) { BM_ITER(e2, &iter, bm, BM_EDGES_OF_VERT, i ? e->v2 : e->v1) { - if (e != e2 && BMO_TestFlag(bm, e2, EDGE_SEAM)) { + if (e != e2 && BMO_elem_flag_test(bm, e2, EDGE_SEAM)) { break; } } @@ -226,13 +226,13 @@ void bmesh_edgesplitop_exec(BMesh *bm, BMOperator *op) } if (!e2) { - BMO_ClearFlag(bm, e, EDGE_SEAM); + BMO_elem_flag_clear(bm, e, EDGE_SEAM); } } etags = MEM_callocN(sizeof(EdgeTag)*bm->totedge, "EdgeTag"); - BM_ElemIndex_Ensure(bm, BM_EDGE); + BM_mesh_elem_index_ensure(bm, BM_EDGE); #ifdef ETV # undef ETV @@ -246,7 +246,7 @@ void bmesh_edgesplitop_exec(BMesh *bm, BMOperator *op) BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) { - if (BMO_TestFlag(bm, f, FACE_NEW)) { + if (BMO_elem_flag_test(bm, f, FACE_NEW)) { continue; } @@ -261,10 +261,10 @@ void bmesh_edgesplitop_exec(BMesh *bm, BMOperator *op) i = 0; BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, f) { - if (!BMO_TestFlag(bm, l->e, EDGE_SEAM)) { + if (!BMO_elem_flag_test(bm, l->e, EDGE_SEAM)) { if (!verts[i]) { - et = &etags[BM_GetIndex(l->e)]; + et = &etags[BM_elem_index_get(l->e)]; if (ETV(et, l->v, l)) { verts[i] = ETV(et, l->v, l); } @@ -286,10 +286,10 @@ void bmesh_edgesplitop_exec(BMesh *bm, BMOperator *op) l2 = j ? nextl : prevl; v = j ? l2->v : l->v; - if (BMO_TestFlag(bm, l2->e, EDGE_SEAM)) { + if (BMO_elem_flag_test(bm, l2->e, EDGE_SEAM)) { if (verts[fv_index] == NULL) { /* make unique vert here for this face only */ - v2 = BM_Make_Vert(bm, v->co, v); + v2 = BM_vert_create(bm, v->co, v); verts[fv_index] = v2; } else { @@ -304,37 +304,37 @@ void bmesh_edgesplitop_exec(BMesh *bm, BMOperator *op) * somewhere within this fa */ l3 = l2; do { - if (BM_Edge_FaceCount(l3->e) != 2) { + if (BM_edge_face_count(l3->e) != 2) { /* if we hit a boundary edge, tag * l3 as null so we know to disconnect * it */ - if (BM_Edge_FaceCount(l3->e) == 1) { + if (BM_edge_face_count(l3->e) == 1) { l3 = NULL; } break; } l3 = l3->radial_next; - l3 = BM_OtherFaceLoop(l3->e, l3->f, v); - } while (l3 != l2 && !BMO_TestFlag(bm, l3->e, EDGE_SEAM)); + l3 = BM_face_other_loop(l3->e, l3->f, v); + } while (l3 != l2 && !BMO_elem_flag_test(bm, l3->e, EDGE_SEAM)); - if (l3 == NULL || (BMO_TestFlag(bm, l3->e, EDGE_SEAM) && l3->e != l->e)) { - et = &etags[BM_GetIndex(l2->e)]; + if (l3 == NULL || (BMO_elem_flag_test(bm, l3->e, EDGE_SEAM) && l3->e != l->e)) { + et = &etags[BM_elem_index_get(l2->e)]; if (ETV(et, v, l2) == NULL) { - v2 = BM_Make_Vert(bm, v->co, v); + v2 = BM_vert_create(bm, v->co, v); l3 = l2; do { SETETV(et, v, l3, v2); - if (BM_Edge_FaceCount(l3->e) != 2) { + if (BM_edge_face_count(l3->e) != 2) { break; } l3 = l3->radial_next; - l3 = BM_OtherFaceLoop(l3->e, l3->f, v); + l3 = BM_face_other_loop(l3->e, l3->f, v); - et = &etags[BM_GetIndex(l3->e)]; - } while (l3 != l2 && !BMO_TestFlag(bm, l3->e, EDGE_SEAM)); + et = &etags[BM_elem_index_get(l3->e)]; + } while (l3 != l2 && !BMO_elem_flag_test(bm, l3->e, EDGE_SEAM)); } else { v2 = ETV(et, v, l2); @@ -380,8 +380,8 @@ void bmesh_edgesplitop_exec(BMesh *bm, BMOperator *op) continue; } - BMO_SetFlag(bm, f, FACE_DEL); - BMO_SetFlag(bm, f2, FACE_NEW); + BMO_elem_flag_set(bm, f, FACE_DEL); + BMO_elem_flag_set(bm, f2, FACE_NEW); } /* remake_face() sets invalid indecies, @@ -392,7 +392,7 @@ void bmesh_edgesplitop_exec(BMesh *bm, BMOperator *op) * relies on original index values, from before editing geometry */ #if 0 - BMO_CallOpf(bm, "del geom=%ff context=%i", FACE_DEL, DEL_ONLYFACES); + BMO_op_callf(bm, "del geom=%ff context=%i", FACE_DEL, DEL_ONLYFACES); #else BMO_remove_tagged_context(bm, FACE_DEL, DEL_ONLYFACES); #endif @@ -400,22 +400,22 @@ void bmesh_edgesplitop_exec(BMesh *bm, BMOperator *op) /* test EDGE_MARK'd edges if we need to delete them, EDGE_MARK * is set in remake_face */ BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) { - if (BMO_TestFlag(bm, e, EDGE_MARK)) { + if (BMO_elem_flag_test(bm, e, EDGE_MARK)) { if (!e->l) { - BMO_SetFlag(bm, e, EDGE_DEL); + BMO_elem_flag_set(bm, e, EDGE_DEL); } } } #if 0 - BMO_CallOpf(bm, "del geom=%fe context=%i", EDGE_DEL, DEL_EDGES); + BMO_op_callf(bm, "del geom=%fe context=%i", EDGE_DEL, DEL_EDGES); #else BMO_remove_tagged_context(bm, EDGE_DEL, DEL_EDGES); #endif tag_out_edges(bm, etags, op); - BMO_Flag_To_Slot(bm, op, "edgeout1", EDGE_RET1, BM_EDGE); - BMO_Flag_To_Slot(bm, op, "edgeout2", EDGE_RET2, BM_EDGE); + BMO_slot_from_flag(bm, op, "edgeout1", EDGE_RET1, BM_EDGE); + BMO_slot_from_flag(bm, op, "edgeout2", EDGE_RET2, BM_EDGE); BLI_array_free(verts); BLI_array_free(edges_tmp); diff --git a/source/blender/bmesh/operators/extrudeops.c b/source/blender/bmesh/operators/extrudeops.c index 4a2aea945d4..e0c2b2da227 100644 --- a/source/blender/bmesh/operators/extrudeops.c +++ b/source/blender/bmesh/operators/extrudeops.c @@ -57,10 +57,10 @@ void bmesh_extrude_face_indiv_exec(BMesh *bm, BMOperator *op) BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, f) { BLI_array_growone(edges); - v = BM_Make_Vert(bm, l->v->co, l->v); + v = BM_vert_create(bm, l->v->co, l->v); if (lastv) { - e = BM_Make_Edge(bm, lastv, v, l->e, FALSE); + e = BM_edge_create(bm, lastv, v, l->e, FALSE); edges[i++] = e; } @@ -70,43 +70,43 @@ void bmesh_extrude_face_indiv_exec(BMesh *bm, BMOperator *op) } BLI_array_growone(edges); - e = BM_Make_Edge(bm, v, firstv, laste, FALSE); + e = BM_edge_create(bm, v, firstv, laste, FALSE); edges[i++] = e; - BMO_SetFlag(bm, f, EXT_DEL); + BMO_elem_flag_set(bm, f, EXT_DEL); - f2 = BM_Make_Ngon(bm, firstv, BM_OtherEdgeVert(edges[0], firstv), edges, f->len, FALSE); + f2 = BM_face_create_ngon(bm, firstv, BM_edge_other_vert(edges[0], firstv), edges, f->len, FALSE); if (!f2) { - BMO_RaiseError(bm, op, BMERR_MESH_ERROR, "Extrude failed; could not create face"); + BMO_error_raise(bm, op, BMERR_MESH_ERROR, "Extrude failed; could not create face"); BLI_array_free(edges); return; } - BMO_SetFlag(bm, f2, EXT_KEEP); - BM_Copy_Attributes(bm, bm, f, f2); + BMO_elem_flag_set(bm, f2, EXT_KEEP); + BM_elem_copy_attrs(bm, bm, f, f2); - l2 = BMIter_New(&liter2, bm, BM_LOOPS_OF_FACE, f2); + l2 = BM_iter_new(&liter2, bm, BM_LOOPS_OF_FACE, f2); BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, f) { - BM_Copy_Attributes(bm, bm, l, l2); + BM_elem_copy_attrs(bm, bm, l, l2); l3 = l->next; l4 = l2->next; - f3 = BM_Make_Face_QuadTri(bm, l3->v, l4->v, l2->v, l->v, f, FALSE); + f3 = BM_face_create_quad_tri(bm, l3->v, l4->v, l2->v, l->v, f, FALSE); - BM_Copy_Attributes(bm, bm, l->next, BM_FACE_FIRST_LOOP(f3)); - BM_Copy_Attributes(bm, bm, l->next, BM_FACE_FIRST_LOOP(f3)->next); - BM_Copy_Attributes(bm, bm, l, BM_FACE_FIRST_LOOP(f3)->next->next); - BM_Copy_Attributes(bm, bm, l, BM_FACE_FIRST_LOOP(f3)->next->next->next); + BM_elem_copy_attrs(bm, bm, l->next, BM_FACE_FIRST_LOOP(f3)); + BM_elem_copy_attrs(bm, bm, l->next, BM_FACE_FIRST_LOOP(f3)->next); + BM_elem_copy_attrs(bm, bm, l, BM_FACE_FIRST_LOOP(f3)->next->next); + BM_elem_copy_attrs(bm, bm, l, BM_FACE_FIRST_LOOP(f3)->next->next->next); - l2 = BMIter_Step(&liter2); + l2 = BM_iter_step(&liter2); } } BLI_array_free(edges); - BMO_CallOpf(bm, "del geom=%ff context=%d", EXT_DEL, DEL_ONLYFACES); - BMO_Flag_To_Slot(bm, op, "faceout", EXT_KEEP, BM_FACE); + BMO_op_callf(bm, "del geom=%ff context=%d", EXT_DEL, DEL_ONLYFACES); + BMO_slot_from_flag(bm, op, "faceout", EXT_KEEP, BM_FACE); } void bmesh_extrude_onlyedge_exec(BMesh *bm, BMOperator *op) @@ -118,17 +118,17 @@ void bmesh_extrude_onlyedge_exec(BMesh *bm, BMOperator *op) BMFace *f; BMO_ITER(e, &siter, bm, op, "edges", BM_EDGE) { - BMO_SetFlag(bm, e, EXT_INPUT); - BMO_SetFlag(bm, e->v1, EXT_INPUT); - BMO_SetFlag(bm, e->v2, EXT_INPUT); + BMO_elem_flag_set(bm, e, EXT_INPUT); + BMO_elem_flag_set(bm, e->v1, EXT_INPUT); + BMO_elem_flag_set(bm, e->v2, EXT_INPUT); } - BMO_InitOpf(bm, &dupeop, "dupe geom=%fve", EXT_INPUT); - BMO_Exec_Op(bm, &dupeop); + BMO_op_initf(bm, &dupeop, "dupe geom=%fve", EXT_INPUT); + BMO_op_exec(bm, &dupeop); - e = BMO_IterNew(&siter, bm, &dupeop, "boundarymap", 0); - for ( ; e; e = BMO_IterStep(&siter)) { - e2 = BMO_IterMapVal(&siter); + e = BMO_iter_new(&siter, bm, &dupeop, "boundarymap", 0); + for ( ; e; e = BMO_iter_step(&siter)) { + e2 = BMO_iter_map_value(&siter); e2 = *(BMEdge **)e2; if (e->l && e->v1 != e->l->v) { @@ -144,21 +144,21 @@ void bmesh_extrude_onlyedge_exec(BMesh *bm, BMOperator *op) v4 = e->v1; } /* not sure what to do about example face, pass NULL for now */ - f = BM_Make_Face_QuadTri(bm, v1, v2, v3, v4, NULL, FALSE); + f = BM_face_create_quad_tri(bm, v1, v2, v3, v4, NULL, FALSE); - if (BMO_TestFlag(bm, e, EXT_INPUT)) + if (BMO_elem_flag_test(bm, e, EXT_INPUT)) e = e2; - BMO_SetFlag(bm, f, EXT_KEEP); - BMO_SetFlag(bm, e, EXT_KEEP); - BMO_SetFlag(bm, e->v1, EXT_KEEP); - BMO_SetFlag(bm, e->v2, EXT_KEEP); + BMO_elem_flag_set(bm, f, EXT_KEEP); + BMO_elem_flag_set(bm, e, EXT_KEEP); + BMO_elem_flag_set(bm, e->v1, EXT_KEEP); + BMO_elem_flag_set(bm, e->v2, EXT_KEEP); } - BMO_Finish_Op(bm, &dupeop); + BMO_op_finish(bm, &dupeop); - BMO_Flag_To_Slot(bm, op, "geomout", EXT_KEEP, BM_ALL); + BMO_slot_from_flag(bm, op, "geomout", EXT_KEEP, BM_ALL); } void extrude_vert_indiv_exec(BMesh *bm, BMOperator *op) @@ -167,18 +167,18 @@ void extrude_vert_indiv_exec(BMesh *bm, BMOperator *op) BMVert *v, *dupev; BMEdge *e; - v = BMO_IterNew(&siter, bm, op, "verts", BM_VERT); - for ( ; v; v = BMO_IterStep(&siter)) { - dupev = BM_Make_Vert(bm, v->co, v); + v = BMO_iter_new(&siter, bm, op, "verts", BM_VERT); + for ( ; v; v = BMO_iter_step(&siter)) { + dupev = BM_vert_create(bm, v->co, v); - e = BM_Make_Edge(bm, v, dupev, NULL, FALSE); + e = BM_edge_create(bm, v, dupev, NULL, FALSE); - BMO_SetFlag(bm, e, EXT_KEEP); - BMO_SetFlag(bm, dupev, EXT_KEEP); + BMO_elem_flag_set(bm, e, EXT_KEEP); + BMO_elem_flag_set(bm, dupev, EXT_KEEP); } - BMO_Flag_To_Slot(bm, op, "vertout", EXT_KEEP, BM_VERT); - BMO_Flag_To_Slot(bm, op, "edgeout", EXT_KEEP, BM_EDGE); + BMO_slot_from_flag(bm, op, "vertout", EXT_KEEP, BM_VERT); + BMO_slot_from_flag(bm, op, "edgeout", EXT_KEEP, BM_EDGE); } void extrude_edge_context_exec(BMesh *bm, BMOperator *op) @@ -193,27 +193,27 @@ void extrude_edge_context_exec(BMesh *bm, BMOperator *op) int rlen, found, fwd, delorig = 0; /* initialize our sub-operators */ - BMO_Init_Op(bm, &dupeop, "dupe"); + BMO_op_init(bm, &dupeop, "dupe"); - BMO_Flag_Buffer(bm, op, "edgefacein", EXT_INPUT, BM_EDGE|BM_FACE); + BMO_slot_buffer_flag(bm, op, "edgefacein", EXT_INPUT, BM_EDGE|BM_FACE); /* if one flagged face is bordered by an unflagged face, then we delete * original geometry unless caller explicitly asked to keep it. */ - if (!BMO_Get_Int(op, "alwayskeeporig")) { + if (!BMO_slot_int_get(op, "alwayskeeporig")) { BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) { - if (!BMO_TestFlag(bm, e, EXT_INPUT)) continue; + if (!BMO_elem_flag_test(bm, e, EXT_INPUT)) continue; found = 0; - f = BMIter_New(&fiter, bm, BM_FACES_OF_EDGE, e); - for (rlen = 0; f; f = BMIter_Step(&fiter), rlen++) { - if (!BMO_TestFlag(bm, f, EXT_INPUT)) { + f = BM_iter_new(&fiter, bm, BM_FACES_OF_EDGE, e); + for (rlen = 0; f; f = BM_iter_step(&fiter), rlen++) { + if (!BMO_elem_flag_test(bm, f, EXT_INPUT)) { found = 1; delorig = 1; break; } } - if (!found && (rlen > 1)) BMO_SetFlag(bm, e, EXT_DEL); + if (!found && (rlen > 1)) BMO_elem_flag_set(bm, e, EXT_DEL); } } @@ -222,57 +222,57 @@ void extrude_edge_context_exec(BMesh *bm, BMOperator *op) found = 0; BM_ITER(e, &viter, bm, BM_EDGES_OF_VERT, v) { - if (!BMO_TestFlag(bm, e, EXT_INPUT) || !BMO_TestFlag(bm, e, EXT_DEL)) { + if (!BMO_elem_flag_test(bm, e, EXT_INPUT) || !BMO_elem_flag_test(bm, e, EXT_DEL)) { found = 1; break; } } BM_ITER(f, &viter, bm, BM_FACES_OF_VERT, v) { - if (!BMO_TestFlag(bm, f, EXT_INPUT)) { + if (!BMO_elem_flag_test(bm, f, EXT_INPUT)) { found = 1; break; } } if (!found) { - BMO_SetFlag(bm, v, EXT_DEL); + BMO_elem_flag_set(bm, v, EXT_DEL); } } BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) { - if (BMO_TestFlag(bm, f, EXT_INPUT)) - BMO_SetFlag(bm, f, EXT_DEL); + if (BMO_elem_flag_test(bm, f, EXT_INPUT)) + BMO_elem_flag_set(bm, f, EXT_DEL); } if (delorig) { - BMO_InitOpf(bm, &delop, "del geom=%fvef context=%d", + BMO_op_initf(bm, &delop, "del geom=%fvef context=%d", EXT_DEL, DEL_ONLYTAGGED); } - BMO_CopySlot(op, &dupeop, "edgefacein", "geom"); - BMO_Exec_Op(bm, &dupeop); + BMO_slot_copy(op, &dupeop, "edgefacein", "geom"); + BMO_op_exec(bm, &dupeop); - if (bm->act_face && BMO_TestFlag(bm, bm->act_face, EXT_INPUT)) - bm->act_face = BMO_Get_MapPointer(bm, &dupeop, "facemap", bm->act_face); + if (bm->act_face && BMO_elem_flag_test(bm, bm->act_face, EXT_INPUT)) + bm->act_face = BMO_slot_map_ptr_get(bm, &dupeop, "facemap", bm->act_face); - if (delorig) BMO_Exec_Op(bm, &delop); + if (delorig) BMO_op_exec(bm, &delop); /* if not delorig, reverse loops of original face */ if (!delorig) { - for (f = BMIter_New(&iter, bm, BM_FACES_OF_MESH, NULL); f; f = BMIter_Step(&iter)) { - if (BMO_TestFlag(bm, f, EXT_INPUT)) { - BM_flip_normal(bm, f); + for (f = BM_iter_new(&iter, bm, BM_FACES_OF_MESH, NULL); f; f = BM_iter_step(&iter)) { + if (BMO_elem_flag_test(bm, f, EXT_INPUT)) { + BM_face_normal_flip(bm, f); } } } - BMO_CopySlot(&dupeop, op, "newout", "geomout"); - e = BMO_IterNew(&siter, bm, &dupeop, "boundarymap", 0); - for ( ; e; e = BMO_IterStep(&siter)) { - if (BMO_InMap(bm, op, "exclude", e)) continue; + BMO_slot_copy(&dupeop, op, "newout", "geomout"); + e = BMO_iter_new(&siter, bm, &dupeop, "boundarymap", 0); + for ( ; e; e = BMO_iter_step(&siter)) { + if (BMO_slot_map_contains(bm, op, "exclude", e)) continue; - newedge = BMO_IterMapVal(&siter); + newedge = BMO_iter_map_value(&siter); newedge = *(BMEdge **)newedge; if (!newedge) continue; @@ -299,54 +299,54 @@ void extrude_edge_context_exec(BMesh *bm, BMOperator *op) } /* not sure what to do about example face, pass NULL for now */ - f = BM_Make_Face_QuadTri_v(bm, verts, 4, NULL, FALSE); + f = BM_face_create_quad_tri_v(bm, verts, 4, NULL, FALSE); /* copy attribute */ - l = BMIter_New(&iter, bm, BM_LOOPS_OF_FACE, f); - for ( ; l; l = BMIter_Step(&iter)) { + l = BM_iter_new(&iter, bm, BM_LOOPS_OF_FACE, f); + for ( ; l; l = BM_iter_step(&iter)) { if (l->e != e && l->e != newedge) continue; l2 = l->radial_next; if (l2 == l) { l2 = newedge->l; - BM_Copy_Attributes(bm, bm, l2->f, l->f); + BM_elem_copy_attrs(bm, bm, l2->f, l->f); - BM_Copy_Attributes(bm, bm, l2, l); + BM_elem_copy_attrs(bm, bm, l2, l); l2 = l2->next; l = l->next; - BM_Copy_Attributes(bm, bm, l2, l); + BM_elem_copy_attrs(bm, bm, l2, l); } else { - BM_Copy_Attributes(bm, bm, l2->f, l->f); + BM_elem_copy_attrs(bm, bm, l2->f, l->f); /* copy dat */ if (l2->v == l->v) { - BM_Copy_Attributes(bm, bm, l2, l); + BM_elem_copy_attrs(bm, bm, l2, l); l2 = l2->next; l = l->next; - BM_Copy_Attributes(bm, bm, l2, l); + BM_elem_copy_attrs(bm, bm, l2, l); } else { l2 = l2->next; - BM_Copy_Attributes(bm, bm, l2, l); + BM_elem_copy_attrs(bm, bm, l2, l); l2 = l2->prev; l = l->next; - BM_Copy_Attributes(bm, bm, l2, l); + BM_elem_copy_attrs(bm, bm, l2, l); } } } } /* link isolated vert */ - v = BMO_IterNew(&siter, bm, &dupeop, "isovertmap", 0); - for ( ; v; v = BMO_IterStep(&siter)) { - v2 = *((void **)BMO_IterMapVal(&siter)); - BM_Make_Edge(bm, v, v2, v->e, TRUE); + v = BMO_iter_new(&siter, bm, &dupeop, "isovertmap", 0); + for ( ; v; v = BMO_iter_step(&siter)) { + v2 = *((void **)BMO_iter_map_value(&siter)); + BM_edge_create(bm, v, v2, v->e, TRUE); } /* cleanu */ - if (delorig) BMO_Finish_Op(bm, &delop); - BMO_Finish_Op(bm, &dupeop); + if (delorig) BMO_op_finish(bm, &delop); + BMO_op_finish(bm, &dupeop); } /* @@ -364,17 +364,17 @@ static void calc_solidify_normals(BMesh *bm) float edge_normal[3]; int i; - /* can't use BM_Edge_FaceCount because we need to count only marked faces */ + /* 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_SetHFlag(v, BM_ELEM_TAG); + BM_elem_flag_set(v, BM_ELEM_TAG); } - BM_ElemIndex_Ensure(bm, BM_EDGE); + BM_mesh_elem_index_ensure(bm, BM_EDGE); BM_ITER(f, &fiter, bm, BM_FACES_OF_MESH, NULL) { - if (!BMO_TestFlag(bm, f, FACE_MARK)) { + if (!BMO_elem_flag_test(bm, f, FACE_MARK)) { continue; } @@ -382,38 +382,38 @@ static void calc_solidify_normals(BMesh *bm) /* And mark all edges and vertices on the * marked faces */ - BMO_SetFlag(bm, e, EDGE_MARK); - BMO_SetFlag(bm, e->v1, VERT_MARK); - BMO_SetFlag(bm, e->v2, VERT_MARK); - edge_face_count[BM_GetIndex(e)]++; + BMO_elem_flag_set(bm, e, EDGE_MARK); + BMO_elem_flag_set(bm, e->v1, VERT_MARK); + BMO_elem_flag_set(bm, e->v2, VERT_MARK); + edge_face_count[BM_elem_index_get(e)]++; } } BM_ITER(e, &eiter, bm, BM_EDGES_OF_MESH, NULL) { - if (!BMO_TestFlag(bm, e, EDGE_MARK)) { + if (!BMO_elem_flag_test(bm, e, EDGE_MARK)) { continue; } - i = edge_face_count[BM_GetIndex(e)]++; + i = edge_face_count[BM_elem_index_get(e)]++; if (i == 0 || i > 2) { /* Edge & vertices are non-manifold even when considering * only marked faces */ - BMO_SetFlag(bm, e, EDGE_NONMAN); - BMO_SetFlag(bm, e->v1, VERT_NONMAN); - BMO_SetFlag(bm, e->v2, VERT_NONMAN); + BMO_elem_flag_set(bm, e, EDGE_NONMAN); + BMO_elem_flag_set(bm, e->v1, VERT_NONMAN); + BMO_elem_flag_set(bm, e->v2, VERT_NONMAN); } } MEM_freeN(edge_face_count); edge_face_count = NULL; /* dont re-use */ BM_ITER(v, &viter, bm, BM_VERTS_OF_MESH, NULL) { - if (BM_Nonmanifold_Vert(bm, v)) { - BMO_SetFlag(bm, v, VERT_NONMAN); + if (BM_vert_is_nonmanifold(bm, v)) { + BMO_elem_flag_set(bm, v, VERT_NONMAN); continue; } - if (BMO_TestFlag(bm, v, VERT_MARK)) { + if (BMO_elem_flag_test(bm, v, VERT_MARK)) { zero_v3(v->no); } } @@ -422,20 +422,20 @@ static void calc_solidify_normals(BMesh *bm) /* If the edge is not part of a the solidify region * its normal should not be considered */ - if (!BMO_TestFlag(bm, e, EDGE_MARK)) { + if (!BMO_elem_flag_test(bm, e, EDGE_MARK)) { continue; } /* If the edge joins more than two marked faces high * quality normal computation won't work */ - if (BMO_TestFlag(bm, e, EDGE_NONMAN)) { + if (BMO_elem_flag_test(bm, e, EDGE_NONMAN)) { continue; } f1 = f2 = NULL; BM_ITER(f, &fiter, bm, BM_FACES_OF_EDGE, e) { - if (BMO_TestFlag(bm, f, FACE_MARK)) { + if (BMO_elem_flag_test(bm, f, FACE_MARK)) { if (f1 == NULL) { f1 = f; } @@ -461,8 +461,8 @@ static void calc_solidify_normals(BMesh *bm) else { /* can't do anything useful here! * Set the face index for a vert incase it gets a zero normal */ - BM_ClearHFlag(e->v1, BM_ELEM_TAG); - BM_ClearHFlag(e->v2, BM_ELEM_TAG); + BM_elem_flag_clear(e->v1, BM_ELEM_TAG); + BM_elem_flag_clear(e->v2, BM_ELEM_TAG); continue; } } @@ -480,19 +480,19 @@ static void calc_solidify_normals(BMesh *bm) /* normalize accumulated vertex normal */ BM_ITER(v, &viter, bm, BM_VERTS_OF_MESH, NULL) { - if (!BMO_TestFlag(bm, v, VERT_MARK)) { + if (!BMO_elem_flag_test(bm, v, VERT_MARK)) { continue; } - if (BMO_TestFlag(bm, v, VERT_NONMAN)) { + if (BMO_elem_flag_test(bm, v, VERT_NONMAN)) { /* use standard normals for vertices connected to non-manifold edges */ - BM_Vert_UpdateNormal(bm, v); + BM_vert_normal_update(bm, v); } - else if (normalize_v3(v->no) == 0.0f && !BM_TestHFlag(v, BM_ELEM_TAG)) { + 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) { - if (BMO_TestFlag(bm, f, FACE_MARK)) { + if (BMO_elem_flag_test(bm, f, FACE_MARK)) { break; } } @@ -520,10 +520,10 @@ static void solidify_add_thickness(BMesh *bm, float dist) float *angles = NULL; BLI_array_staticdeclare(angles, BM_NGON_STACK_SIZE); - BM_ElemIndex_Ensure(bm, BM_VERT); + BM_mesh_elem_index_ensure(bm, BM_VERT); BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) { - if (!BMO_TestFlag(bm, f, FACE_MARK)) { + if (!BMO_elem_flag_test(bm, f, FACE_MARK)) { continue; } @@ -537,7 +537,7 @@ static void solidify_add_thickness(BMesh *bm, float dist) i = 0; BM_ITER(l, &loopIter, bm, BM_LOOPS_OF_FACE, f) { v = l->v; - index = BM_GetIndex(v); + index = BM_elem_index_get(v); angle = angles[i]; vert_accum[index] += angle; vert_angles[index] += shell_angle_to_dist(angle_normalized_v3v3(v->no, f->no)) * angle; @@ -549,7 +549,7 @@ static void solidify_add_thickness(BMesh *bm, float dist) } BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) { - index = BM_GetIndex(v); + index = BM_elem_index_get(v); if (vert_accum[index]) { /* zero if unselected */ float vdist = MIN2(maxdist, dist * vert_angles[index] / vert_accum[index]); madd_v3_v3fl(v->co, v->no, vdist); @@ -565,25 +565,25 @@ void bmesh_solidify_face_region_exec(BMesh *bm, BMOperator *op) BMOperator reverseop; float thickness; - thickness = BMO_Get_Float(op, "thickness"); + thickness = BMO_slot_float_get(op, "thickness"); /* Flip original faces (so the shell is extruded inward) */ - BMO_Init_Op(bm, &reverseop, "reversefaces"); - BMO_CopySlot(op, &reverseop, "geom", "faces"); - BMO_Exec_Op(bm, &reverseop); - BMO_Finish_Op(bm, &reverseop); + BMO_op_init(bm, &reverseop, "reversefaces"); + BMO_slot_copy(op, &reverseop, "geom", "faces"); + BMO_op_exec(bm, &reverseop); + BMO_op_finish(bm, &reverseop); /* Extrude the region */ - BMO_InitOpf(bm, &extrudeop, "extrudefaceregion alwayskeeporig=%i", TRUE); - BMO_CopySlot(op, &extrudeop, "geom", "edgefacein"); - BMO_Exec_Op(bm, &extrudeop); + BMO_op_initf(bm, &extrudeop, "extrudefaceregion alwayskeeporig=%i", TRUE); + BMO_slot_copy(op, &extrudeop, "geom", "edgefacein"); + BMO_op_exec(bm, &extrudeop); /* Push the verts of the extruded faces inward to create thickness */ - BMO_Flag_Buffer(bm, &extrudeop, "geomout", FACE_MARK, BM_FACE); + BMO_slot_buffer_flag(bm, &extrudeop, "geomout", FACE_MARK, BM_FACE); calc_solidify_normals(bm); solidify_add_thickness(bm, thickness); - BMO_CopySlot(&extrudeop, op, "geomout", "geomout"); + BMO_slot_copy(&extrudeop, op, "geomout", "geomout"); - BMO_Finish_Op(bm, &extrudeop); + BMO_op_finish(bm, &extrudeop); } diff --git a/source/blender/bmesh/operators/join_triangles.c b/source/blender/bmesh/operators/join_triangles.c index 36f9ea1b4f4..e996a96b7e6 100644 --- a/source/blender/bmesh/operators/join_triangles.c +++ b/source/blender/bmesh/operators/join_triangles.c @@ -231,26 +231,26 @@ void bmesh_jointriangles_exec(BMesh *bm, BMOperator *op) BMEdge *e; BLI_array_declare(jedges); JoinEdge *jedges = NULL; - int dosharp = BMO_Get_Int(op, "compare_sharp"), douvs = BMO_Get_Int(op, "compare_uvs"); - int dovcols = BMO_Get_Int(op, "compare_vcols"), domat = BMO_Get_Int(op, "compare_materials"); - float limit = BMO_Get_Float(op, "limit"); + int dosharp = BMO_slot_int_get(op, "compare_sharp"), douvs = BMO_slot_int_get(op, "compare_uvs"); + int dovcols = BMO_slot_int_get(op, "compare_vcols"), domat = BMO_slot_int_get(op, "compare_materials"); + float limit = BMO_slot_float_get(op, "limit"); int i, totedge; /* flag all edges of all input face */ BMO_ITER(f1, &siter, bm, op, "faces", BM_FACE) { - BMO_SetFlag(bm, f1, FACE_INPUT); + BMO_elem_flag_set(bm, f1, FACE_INPUT); BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, f1) { - BMO_SetFlag(bm, l->e, EDGE_MARK); + BMO_elem_flag_set(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) { - if (!BMO_TestFlag(bm, e, EDGE_MARK)) + if (!BMO_elem_flag_test(bm, e, EDGE_MARK)) continue; - if (BM_Edge_FaceCount(e) < 2) { - BMO_ClearFlag(bm, e, EDGE_MARK); + if (BM_edge_face_count(e) < 2) { + BMO_elem_flag_clear(bm, e, EDGE_MARK); continue; } @@ -258,12 +258,12 @@ void bmesh_jointriangles_exec(BMesh *bm, BMOperator *op) f2 = e->l->radial_next->f; if (f1->len != 3 || f2->len != 3) { - BMO_ClearFlag(bm, e, EDGE_MARK); + BMO_elem_flag_clear(bm, e, EDGE_MARK); continue; } - if (!BMO_TestFlag(bm, f1, FACE_INPUT) || !BMO_TestFlag(bm, f2, FACE_INPUT)) { - BMO_ClearFlag(bm, e, EDGE_MARK); + if (!BMO_elem_flag_test(bm, f1, FACE_INPUT) || !BMO_elem_flag_test(bm, f2, FACE_INPUT)) { + BMO_elem_flag_clear(bm, e, EDGE_MARK); continue; } } @@ -274,7 +274,7 @@ void bmesh_jointriangles_exec(BMesh *bm, BMOperator *op) BMFace *f1, *f2; float measure; - if (!BMO_TestFlag(bm, e, EDGE_MARK)) + if (!BMO_elem_flag_test(bm, e, EDGE_MARK)) continue; f1 = e->l->f; @@ -285,7 +285,7 @@ void bmesh_jointriangles_exec(BMesh *bm, BMOperator *op) v3 = e->l->next->v; v4 = e->l->radial_next->prev->v; - if (dosharp && BM_TestHFlag(e, BM_ELEM_SHARP)) + if (dosharp && BM_elem_flag_test(e, BM_ELEM_SHARP)) continue; if ((douvs || dovcols) && compareFaceAttribs(bm, e, douvs, dovcols)) @@ -318,26 +318,26 @@ void bmesh_jointriangles_exec(BMesh *bm, BMOperator *op) f1 = e->l->f; f2 = e->l->radial_next->f; - if (BMO_TestFlag(bm, f1, FACE_MARK) || BMO_TestFlag(bm, f2, FACE_MARK)) + if (BMO_elem_flag_test(bm, f1, FACE_MARK) || BMO_elem_flag_test(bm, f2, FACE_MARK)) continue; - BMO_SetFlag(bm, f1, FACE_MARK); - BMO_SetFlag(bm, f2, FACE_MARK); - BMO_SetFlag(bm, e, EDGE_CHOSEN); + BMO_elem_flag_set(bm, f1, FACE_MARK); + BMO_elem_flag_set(bm, f2, FACE_MARK); + BMO_elem_flag_set(bm, e, EDGE_CHOSEN); } BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) { - if (!BMO_TestFlag(bm, e, EDGE_CHOSEN)) + if (!BMO_elem_flag_test(bm, e, EDGE_CHOSEN)) continue; f1 = e->l->f; f2 = e->l->radial_next->f; - BM_Join_TwoFaces(bm, f1, f2, e); + BM_faces_join_pair(bm, f1, f2, e); } BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) { - if (BMO_TestFlag(bm, e, EDGE_MARK)) { + 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 */ @@ -349,7 +349,7 @@ void bmesh_jointriangles_exec(BMesh *bm, BMOperator *op) for (i = 0; i < 2; i++) { BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, i ? f2 : f1) { - if (l->e != e && BMO_TestFlag(bm, l->e, EDGE_MARK)) { + if (l->e != e && BMO_elem_flag_test(bm, l->e, EDGE_MARK)) { break; } } @@ -365,7 +365,7 @@ void bmesh_jointriangles_exec(BMesh *bm, BMOperator *op) continue; } - BM_Join_TwoFaces(bm, f1, f2, e); + BM_faces_join_pair(bm, f1, f2, e); } } diff --git a/source/blender/bmesh/operators/mesh_conv.c b/source/blender/bmesh/operators/mesh_conv.c index bc1829d6fb8..3ca337ddcdf 100644 --- a/source/blender/bmesh/operators/mesh_conv.c +++ b/source/blender/bmesh/operators/mesh_conv.c @@ -54,8 +54,8 @@ void mesh_to_bmesh_exec(BMesh *bm, BMOperator *op) { - Object *ob = BMO_Get_Pnt(op, "object"); - Mesh *me = BMO_Get_Pnt(op, "mesh"); + Object *ob = BMO_slot_ptr_get(op, "object"); + Mesh *me = BMO_slot_ptr_get(op, "mesh"); MVert *mvert; BLI_array_declare(verts); MEdge *medge; @@ -69,7 +69,7 @@ void mesh_to_bmesh_exec(BMesh *bm, BMOperator *op) BLI_array_declare(fedges); float (*keyco)[3] = NULL; int *keyi; - int set_key = BMO_Get_Int(op, "set_shapekey"); + int set_key = BMO_slot_int_get(op, "set_shapekey"); int totuv, i, j, allocsize[4] = {512, 512, 2048, 512}; if (!me || !me->totvert) { @@ -143,19 +143,19 @@ void mesh_to_bmesh_exec(BMesh *bm, BMOperator *op) CustomData_bmesh_init_pool(&bm->pdata, allocsize[3]); for (i = 0, mvert = me->mvert; i < me->totvert; i++, mvert++) { - v = BM_Make_Vert(bm, keyco && set_key ? keyco[i] : mvert->co, NULL); - BM_SetIndex(v, i); /* set_ok */ + v = BM_vert_create(bm, keyco && set_key ? keyco[i] : mvert->co, NULL); + BM_elem_index_set(v, i); /* set_ok */ vt[i] = v; /* transfer flag */ - v->head.hflag = BM_Vert_Flag_From_MEFlag(mvert->flag); + v->head.hflag = BM_vert_flag_from_mflag(mvert->flag); /* this is necassary for selection counts to work properl */ - if (BM_TestHFlag(v, BM_ELEM_SELECT)) BM_Select_Vert(bm, v, TRUE); + if (BM_elem_flag_test(v, BM_ELEM_SELECT)) BM_vert_select(bm, v, TRUE); normal_short_to_float_v3(v->no, mvert->no); - BM_SetCDf(&bm->vdata, v, CD_BWEIGHT, (float)mvert->bweight / 255.0f); + BM_elem_float_data_set(&bm->vdata, v, CD_BWEIGHT, (float)mvert->bweight / 255.0f); /* Copy Custom Dat */ CustomData_to_bmesh_block(&me->vdata, &bm->vdata, i, &v->head.data); @@ -189,21 +189,21 @@ void mesh_to_bmesh_exec(BMesh *bm, BMOperator *op) medge = me->medge; for (i = 0; i < me->totedge; i++, medge++) { - e = BM_Make_Edge(bm, vt[medge->v1], vt[medge->v2], NULL, FALSE); - BM_SetIndex(e, i); /* set_ok */ + e = BM_edge_create(bm, vt[medge->v1], vt[medge->v2], NULL, FALSE); + BM_elem_index_set(e, i); /* set_ok */ et[i] = e; /* transfer flags */ - e->head.hflag = BM_Edge_Flag_From_MEFlag(medge->flag); + e->head.hflag = BM_edge_flag_from_mflag(medge->flag); /* this is necassary for selection counts to work properly */ - if (BM_TestHFlag(e, BM_ELEM_SELECT)) BM_Select(bm, e, TRUE); + if (BM_elem_flag_test(e, BM_ELEM_SELECT)) BM_elem_select_set(bm, e, TRUE); /* Copy Custom Dat */ CustomData_to_bmesh_block(&me->edata, &bm->edata, i, &e->head.data); - BM_SetCDf(&bm->edata, e, CD_CREASE, (float)medge->crease / 255.0f); - BM_SetCDf(&bm->edata, e, CD_BWEIGHT, (float)medge->bweight / 255.0f); + BM_elem_float_data_set(&bm->edata, e, CD_CREASE, (float)medge->crease / 255.0f); + BM_elem_float_data_set(&bm->edata, e, CD_BWEIGHT, (float)medge->bweight / 255.0f); } bm->elem_index_dirty &= ~BM_EDGE; /* added in order, clear dirty flag */ @@ -251,7 +251,7 @@ void mesh_to_bmesh_exec(BMesh *bm, BMOperator *op) } #endif - f = BM_Make_Face(bm, verts, fedges, mpoly->totloop, FALSE); + f = BM_face_create(bm, verts, fedges, mpoly->totloop, FALSE); if (!f) { printf("%s: Warning! Bad face in mesh" @@ -261,13 +261,13 @@ void mesh_to_bmesh_exec(BMesh *bm, BMOperator *op) } /* dont use 'i' since we may have skipped the face */ - BM_SetIndex(f, bm->totface - 1); /* set_ok */ + BM_elem_index_set(f, bm->totface - 1); /* set_ok */ /* transfer flag */ - f->head.hflag = BM_Face_Flag_From_MEFlag(mpoly->flag); + f->head.hflag = BM_face_flag_from_mflag(mpoly->flag); /* this is necassary for selection counts to work properl */ - if (BM_TestHFlag(f, BM_ELEM_SELECT)) BM_Select(bm, f, TRUE); + if (BM_elem_flag_test(f, BM_ELEM_SELECT)) BM_elem_select_set(bm, f, TRUE); f->mat_nr = mpoly->mat_nr; if (i == me->act_face) bm->act_face = f; @@ -275,7 +275,7 @@ void mesh_to_bmesh_exec(BMesh *bm, BMOperator *op) j = 0; BM_ITER_INDEX(l, &iter, bm, BM_LOOPS_OF_FACE, f, j) { /* Save index of correspsonding MLoop */ - BM_SetIndex(l, mpoly->loopstart + j); /* set_loop */ + BM_elem_index_set(l, mpoly->loopstart + j); /* set_loop */ } /* Copy Custom Dat */ @@ -294,9 +294,9 @@ void mesh_to_bmesh_exec(BMesh *bm, BMOperator *op) * 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) { - int li = BM_GetIndex(l); + int li = BM_elem_index_get(l); CustomData_to_bmesh_block(&me->ldata, &bm->ldata, li, &l->head.data); - BM_SetIndex(l, 0); /* set_loop */ + BM_elem_index_set(l, 0); /* set_loop */ } } } @@ -313,23 +313,23 @@ void mesh_to_bmesh_exec(BMesh *bm, BMOperator *op) BMFace **face_array = MEM_callocN(sizeof(BMFace *) * bm->totface, "Selection Conversion Face Pointer Array"); - for (i = 0, vertex = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL); + for (i = 0, vertex = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL); vertex; - i++, vertex = BMIter_Step(&iter)) + i++, vertex = BM_iter_step(&iter)) { vertex_array[i] = vertex; } - for (i = 0, edge = BMIter_New(&iter, bm, BM_EDGES_OF_MESH, NULL); + for (i = 0, edge = BM_iter_new(&iter, bm, BM_EDGES_OF_MESH, NULL); edge; - i++, edge = BMIter_Step(&iter)) + i++, edge = BM_iter_step(&iter)) { edge_array[i] = edge; } - for (i = 0, face = BMIter_New(&iter, bm, BM_FACES_OF_MESH, NULL); + for (i = 0, face = BM_iter_new(&iter, bm, BM_FACES_OF_MESH, NULL); face; - i++, face = BMIter_Step(&iter)) + i++, face = BM_iter_step(&iter)) { face_array[i] = face; } @@ -337,13 +337,13 @@ void mesh_to_bmesh_exec(BMesh *bm, BMOperator *op) if (me->mselect) { for (i = 0; i < me->totselect; i++) { if (me->mselect[i].type == ME_VSEL) { - BM_store_selection(bm, vertex_array[me->mselect[i].index]); + BM_select_history_store(bm, vertex_array[me->mselect[i].index]); } else if (me->mselect[i].type == ME_ESEL) { - BM_store_selection(bm, edge_array[me->mselect[i].index]); + BM_select_history_store(bm, edge_array[me->mselect[i].index]); } else if (me->mselect[i].type == ME_FSEL) { - BM_store_selection(bm, face_array[me->mselect[i].index]); + BM_select_history_store(bm, face_array[me->mselect[i].index]); } } } @@ -372,11 +372,11 @@ void mesh_to_bmesh_exec(BMesh *bm, BMOperator *op) void object_load_bmesh_exec(BMesh *bm, BMOperator *op) { - Object *ob = BMO_Get_Pnt(op, "object"); - /* Scene *scene = BMO_Get_Pnt(op, "scene"); */ + Object *ob = BMO_slot_ptr_get(op, "object"); + /* Scene *scene = BMO_slot_ptr_get(op, "scene"); */ Mesh *me = ob->data; - BMO_CallOpf(bm, "bmesh_to_mesh mesh=%p object=%p notesselation=%i", me, ob, TRUE); + BMO_op_callf(bm, "bmesh_to_mesh mesh=%p object=%p notesselation=%i", me, ob, TRUE); } @@ -441,8 +441,8 @@ BM_INLINE void bmesh_quick_edgedraw_flag(MEdge *med, BMEdge *e) void bmesh_to_mesh_exec(BMesh *bm, BMOperator *op) { - Mesh *me = BMO_Get_Pnt(op, "mesh"); - /* Object *ob = BMO_Get_Pnt(op, "object"); */ + Mesh *me = BMO_slot_ptr_get(op, "mesh"); + /* Object *ob = BMO_slot_ptr_get(op, "object"); */ MLoop *mloop; MPoly *mpoly; MVert *mvert, *oldverts; @@ -453,7 +453,7 @@ void bmesh_to_mesh_exec(BMesh *bm, BMOperator *op) BMFace *f; BMIter iter, liter; int i, j, *keyi, ototvert, totloop; - int dotess = !BMO_Get_Int(op, "notesselation"); + int dotess = !BMO_slot_int_get(op, "notesselation"); ototvert = me->totvert; @@ -525,9 +525,9 @@ void bmesh_to_mesh_exec(BMesh *bm, BMOperator *op) copy_v3_v3(mvert->co, v->co); normal_float_to_short_v3(mvert->no, v->no); - mvert->flag = BM_Vert_Flag_To_MEFlag(v); + mvert->flag = BM_vert_flag_to_mflag(v); - BM_SetIndex(v, i); /* set_inline */ + BM_elem_index_set(v, i); /* set_inline */ /* copy over customdat */ CustomData_from_bmesh_block(&bm->vdata, &me->vdata, v->head.data, i); @@ -545,14 +545,14 @@ void bmesh_to_mesh_exec(BMesh *bm, BMOperator *op) float *crease = CustomData_bmesh_get(&bm->edata, e->head.data, CD_CREASE); float *bweight = CustomData_bmesh_get(&bm->edata, e->head.data, CD_BWEIGHT); - med->v1 = BM_GetIndex(e->v1); - med->v2 = BM_GetIndex(e->v2); + med->v1 = BM_elem_index_get(e->v1); + med->v2 = BM_elem_index_get(e->v2); med->crease = crease ? (char)((*crease) * 255) : 0; med->bweight = bweight ? (char)((*bweight) * 255) : 0; - med->flag = BM_Edge_Flag_To_MEFlag(e); + med->flag = BM_edge_flag_to_mflag(e); - BM_SetIndex(e, i); /* set_inline */ + BM_elem_index_set(e, i); /* set_inline */ /* copy over customdat */ CustomData_from_bmesh_block(&bm->edata, &me->edata, e->head.data, i); @@ -571,12 +571,12 @@ void bmesh_to_mesh_exec(BMesh *bm, BMOperator *op) mpoly->loopstart = j; mpoly->totloop = f->len; mpoly->mat_nr = f->mat_nr; - mpoly->flag = BM_Face_Flag_To_MEFlag(f); + mpoly->flag = BM_face_flag_to_mflag(f); - l = BMIter_New(&liter, bm, BM_LOOPS_OF_FACE, f); - for ( ; l; l = BMIter_Step(&liter), j++, mloop++) { - mloop->e = BM_GetIndex(l->e); - mloop->v = BM_GetIndex(l->v); + l = BM_iter_new(&liter, bm, BM_LOOPS_OF_FACE, f); + for ( ; l; l = BM_iter_step(&liter), j++, mloop++) { + mloop->e = BM_elem_index_get(l->e); + mloop->v = BM_elem_index_get(l->v); /* copy over customdat */ CustomData_from_bmesh_block(&bm->ldata, &me->ldata, l->head.data, j); @@ -611,15 +611,15 @@ void bmesh_to_mesh_exec(BMesh *bm, BMOperator *op) if (ob->par1 < ototvert) { eve = vertMap[ob->par1]; - if (eve) ob->par1 = BM_GetIndex(eve); + if (eve) ob->par1 = BM_elem_index_get(eve); } if (ob->par2 < ototvert) { eve = vertMap[ob->par2]; - if (eve) ob->par2 = BM_GetIndex(eve); + if (eve) ob->par2 = BM_elem_index_get(eve); } if (ob->par3 < ototvert) { eve = vertMap[ob->par3]; - if (eve) ob->par3 = BM_GetIndex(eve); + if (eve) ob->par3 = BM_elem_index_get(eve); } } @@ -637,7 +637,7 @@ void bmesh_to_mesh_exec(BMesh *bm, BMOperator *op) eve = vertMap[hmd->indexar[i]]; if (eve) { - hmd->indexar[j++] = BM_GetIndex(eve); + hmd->indexar[j++] = BM_elem_index_get(eve); } } else j++; @@ -680,7 +680,7 @@ void bmesh_to_mesh_exec(BMesh *bm, BMOperator *op) me->mselect[i].type = ME_FSEL; } - me->mselect[i].index = BM_GetIndex(selected->data); + me->mselect[i].index = BM_elem_index_get(selected->data); } } @@ -855,7 +855,7 @@ void bmesh_to_mesh_exec(BMesh *bm, BMOperator *op) fp = newkey = MEM_callocN(me->key->elemsize * bm->totvert, "currkey->data"); oldkey = currkey->data; - eve = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL); + eve = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL); i = 0; mvert = me->mvert; @@ -894,7 +894,7 @@ void bmesh_to_mesh_exec(BMesh *bm, BMOperator *op) fp+= 3; ++i; ++mvert; - eve = BMIter_Step(&iter); + eve = BM_iter_step(&iter); } currkey->totelem = bm->totvert; if (currkey->data) MEM_freeN(currkey->data); diff --git a/source/blender/bmesh/operators/mirror.c b/source/blender/bmesh/operators/mirror.c index d73493020b6..99ff0b55e7b 100644 --- a/source/blender/bmesh/operators/mirror.c +++ b/source/blender/bmesh/operators/mirror.c @@ -46,32 +46,32 @@ void bmesh_mirror_exec(BMesh *bm, BMOperator *op) float mtx[4][4]; float imtx[4][4]; float scale[3] = {1.0f, 1.0f, 1.0f}; - float dist = BMO_Get_Float(op, "mergedist"); - int i, ototvert, ototedge, axis = BMO_Get_Int(op, "axis"); - int mirroru = BMO_Get_Int(op, "mirror_u"); - int mirrorv = BMO_Get_Int(op, "mirror_v"); + float dist = BMO_slot_float_get(op, "mergedist"); + int i, ototvert, ototedge, axis = BMO_slot_int_get(op, "axis"); + int mirroru = BMO_slot_int_get(op, "mirror_u"); + int mirrorv = BMO_slot_int_get(op, "mirror_v"); ototvert = bm->totvert; ototedge = bm->totedge; - BMO_Get_Mat4(op, "mat", mtx); + BMO_slot_mat4_set(op, "mat", mtx); invert_m4_m4(imtx, mtx); - BMO_InitOpf(bm, &dupeop, "dupe geom=%s", op, "geom"); - BMO_Exec_Op(bm, &dupeop); + BMO_op_initf(bm, &dupeop, "dupe geom=%s", op, "geom"); + BMO_op_exec(bm, &dupeop); - BMO_Flag_Buffer(bm, &dupeop, "newout", ELE_NEW, BM_ALL); + BMO_slot_buffer_flag(bm, &dupeop, "newout", ELE_NEW, BM_ALL); /* create old -> new mappin */ i = 0; - v2 = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL); + v2 = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL); BMO_ITER(v, &siter, bm, &dupeop, "newout", BM_VERT) { BLI_array_growone(vmap); vmap[i] = v; /* BMESH_TODO, double check this is being made dirty, 99% sure it is - campbell */ - BM_SetIndex(v2, i); /* set_dirty! */ - v2 = BMIter_Step(&iter); + BM_elem_index_set(v2, i); /* set_dirty! */ + v2 = BM_iter_step(&iter); i++; } @@ -79,18 +79,18 @@ void bmesh_mirror_exec(BMesh *bm, BMOperator *op) /* feed old data to transform bmo */ scale[axis] = -1.0f; - BMO_CallOpf(bm, "transform verts=%fv mat=%m4", ELE_NEW, mtx); - BMO_CallOpf(bm, "scale verts=%fv vec=%v", ELE_NEW, scale); - BMO_CallOpf(bm, "transform verts=%fv mat=%m4", ELE_NEW, imtx); + BMO_op_callf(bm, "transform verts=%fv mat=%m4", ELE_NEW, mtx); + BMO_op_callf(bm, "scale verts=%fv vec=%v", ELE_NEW, scale); + BMO_op_callf(bm, "transform verts=%fv mat=%m4", ELE_NEW, imtx); - BMO_Init_Op(bm, &weldop, "weldverts"); + BMO_op_init(bm, &weldop, "weldverts"); - v = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL); + v = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL); for (i = 0; i < ototvert; i++) { if (ABS(v->co[axis]) <= dist) { - BMO_Insert_MapPointer(bm, &weldop, "targetmap", vmap[i], v); + BMO_slot_map_ptr_insert(bm, &weldop, "targetmap", vmap[i], v); } - v = BMIter_Step(&iter); + v = BM_iter_step(&iter); } if (mirroru || mirrorv) { @@ -114,12 +114,12 @@ void bmesh_mirror_exec(BMesh *bm, BMOperator *op) } } - BMO_Exec_Op(bm, &weldop); + BMO_op_exec(bm, &weldop); - BMO_Finish_Op(bm, &weldop); - BMO_Finish_Op(bm, &dupeop); + BMO_op_finish(bm, &weldop); + BMO_op_finish(bm, &dupeop); - BMO_Flag_To_Slot(bm, op, "newout", ELE_NEW, BM_ALL); + BMO_slot_from_flag(bm, op, "newout", ELE_NEW, BM_ALL); BLI_array_free(vmap); BLI_array_free(emap); diff --git a/source/blender/bmesh/operators/primitiveops.c b/source/blender/bmesh/operators/primitiveops.c index ed169b93ad3..bb11876d979 100644 --- a/source/blender/bmesh/operators/primitiveops.c +++ b/source/blender/bmesh/operators/primitiveops.c @@ -228,13 +228,13 @@ void bmesh_create_grid_exec(BMesh *bm, BMOperator *op) BMOperator bmop, prevop; BMVert *eve, *preveve; BMEdge *e; - float vec[3], mat[4][4], phi, phid, dia = BMO_Get_Float(op, "size"); - int a, tot = BMO_Get_Int(op, "xsegments"), seg = BMO_Get_Int(op, "ysegments"); + float vec[3], mat[4][4], phi, phid, dia = BMO_slot_float_get(op, "size"); + int a, tot = BMO_slot_int_get(op, "xsegments"), seg = BMO_slot_int_get(op, "ysegments"); if (tot < 2) tot = 2; if (seg < 2) seg = 2; - BMO_Get_Mat4(op, "mat", mat); + BMO_slot_mat4_set(op, "mat", mat); /* one segment first: the X axis */ phi = 1.0f; @@ -245,12 +245,12 @@ void bmesh_create_grid_exec(BMesh *bm, BMOperator *op) vec[2] = 0.0f; mul_m4_v3(mat, vec); - eve = BM_Make_Vert(bm, vec, NULL); - BM_Select(bm, eve, TRUE); + eve = BM_vert_create(bm, vec, NULL); + BM_elem_select_set(bm, eve, TRUE); if (a) { - e = BM_Make_Edge(bm, preveve, eve, NULL, TRUE); - BMO_SetFlag(bm, e, EDGE_ORIG); + e = BM_edge_create(bm, preveve, eve, NULL, TRUE); + BMO_elem_flag_set(bm, e, EDGE_ORIG); } preveve = eve; @@ -264,26 +264,26 @@ void bmesh_create_grid_exec(BMesh *bm, BMOperator *op) for (a = 0; a < seg - 1; a++) { if (a) { - BMO_InitOpf(bm, &bmop, "extrude_edge_only edges=%s", &prevop, "geomout"); - BMO_Exec_Op(bm, &bmop); - BMO_Finish_Op(bm, &prevop); + BMO_op_initf(bm, &bmop, "extrude_edge_only edges=%s", &prevop, "geomout"); + BMO_op_exec(bm, &bmop); + BMO_op_finish(bm, &prevop); - BMO_Flag_Buffer(bm, &bmop, "geomout", VERT_MARK, BM_VERT); + BMO_slot_buffer_flag(bm, &bmop, "geomout", VERT_MARK, BM_VERT); } else { - BMO_InitOpf(bm, &bmop, "extrude_edge_only edges=%fe", EDGE_ORIG); - BMO_Exec_Op(bm, &bmop); - BMO_Flag_Buffer(bm, &bmop, "geomout", VERT_MARK, BM_VERT); + BMO_op_initf(bm, &bmop, "extrude_edge_only edges=%fe", EDGE_ORIG); + BMO_op_exec(bm, &bmop); + BMO_slot_buffer_flag(bm, &bmop, "geomout", VERT_MARK, BM_VERT); } - BMO_CallOpf(bm, "translate vec=%v verts=%s", vec, &bmop, "geomout"); + BMO_op_callf(bm, "translate vec=%v verts=%s", vec, &bmop, "geomout"); prevop = bmop; } if (a) - BMO_Finish_Op(bm, &bmop); + BMO_op_finish(bm, &bmop); - BMO_Flag_To_Slot(bm, op, "vertout", VERT_MARK, BM_VERT); + BMO_slot_from_flag(bm, op, "vertout", VERT_MARK, BM_VERT); } void bmesh_create_uvsphere_exec(BMesh *bm, BMOperator *op) @@ -293,10 +293,10 @@ void bmesh_create_uvsphere_exec(BMesh *bm, BMOperator *op) BMEdge *e; BMIter iter; float vec[3], mat[4][4], cmat[3][3], phi, q[4]; - float phid, dia = BMO_Get_Float(op, "diameter"); - int a, seg = BMO_Get_Int(op, "segments"), tot = BMO_Get_Int(op, "revolutions"); + float phid, dia = BMO_slot_float_get(op, "diameter"); + int a, seg = BMO_slot_int_get(op, "segments"), tot = BMO_slot_int_get(op, "revolutions"); - BMO_Get_Mat4(op, "mat", mat); + BMO_slot_mat4_set(op, "mat", mat); phid = 2.0f * (float)M_PI / tot; phi = 0.25f * (float)M_PI; @@ -309,12 +309,12 @@ void bmesh_create_uvsphere_exec(BMesh *bm, BMOperator *op) vec[0] = -dia * sinf(phi); vec[1] = 0.0; vec[2] = dia * cosf(phi); - eve = BM_Make_Vert(bm, vec, NULL); - BMO_SetFlag(bm, eve, VERT_MARK); + eve = BM_vert_create(bm, vec, NULL); + BMO_elem_flag_set(bm, eve, VERT_MARK); if (a != 0) { - e = BM_Make_Edge(bm, preveve, eve, NULL, FALSE); - BMO_SetFlag(bm, e, EDGE_ORIG); + e = BM_edge_create(bm, preveve, eve, NULL, FALSE); + BMO_elem_flag_set(bm, e, EDGE_ORIG); } phi+= phid; @@ -330,23 +330,23 @@ void bmesh_create_uvsphere_exec(BMesh *bm, BMOperator *op) for (a = 0; a < seg; a++) { if (a) { - BMO_InitOpf(bm, &bmop, "extrude_edge_only edges=%s", &prevop, "geomout"); - BMO_Exec_Op(bm, &bmop); - BMO_Finish_Op(bm, &prevop); + BMO_op_initf(bm, &bmop, "extrude_edge_only edges=%s", &prevop, "geomout"); + BMO_op_exec(bm, &bmop); + BMO_op_finish(bm, &prevop); } else { - BMO_InitOpf(bm, &bmop, "extrude_edge_only edges=%fe", EDGE_ORIG); - BMO_Exec_Op(bm, &bmop); + BMO_op_initf(bm, &bmop, "extrude_edge_only edges=%fe", EDGE_ORIG); + BMO_op_exec(bm, &bmop); } - BMO_Flag_Buffer(bm, &bmop, "geomout", VERT_MARK, BM_VERT); - BMO_CallOpf(bm, "rotate cent=%v mat=%m3 verts=%s", vec, cmat, &bmop, "geomout"); + BMO_slot_buffer_flag(bm, &bmop, "geomout", VERT_MARK, BM_VERT); + BMO_op_callf(bm, "rotate cent=%v mat=%m3 verts=%s", vec, cmat, &bmop, "geomout"); prevop = bmop; } if (a) - BMO_Finish_Op(bm, &bmop); + BMO_op_finish(bm, &bmop); { float len, len2, vec2[3]; @@ -362,17 +362,17 @@ void bmesh_create_uvsphere_exec(BMesh *bm, BMOperator *op) len2= len_v3v3(vec, vec2); /* use shortest segment length divided by 3 as merge threshold */ - BMO_CallOpf(bm, "removedoubles verts=%fv dist=%f", VERT_MARK, MIN2(len, len2) / 3.0f); + BMO_op_callf(bm, "removedoubles verts=%fv dist=%f", VERT_MARK, MIN2(len, len2) / 3.0f); } /* and now do imat */ BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) { - if (BMO_TestFlag(bm, eve, VERT_MARK)) { + if (BMO_elem_flag_test(bm, eve, VERT_MARK)) { mul_m4_v3(mat, eve->co); } } - BMO_Flag_To_Slot(bm, op, "vertout", VERT_MARK, BM_VERT); + BMO_slot_from_flag(bm, op, "vertout", VERT_MARK, BM_VERT); } void bmesh_create_icosphere_exec(BMesh *bm, BMOperator *op) @@ -381,10 +381,10 @@ void bmesh_create_icosphere_exec(BMesh *bm, BMOperator *op) BMIter liter; BMLoop *l; float vec[3], mat[4][4] /* , phi, phid */; - float dia = BMO_Get_Float(op, "diameter"); - int a, subdiv = BMO_Get_Int(op, "subdivisions"); + float dia = BMO_slot_float_get(op, "diameter"); + int a, subdiv = BMO_slot_int_get(op, "subdivisions"); - BMO_Get_Mat4(op, "mat", mat); + BMO_slot_mat4_set(op, "mat", mat); /* phid = 2.0f * (float)M_PI / subdiv; */ /* UNUSED */ /* phi = 0.25f * (float)M_PI; */ /* UNUSED */ @@ -394,10 +394,10 @@ void bmesh_create_icosphere_exec(BMesh *bm, BMOperator *op) vec[0] = dia * icovert[a][0]; vec[1] = dia * icovert[a][1]; vec[2] = dia * icovert[a][2]; - eva[a] = BM_Make_Vert(bm, vec, NULL); + eva[a] = BM_vert_create(bm, vec, NULL); mul_m4_v3(mat, eva[a]->co); - BM_Select(bm, eva[a], TRUE); + BM_elem_select_set(bm, eva[a], TRUE); } for (a = 0; a < 20; a++) { @@ -408,13 +408,13 @@ void bmesh_create_icosphere_exec(BMesh *bm, BMOperator *op) v2 = eva[icoface[a][1]]; v3 = eva[icoface[a][2]]; - eftemp = BM_Make_Face_QuadTri(bm, v1, v2, v3, NULL, NULL, FALSE); + eftemp = BM_face_create_quad_tri(bm, v1, v2, v3, NULL, NULL, FALSE); BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, eftemp) { - BMO_SetFlag(bm, l->e, EDGE_MARK); + BMO_elem_flag_set(bm, l->e, EDGE_MARK); } - BMO_SetFlag(bm, eftemp, FACE_MARK); + BMO_elem_flag_set(bm, eftemp, FACE_MARK); } dia *= 200.0f; @@ -422,16 +422,16 @@ void bmesh_create_icosphere_exec(BMesh *bm, BMOperator *op) for (a = 1; a < subdiv; a++) { BMOperator bmop; - BMO_InitOpf(bm, &bmop, + BMO_op_initf(bm, &bmop, "esubd edges=%fe smooth=%f numcuts=%i gridfill=%i beauty=%i", EDGE_MARK, dia, 1, 1, B_SPHERE); - BMO_Exec_Op(bm, &bmop); - BMO_Flag_Buffer(bm, &bmop, "geomout", VERT_MARK, BM_VERT); - BMO_Flag_Buffer(bm, &bmop, "geomout", EDGE_MARK, BM_EDGE); - BMO_Finish_Op(bm, &bmop); + BMO_op_exec(bm, &bmop); + BMO_slot_buffer_flag(bm, &bmop, "geomout", VERT_MARK, BM_VERT); + BMO_slot_buffer_flag(bm, &bmop, "geomout", EDGE_MARK, BM_EDGE); + BMO_op_finish(bm, &bmop); } - BMO_Flag_To_Slot(bm, op, "vertout", VERT_MARK, BM_VERT); + BMO_slot_from_flag(bm, op, "vertout", VERT_MARK, BM_VERT); } void bmesh_create_monkey_exec(BMesh *bm, BMOperator *op) @@ -441,31 +441,31 @@ void bmesh_create_monkey_exec(BMesh *bm, BMOperator *op) float mat[4][4]; int i; - BMO_Get_Mat4(op, "mat", mat); + BMO_slot_mat4_set(op, "mat", mat); for (i = 0; i < monkeynv; i++) { float v[3]; v[0] = (monkeyv[i][0] + 127) / 128.0, v[1] = monkeyv[i][1] / 128.0, v[2] = monkeyv[i][2] / 128.0; - tv[i] = BM_Make_Vert(bm, v, NULL); - BMO_SetFlag(bm, tv[i], VERT_MARK); + tv[i] = BM_vert_create(bm, v, NULL); + BMO_elem_flag_set(bm, tv[i], VERT_MARK); - tv[monkeynv + i] = (fabsf(v[0] = -v[0]) < 0.001f) ? tv[i]: (eve = BM_Make_Vert(bm, v, NULL), mul_m4_v3(mat, eve->co), eve); - BMO_SetFlag(bm, tv[monkeynv + i], VERT_MARK); + tv[monkeynv + i] = (fabsf(v[0] = -v[0]) < 0.001f) ? tv[i]: (eve = BM_vert_create(bm, v, NULL), mul_m4_v3(mat, eve->co), eve); + BMO_elem_flag_set(bm, tv[monkeynv + i], VERT_MARK); mul_m4_v3(mat, tv[i]->co); } for (i = 0; i < monkeynf; i++) { - BM_Make_Face_QuadTri(bm, + BM_face_create_quad_tri(bm, tv[monkeyf[i][0] + i - monkeyo], tv[monkeyf[i][1] + i - monkeyo], tv[monkeyf[i][2] + i - monkeyo], (monkeyf[i][3] != monkeyf[i][2]) ? tv[monkeyf[i][3] + i - monkeyo] : NULL, NULL, FALSE); - BM_Make_Face_QuadTri(bm, + BM_face_create_quad_tri(bm, tv[monkeynv + monkeyf[i][2] + i - monkeyo], tv[monkeynv + monkeyf[i][1] + i - monkeyo], tv[monkeynv + monkeyf[i][0] + i - monkeyo], @@ -475,7 +475,7 @@ void bmesh_create_monkey_exec(BMesh *bm, BMOperator *op) MEM_freeN(tv); - BMO_Flag_To_Slot(bm, op, "vertout", VERT_MARK, BM_VERT); + BMO_slot_from_flag(bm, op, "vertout", VERT_MARK, BM_VERT); } @@ -483,15 +483,15 @@ void bmesh_create_circle_exec(BMesh *bm, BMOperator *op) { BMVert *v1, *lastv1 = NULL, *cent1, *firstv1 = NULL; float vec[3], mat[4][4], phi, phid; - float dia = BMO_Get_Float(op, "diameter"); - int cap_ends = BMO_Get_Int(op, "cap_ends"), segs = BMO_Get_Int(op, "segments"); - int cap_tris = BMO_Get_Int(op, "cap_tris"); + float dia = BMO_slot_float_get(op, "diameter"); + int cap_ends = BMO_slot_int_get(op, "cap_ends"), segs = BMO_slot_int_get(op, "segments"); + int cap_tris = BMO_slot_int_get(op, "cap_tris"); int a; if (!segs) return; - BMO_Get_Mat4(op, "mat", mat); + BMO_slot_mat4_set(op, "mat", mat); phid = 2.0f * (float)M_PI / segs; phi = .25f * (float)M_PI; @@ -501,7 +501,7 @@ void bmesh_create_circle_exec(BMesh *bm, BMOperator *op) vec[2] = 0.0; mul_m4_v3(mat, vec); - cent1 = BM_Make_Vert(bm, vec, NULL); + cent1 = BM_vert_create(bm, vec, NULL); } for (a = 0; a < segs; a++, phi += phid) { @@ -510,18 +510,18 @@ void bmesh_create_circle_exec(BMesh *bm, BMOperator *op) vec[1] = dia * cosf(phi); vec[2] = 0.0f; mul_m4_v3(mat, vec); - v1 = BM_Make_Vert(bm, vec, NULL); + v1 = BM_vert_create(bm, vec, NULL); - BMO_SetFlag(bm, v1, VERT_MARK); + BMO_elem_flag_set(bm, v1, VERT_MARK); if (lastv1) - BM_Make_Edge(bm, v1, lastv1, NULL, FALSE); + BM_edge_create(bm, v1, lastv1, NULL, FALSE); if (a && cap_ends) { BMFace *f; - f = BM_Make_Face_QuadTri(bm, cent1, lastv1, v1, NULL, NULL, FALSE); - BMO_SetFlag(bm, f, FACE_NEW); + f = BM_face_create_quad_tri(bm, cent1, lastv1, v1, NULL, NULL, FALSE); + BMO_elem_flag_set(bm, f, FACE_NEW); } if (!firstv1) @@ -533,37 +533,37 @@ void bmesh_create_circle_exec(BMesh *bm, BMOperator *op) if (!a) return; - BM_Make_Edge(bm, lastv1, firstv1, NULL, FALSE); + BM_edge_create(bm, lastv1, firstv1, NULL, FALSE); if (cap_ends) { BMFace *f; - f = BM_Make_Face_QuadTri(bm, cent1, v1, firstv1, NULL, NULL, FALSE); - BMO_SetFlag(bm, f, FACE_NEW); + f = BM_face_create_quad_tri(bm, cent1, v1, firstv1, NULL, NULL, FALSE); + BMO_elem_flag_set(bm, f, FACE_NEW); } if (!cap_tris) { - BMO_CallOpf(bm, "dissolvefaces faces=%ff", FACE_NEW); + BMO_op_callf(bm, "dissolvefaces faces=%ff", FACE_NEW); } - BMO_Flag_To_Slot(bm, op, "vertout", VERT_MARK, BM_VERT); + BMO_slot_from_flag(bm, op, "vertout", VERT_MARK, BM_VERT); } void bmesh_create_cone_exec(BMesh *bm, BMOperator *op) { BMVert *v1, *v2, *lastv1 = NULL, *lastv2 = NULL, *cent1, *cent2, *firstv1, *firstv2; float vec[3], mat[4][4], phi, phid; - float dia1 = BMO_Get_Float(op, "diameter1"); - float dia2 = BMO_Get_Float(op, "diameter2"); - float depth = BMO_Get_Float(op, "depth"); - int cap_ends = BMO_Get_Int(op, "cap_ends"), segs = BMO_Get_Int(op, "segments"); - int cap_tris = BMO_Get_Int(op, "cap_tris"); + float dia1 = BMO_slot_float_get(op, "diameter1"); + float dia2 = BMO_slot_float_get(op, "diameter2"); + float depth = BMO_slot_float_get(op, "depth"); + int cap_ends = BMO_slot_int_get(op, "cap_ends"), segs = BMO_slot_int_get(op, "segments"); + int cap_tris = BMO_slot_int_get(op, "cap_tris"); int a; if (!segs) return; - BMO_Get_Mat4(op, "mat", mat); + BMO_slot_mat4_set(op, "mat", mat); phid = 2.0f * (float)M_PI / segs; phi = 0.25f * (float)M_PI; @@ -574,16 +574,16 @@ void bmesh_create_cone_exec(BMesh *bm, BMOperator *op) vec[2] = -depth; mul_m4_v3(mat, vec); - cent1 = BM_Make_Vert(bm, vec, NULL); + cent1 = BM_vert_create(bm, vec, NULL); vec[0] = vec[1] = 0.0f; vec[2] = depth; mul_m4_v3(mat, vec); - cent2 = BM_Make_Vert(bm, vec, NULL); + cent2 = BM_vert_create(bm, vec, NULL); - BMO_SetFlag(bm, cent1, VERT_MARK); - BMO_SetFlag(bm, cent2, VERT_MARK); + BMO_elem_flag_set(bm, cent1, VERT_MARK); + BMO_elem_flag_set(bm, cent2, VERT_MARK); } for (a = 0; a < segs; a++, phi += phid) { @@ -591,27 +591,27 @@ void bmesh_create_cone_exec(BMesh *bm, BMOperator *op) vec[1] = dia1 * cosf(phi); vec[2] = -depth; mul_m4_v3(mat, vec); - v1 = BM_Make_Vert(bm, vec, NULL); + v1 = BM_vert_create(bm, vec, NULL); vec[0] = dia2 * sinf(phi); vec[1] = dia2 * cosf(phi); vec[2] = depth; mul_m4_v3(mat, vec); - v2 = BM_Make_Vert(bm, vec, NULL); + v2 = BM_vert_create(bm, vec, NULL); - BMO_SetFlag(bm, v1, VERT_MARK); - BMO_SetFlag(bm, v2, VERT_MARK); + BMO_elem_flag_set(bm, v1, VERT_MARK); + BMO_elem_flag_set(bm, v2, VERT_MARK); if (a) { if (cap_ends) { BMFace *f; - f = BM_Make_Face_QuadTri(bm, cent1, lastv1, v1, NULL, NULL, FALSE); - BMO_SetFlag(bm, f, FACE_NEW); - f = BM_Make_Face_QuadTri(bm, cent2, v2, lastv2, NULL, NULL, FALSE); - BMO_SetFlag(bm, f, FACE_NEW); + f = BM_face_create_quad_tri(bm, cent1, lastv1, v1, NULL, NULL, FALSE); + BMO_elem_flag_set(bm, f, FACE_NEW); + f = BM_face_create_quad_tri(bm, cent2, v2, lastv2, NULL, NULL, FALSE); + BMO_elem_flag_set(bm, f, FACE_NEW); } - BM_Make_Face_QuadTri(bm, lastv1, lastv2, v2, v1, NULL, FALSE); + BM_face_create_quad_tri(bm, lastv1, lastv2, v2, v1, NULL, FALSE); } else { firstv1 = v1; @@ -628,28 +628,28 @@ void bmesh_create_cone_exec(BMesh *bm, BMOperator *op) if (cap_ends) { BMFace *f; - f = BM_Make_Face_QuadTri(bm, cent1, v1, firstv1, NULL, NULL, FALSE); - BMO_SetFlag(bm, f, FACE_NEW); - f = BM_Make_Face_QuadTri(bm, cent2, firstv2, v2, NULL, NULL, FALSE); - BMO_SetFlag(bm, f, FACE_NEW); + f = BM_face_create_quad_tri(bm, cent1, v1, firstv1, NULL, NULL, FALSE); + BMO_elem_flag_set(bm, f, FACE_NEW); + f = BM_face_create_quad_tri(bm, cent2, firstv2, v2, NULL, NULL, FALSE); + BMO_elem_flag_set(bm, f, FACE_NEW); } if (!cap_tris) { - BMO_CallOpf(bm, "dissolvefaces faces=%ff", FACE_NEW); + BMO_op_callf(bm, "dissolvefaces faces=%ff", FACE_NEW); } - BM_Make_Face_QuadTri(bm, v1, v2, firstv2, firstv1, NULL, FALSE); + BM_face_create_quad_tri(bm, v1, v2, firstv2, firstv1, NULL, FALSE); - BMO_CallOpf(bm, "removedoubles verts=%fv dist=%f", VERT_MARK, 0.000001); - BMO_Flag_To_Slot(bm, op, "vertout", VERT_MARK, BM_VERT); + BMO_op_callf(bm, "removedoubles verts=%fv dist=%f", VERT_MARK, 0.000001); + BMO_slot_from_flag(bm, op, "vertout", VERT_MARK, BM_VERT); } void bmesh_create_cube_exec(BMesh *bm, BMOperator *op) { BMVert *v1, *v2, *v3, *v4, *v5, *v6, *v7, *v8; - float vec[3], mat[4][4], off = BMO_Get_Float(op, "size") / 2.0f; + float vec[3], mat[4][4], off = BMO_slot_float_get(op, "size") / 2.0f; - BMO_Get_Mat4(op, "mat", mat); + BMO_slot_mat4_set(op, "mat", mat); if (!off) off = 0.5f; @@ -657,67 +657,67 @@ void bmesh_create_cube_exec(BMesh *bm, BMOperator *op) vec[1] = -off; vec[2] = -off; mul_m4_v3(mat, vec); - v1 = BM_Make_Vert(bm, vec, NULL); - BMO_SetFlag(bm, v1, VERT_MARK); + v1 = BM_vert_create(bm, vec, NULL); + BMO_elem_flag_set(bm, v1, VERT_MARK); vec[0] = -off; vec[1] = off; vec[2] = -off; mul_m4_v3(mat, vec); - v2 = BM_Make_Vert(bm, vec, NULL); - BMO_SetFlag(bm, v2, VERT_MARK); + v2 = BM_vert_create(bm, vec, NULL); + BMO_elem_flag_set(bm, v2, VERT_MARK); vec[0] = off; vec[1] = off; vec[2] = -off; mul_m4_v3(mat, vec); - v3 = BM_Make_Vert(bm, vec, NULL); - BMO_SetFlag(bm, v3, VERT_MARK); + v3 = BM_vert_create(bm, vec, NULL); + BMO_elem_flag_set(bm, v3, VERT_MARK); vec[0] = off; vec[1] = -off; vec[2] = -off; mul_m4_v3(mat, vec); - v4 = BM_Make_Vert(bm, vec, NULL); - BMO_SetFlag(bm, v4, VERT_MARK); + v4 = BM_vert_create(bm, vec, NULL); + BMO_elem_flag_set(bm, v4, VERT_MARK); vec[0] = -off; vec[1] = -off; vec[2] = off; mul_m4_v3(mat, vec); - v5 = BM_Make_Vert(bm, vec, NULL); - BMO_SetFlag(bm, v5, VERT_MARK); + v5 = BM_vert_create(bm, vec, NULL); + BMO_elem_flag_set(bm, v5, VERT_MARK); vec[0] = -off; vec[1] = off; vec[2] = off; mul_m4_v3(mat, vec); - v6 = BM_Make_Vert(bm, vec, NULL); - BMO_SetFlag(bm, v6, VERT_MARK); + v6 = BM_vert_create(bm, vec, NULL); + BMO_elem_flag_set(bm, v6, VERT_MARK); vec[0] = off; vec[1] = off; vec[2] = off; mul_m4_v3(mat, vec); - v7 = BM_Make_Vert(bm, vec, NULL); - BMO_SetFlag(bm, v7, VERT_MARK); + v7 = BM_vert_create(bm, vec, NULL); + BMO_elem_flag_set(bm, v7, VERT_MARK); vec[0] = off; vec[1] = -off; vec[2] = off; mul_m4_v3(mat, vec); - v8 = BM_Make_Vert(bm, vec, NULL); - BMO_SetFlag(bm, v8, VERT_MARK); + v8 = BM_vert_create(bm, vec, NULL); + BMO_elem_flag_set(bm, v8, VERT_MARK); /* the four sides */ - BM_Make_Face_QuadTri(bm, v5, v6, v2, v1, NULL, FALSE); - BM_Make_Face_QuadTri(bm, v6, v7, v3, v2, NULL, FALSE); - BM_Make_Face_QuadTri(bm, v7, v8, v4, v3, NULL, FALSE); - BM_Make_Face_QuadTri(bm, v8, v5, v1, v4, NULL, FALSE); + BM_face_create_quad_tri(bm, v5, v6, v2, v1, NULL, FALSE); + BM_face_create_quad_tri(bm, v6, v7, v3, v2, NULL, FALSE); + BM_face_create_quad_tri(bm, v7, v8, v4, v3, NULL, FALSE); + BM_face_create_quad_tri(bm, v8, v5, v1, v4, NULL, FALSE); /* top/bottom */ - BM_Make_Face_QuadTri(bm, v1, v2, v3, v4, NULL, FALSE); - BM_Make_Face_QuadTri(bm, v8, v7, v6, v5, NULL, FALSE); + BM_face_create_quad_tri(bm, v1, v2, v3, v4, NULL, FALSE); + BM_face_create_quad_tri(bm, v8, v7, v6, v5, NULL, FALSE); - BMO_Flag_To_Slot(bm, op, "vertout", VERT_MARK, BM_VERT); + BMO_slot_from_flag(bm, op, "vertout", VERT_MARK, BM_VERT); } diff --git a/source/blender/bmesh/operators/removedoubles.c b/source/blender/bmesh/operators/removedoubles.c index 087a68d9caa..918284854e0 100644 --- a/source/blender/bmesh/operators/removedoubles.c +++ b/source/blender/bmesh/operators/removedoubles.c @@ -40,10 +40,10 @@ static void remdoubles_splitface(BMFace *f, BMesh *bm, BMOperator *op) int split = 0; BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, f) { - v2 = BMO_Get_MapPointer(bm, op, "targetmap", l->v); + 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 doubl */ - if (v2 && BM_Vert_In_Face(f, v2) && (v2 != ((BMLoop *)l->prev)->v) && (v2 != ((BMLoop *)l->next)->v)) { + if (v2 && BM_vert_in_face(f, v2) && (v2 != ((BMLoop *)l->prev)->v) && (v2 != ((BMLoop *)l->next)->v)) { doub = l->v; split = 1; break; @@ -52,7 +52,7 @@ static void remdoubles_splitface(BMFace *f, BMesh *bm, BMOperator *op) if (split && doub != v2) { BMLoop *nl; - BMFace *f2 = BM_Split_Face(bm, f, doub, v2, &nl, NULL); + BMFace *f2 = BM_face_split(bm, f, doub, v2, &nl, NULL); remdoubles_splitface(f, bm, op); remdoubles_splitface(f2, bm, op); @@ -75,14 +75,14 @@ int remdoubles_face_overlaps(BMesh *bm, BMVert **varr, if (overlapface) *overlapface = NULL; for (i = 0; i < len; i++) { - f = BMIter_New(&vertfaces, bm, BM_FACES_OF_VERT, varr[i]); + f = BM_iter_new(&vertfaces, bm, BM_FACES_OF_VERT, varr[i]); while (f) { - amount = BM_Verts_In_Face(bm, f, varr, len); + amount = BM_verts_in_face(bm, f, varr, len); if (amount >= len) { if (overlapface) *overlapface = f; return TRUE; } - f = BMIter_Step(&vertfaces); + f = BM_iter_step(&vertfaces); } } return FALSE; @@ -101,11 +101,11 @@ void bmesh_weldverts_exec(BMesh *bm, BMOperator *op) int a, b; BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) { - if ((v2 = BMO_Get_MapPointer(bm, op, "targetmap", v))) { - BMO_SetFlag(bm, v, ELE_DEL); + if ((v2 = BMO_slot_map_ptr_get(bm, op, "targetmap", v))) { + BMO_elem_flag_set(bm, v, ELE_DEL); /* merge the vertex flags, else we get randomly selected/unselected verts */ - BM_MergeHFlag(v, v2); + BM_elem_flag_merge(v, v2); } } @@ -114,42 +114,42 @@ void bmesh_weldverts_exec(BMesh *bm, BMOperator *op) } BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) { - if (BMO_TestFlag(bm, e->v1, ELE_DEL) || BMO_TestFlag(bm, e->v2, ELE_DEL)) { - v = BMO_Get_MapPointer(bm, op, "targetmap", e->v1); - v2 = BMO_Get_MapPointer(bm, op, "targetmap", e->v2); + 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); if (!v) v = e->v1; if (!v2) v2 = e->v2; if (v == v2) - BMO_SetFlag(bm, e, EDGE_COL); - else if (!BM_Edge_Exist(v, v2)) - BM_Make_Edge(bm, v, v2, e, TRUE); + BMO_elem_flag_set(bm, e, EDGE_COL); + else if (!BM_edge_exists(v, v2)) + BM_edge_create(bm, v, v2, e, TRUE); - BMO_SetFlag(bm, e, ELE_DEL); + BMO_elem_flag_set(bm, e, ELE_DEL); } } /* BMESH_TODO, stop abusing face index here */ BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) { - BM_SetIndex(f, 0); /* set_dirty! */ + BM_elem_index_set(f, 0); /* set_dirty! */ BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, f) { - if (BMO_TestFlag(bm, l->v, ELE_DEL)) { - BMO_SetFlag(bm, f, FACE_MARK|ELE_DEL); + if (BMO_elem_flag_test(bm, l->v, ELE_DEL)) { + BMO_elem_flag_set(bm, f, FACE_MARK|ELE_DEL); } - if (BMO_TestFlag(bm, l->e, EDGE_COL)) { - BM_SetIndex(f, BM_GetIndex(f) + 1); /* set_dirty! */ + if (BMO_elem_flag_test(bm, l->e, EDGE_COL)) { + BM_elem_index_set(f, BM_elem_index_get(f) + 1); /* set_dirty! */ } } } bm->elem_index_dirty |= BM_FACE; BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) { - if (!BMO_TestFlag(bm, f, FACE_MARK)) + if (!BMO_elem_flag_test(bm, f, FACE_MARK)) continue; - if (f->len - BM_GetIndex(f) < 3) { - BMO_SetFlag(bm, f, ELE_DEL); + if (f->len - BM_elem_index_get(f) < 3) { + BMO_elem_flag_set(bm, f, ELE_DEL); continue; } @@ -159,14 +159,14 @@ void bmesh_weldverts_exec(BMesh *bm, BMOperator *op) BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, f) { v = l->v; v2 = ((BMLoop *)l->next)->v; - if (BMO_TestFlag(bm, v, ELE_DEL)) { - v = BMO_Get_MapPointer(bm, op, "targetmap", v); + if (BMO_elem_flag_test(bm, v, ELE_DEL)) { + v = BMO_slot_map_ptr_get(bm, op, "targetmap", v); } - if (BMO_TestFlag(bm, v2, ELE_DEL)) { - v2 = BMO_Get_MapPointer(bm, op, "targetmap", v2); + if (BMO_elem_flag_test(bm, v2, ELE_DEL)) { + v2 = BMO_slot_map_ptr_get(bm, op, "targetmap", v2); } - e2 = v != v2 ? BM_Edge_Exist(v, v2) : NULL; + e2 = v != v2 ? BM_edge_exists(v, v2) : NULL; if (e2) { for (b = 0; b < a; b++) { if (edges[b] == e2) { @@ -192,28 +192,28 @@ void bmesh_weldverts_exec(BMesh *bm, BMOperator *op) v = loops[0]->v; v2 = loops[1]->v; - if (BMO_TestFlag(bm, v, ELE_DEL)) { - v = BMO_Get_MapPointer(bm, op, "targetmap", v); + if (BMO_elem_flag_test(bm, v, ELE_DEL)) { + v = BMO_slot_map_ptr_get(bm, op, "targetmap", v); } - if (BMO_TestFlag(bm, v2, ELE_DEL)) { - v2 = BMO_Get_MapPointer(bm, op, "targetmap", v2); + if (BMO_elem_flag_test(bm, v2, ELE_DEL)) { + v2 = BMO_slot_map_ptr_get(bm, op, "targetmap", v2); } - f2 = BM_Make_Ngon(bm, v, v2, edges, a, TRUE); + f2 = BM_face_create_ngon(bm, v, v2, edges, a, TRUE); if (f2 && (f2 != f)) { - BM_Copy_Attributes(bm, bm, f, f2); + BM_elem_copy_attrs(bm, bm, f, f2); a = 0; BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, f2) { l2 = loops[a]; - BM_Copy_Attributes(bm, bm, l2, l); + BM_elem_copy_attrs(bm, bm, l2, l); a++; } } } - BMO_CallOpf(bm, "del geom=%fvef context=%i", ELE_DEL, DEL_ONLYTAGGED); + BMO_op_callf(bm, "del geom=%fvef context=%i", ELE_DEL, DEL_ONLYTAGGED); BLI_array_free(edges); BLI_array_free(loops); @@ -248,8 +248,8 @@ void bmesh_pointmerge_facedata_exec(BMesh *bm, BMOperator *op) float fac; int i, tot; - snapv = BMO_IterNew(&siter, bm, op, "snapv", BM_VERT); - tot = BM_Vert_FaceCount(snapv); + snapv = BMO_iter_new(&siter, bm, op, "snapv", BM_VERT); + tot = BM_vert_face_count(snapv); if (!tot) return; @@ -331,10 +331,10 @@ void bmesh_pointmerge_exec(BMesh *bm, BMOperator *op) BMVert *v, *snapv = NULL; float vec[3]; - BMO_Get_Vec(op, "mergeco", vec); + BMO_slot_vec_get(op, "mergeco", vec); - //BMO_CallOpf(bm, "collapse_uvs edges=%s", op, "edges"); - BMO_Init_Op(bm, &weldop, "weldverts"); + //BMO_op_callf(bm, "collapse_uvs edges=%s", op, "edges"); + BMO_op_init(bm, &weldop, "weldverts"); BMO_ITER(v, &siter, bm, op, "verts", BM_VERT) { if (!snapv) { @@ -342,12 +342,12 @@ void bmesh_pointmerge_exec(BMesh *bm, BMOperator *op) copy_v3_v3(snapv->co, vec); } else { - BMO_Insert_MapPointer(bm, &weldop, "targetmap", v, snapv); + BMO_slot_map_ptr_insert(bm, &weldop, "targetmap", v, snapv); } } - BMO_Exec_Op(bm, &weldop); - BMO_Finish_Op(bm, &weldop); + BMO_op_exec(bm, &weldop); + BMO_op_finish(bm, &weldop); } void bmesh_collapse_exec(BMesh *bm, BMOperator *op) @@ -360,24 +360,24 @@ void bmesh_collapse_exec(BMesh *bm, BMOperator *op) float min[3], max[3]; int i, tot; - BMO_CallOpf(bm, "collapse_uvs edges=%s", op, "edges"); - BMO_Init_Op(bm, &weldop, "weldverts"); + BMO_op_callf(bm, "collapse_uvs edges=%s", op, "edges"); + BMO_op_init(bm, &weldop, "weldverts"); - BMO_Flag_Buffer(bm, op, "edges", EDGE_MARK, BM_EDGE); + BMO_slot_buffer_flag(bm, op, "edges", EDGE_MARK, BM_EDGE); - BMW_Init(&walker, bm, BMW_SHELL, + BMW_init(&walker, bm, BMW_SHELL, BMW_MASK_NOP, EDGE_MARK, BMW_MASK_NOP, BMW_MASK_NOP, BMW_NIL_LAY); BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) { - if (!BMO_TestFlag(bm, e, EDGE_MARK)) + if (!BMO_elem_flag_test(bm, e, EDGE_MARK)) continue; - e = BMW_Begin(&walker, e->v1); + e = BMW_begin(&walker, e->v1); BLI_array_empty(edges); INIT_MINMAX(min, max); - for (tot = 0; e; tot++, e = BMW_Step(&walker)) { + for (tot = 0; e; tot++, e = BMW_step(&walker)) { BLI_array_growone(edges); edges[tot] = e; @@ -394,16 +394,16 @@ void bmesh_collapse_exec(BMesh *bm, BMOperator *op) copy_v3_v3(edges[i]->v2->co, min); if (edges[i]->v1 != edges[0]->v1) - BMO_Insert_MapPointer(bm, &weldop, "targetmap", edges[i]->v1, edges[0]->v1); + BMO_slot_map_ptr_insert(bm, &weldop, "targetmap", edges[i]->v1, edges[0]->v1); if (edges[i]->v2 != edges[0]->v1) - BMO_Insert_MapPointer(bm, &weldop, "targetmap", edges[i]->v2, edges[0]->v1); + BMO_slot_map_ptr_insert(bm, &weldop, "targetmap", edges[i]->v2, edges[0]->v1); } } - BMO_Exec_Op(bm, &weldop); - BMO_Finish_Op(bm, &weldop); + BMO_op_exec(bm, &weldop); + BMO_op_finish(bm, &weldop); - BMW_End(&walker); + BMW_end(&walker); BLI_array_free(edges); } @@ -420,24 +420,24 @@ static void bmesh_collapsecon_do_layer(BMesh *bm, BMOperator *op, int layer) int i, tot, type = bm->ldata.layers[layer].type; /* clear all short flags */ - BMO_Clear_Flag_All(bm, op, BM_ALL, (1 << 16) - 1); + BMO_mesh_flag_clear_all(bm, op, BM_ALL, (1 << 16) - 1); - BMO_Flag_Buffer(bm, op, "edges", EDGE_MARK, BM_EDGE); + BMO_slot_buffer_flag(bm, op, "edges", EDGE_MARK, BM_EDGE); - BMW_Init(&walker, bm, BMW_LOOPDATA_ISLAND, + BMW_init(&walker, bm, BMW_LOOPDATA_ISLAND, BMW_MASK_NOP, EDGE_MARK, BMW_MASK_NOP, BMW_MASK_NOP, layer); BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) { BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, f) { - if (BMO_TestFlag(bm, l->e, EDGE_MARK)) { + if (BMO_elem_flag_test(bm, l->e, EDGE_MARK)) { /* wal */ BLI_array_empty(blocks); tot = 0; - l2 = BMW_Begin(&walker, l); + l2 = BMW_begin(&walker, l); CustomData_data_initminmax(type, &min, &max); - for (tot = 0; l2; tot++, l2 = BMW_Step(&walker)) { + for (tot = 0; l2; tot++, l2 = BMW_step(&walker)) { BLI_array_growone(blocks); blocks[tot] = CustomData_bmesh_get_layer_n(&bm->ldata, l2->head.data, layer); CustomData_data_dominmax(type, blocks[tot], &min, &max); @@ -457,7 +457,7 @@ static void bmesh_collapsecon_do_layer(BMesh *bm, BMOperator *op, int layer) } } - BMW_End(&walker); + BMW_end(&walker); BLI_array_free(blocks); } @@ -480,7 +480,7 @@ void bmesh_finddoubles_common(BMesh *bm, BMOperator *op, BMOperator *optarget, c float dist, dist3; int i, j, len, keepvert = 0; - dist = BMO_Get_Float(op, "dist"); + dist = BMO_slot_float_get(op, "dist"); dist3 = dist * 3.0f; i = 0; @@ -490,8 +490,8 @@ void bmesh_finddoubles_common(BMesh *bm, BMOperator *op, BMOperator *optarget, c } /* Test whether keepverts arg exists and is non-empty */ - if (BMO_HasSlot(op, "keepverts")) { - keepvert = BMO_IterNew(&oiter, bm, op, "keepverts", BM_VERT) != NULL; + if (BMO_slot_exists(op, "keepverts")) { + keepvert = BMO_iter_new(&oiter, bm, op, "keepverts", BM_VERT) != NULL; } /* sort by vertex coordinates added togethe */ @@ -499,13 +499,13 @@ void bmesh_finddoubles_common(BMesh *bm, BMOperator *op, BMOperator *optarget, c /* Flag keepverts */ if (keepvert) { - BMO_Flag_Buffer(bm, op, "keepverts", VERT_KEEP, BM_VERT); + BMO_slot_buffer_flag(bm, op, "keepverts", VERT_KEEP, BM_VERT); } len = BLI_array_count(verts); for (i = 0; i < len; i++) { v = verts[i]; - if (BMO_TestFlag(bm, v, VERT_DOUBLE)) continue; + if (BMO_elem_flag_test(bm, v, VERT_DOUBLE)) continue; for (j = i + 1; j < len; j++) { v2 = verts[j]; @@ -517,21 +517,21 @@ void bmesh_finddoubles_common(BMesh *bm, BMOperator *op, BMOperator *optarget, c break; if (keepvert) { - if (BMO_TestFlag(bm, v2, VERT_KEEP) == BMO_TestFlag(bm, v, VERT_KEEP)) + if (BMO_elem_flag_test(bm, v2, VERT_KEEP) == BMO_elem_flag_test(bm, v, VERT_KEEP)) continue; } if (compare_len_v3v3(v->co, v2->co, dist)) { /* If one vert is marked as keep, make sure it will be the target */ - if (BMO_TestFlag(bm, v2, VERT_KEEP)) { + if (BMO_elem_flag_test(bm, v2, VERT_KEEP)) { SWAP(BMVert *, v, v2); } - BMO_SetFlag(bm, v2, VERT_DOUBLE); - BMO_SetFlag(bm, v, VERT_TARGET); + BMO_elem_flag_set(bm, v2, VERT_DOUBLE); + BMO_elem_flag_set(bm, v, VERT_TARGET); - BMO_Insert_MapPointer(bm, optarget, targetmapname, v2, v); + BMO_slot_map_ptr_insert(bm, optarget, targetmapname, v2, v); } } } @@ -543,10 +543,10 @@ void bmesh_removedoubles_exec(BMesh *bm, BMOperator *op) { BMOperator weldop; - BMO_Init_Op(bm, &weldop, "weldverts"); + BMO_op_init(bm, &weldop, "weldverts"); bmesh_finddoubles_common(bm, op, &weldop, "targetmap"); - BMO_Exec_Op(bm, &weldop); - BMO_Finish_Op(bm, &weldop); + BMO_op_exec(bm, &weldop); + BMO_op_finish(bm, &weldop); } @@ -564,24 +564,24 @@ void bmesh_automerge_exec(BMesh *bm, BMOperator *op) /* The "verts" input sent to this op is the set of verts that * can be merged away into any other verts. Mark all other verts * as VERT_KEEP. */ - BMO_Flag_Buffer(bm, op, "verts", VERT_IN, BM_VERT); + BMO_slot_buffer_flag(bm, op, "verts", VERT_IN, BM_VERT); BM_ITER(v, &viter, bm, BM_VERTS_OF_MESH, NULL) { - if (!BMO_TestFlag(bm, v, VERT_IN)) { - BMO_SetFlag(bm, v, VERT_KEEP); + if (!BMO_elem_flag_test(bm, v, VERT_IN)) { + BMO_elem_flag_set(bm, v, VERT_KEEP); } } /* Search for doubles among all vertices, but only merge non-VERT_KEEP * vertices into VERT_KEEP vertices. */ - BMO_InitOpf(bm, &findop, "finddoubles verts=%av keepverts=%fv", VERT_KEEP); - BMO_CopySlot(op, &findop, "dist", "dist"); - BMO_Exec_Op(bm, &findop); + BMO_op_initf(bm, &findop, "finddoubles verts=%av keepverts=%fv", VERT_KEEP); + BMO_slot_copy(op, &findop, "dist", "dist"); + BMO_op_exec(bm, &findop); /* weld the vertices */ - BMO_Init_Op(bm, &weldop, "weldverts"); - BMO_CopySlot(&findop, &weldop, "targetmapout", "targetmap"); - BMO_Exec_Op(bm, &weldop); + BMO_op_init(bm, &weldop, "weldverts"); + BMO_slot_copy(&findop, &weldop, "targetmapout", "targetmap"); + BMO_op_exec(bm, &weldop); - BMO_Finish_Op(bm, &findop); - BMO_Finish_Op(bm, &weldop); + BMO_op_finish(bm, &findop); + BMO_op_finish(bm, &weldop); } diff --git a/source/blender/bmesh/operators/subdivideop.c b/source/blender/bmesh/operators/subdivideop.c index 204ec9da09e..66f337a4f1b 100644 --- a/source/blender/bmesh/operators/subdivideop.c +++ b/source/blender/bmesh/operators/subdivideop.c @@ -76,8 +76,8 @@ static BMEdge *connect_smallest_face(BMesh *bm, BMVert *v1, BMVert *v2, BMFace * /* this isn't the best thing in the world. it doesn't handle cases where there's * multiple faces yet. that might require a convexity test to figure out which * face is "best," and who knows what for non-manifold conditions. */ - for (face = BMIter_New(&iter, bm, BM_FACES_OF_VERT, v1); face; face = BMIter_Step(&iter)) { - for (v = BMIter_New(&iter2, bm, BM_VERTS_OF_FACE, face); v; v = BMIter_Step(&iter2)) { + for (face = BM_iter_new(&iter, bm, BM_FACES_OF_VERT, v1); face; face = BM_iter_step(&iter)) { + for (v = BM_iter_new(&iter2, bm, BM_VERTS_OF_FACE, face); v; v = BM_iter_step(&iter2)) { if (v == v2) { if (!curf || face->len < curf->len) curf = face; } @@ -85,7 +85,7 @@ static BMEdge *connect_smallest_face(BMesh *bm, BMVert *v1, BMVert *v2, BMFace * } if (curf) { - face = BM_Split_Face(bm, curf, v1, v2, &nl, NULL); + face = BM_face_split(bm, curf, v1, v2, &nl, NULL); if (r_nf) *r_nf = face; return nl ? nl->e : NULL; @@ -101,7 +101,7 @@ static void alter_co(BMesh *bm, BMVert *v, BMEdge *UNUSED(origed), const subdpar float *co = NULL; int i, totlayer = CustomData_number_of_layers(&bm->vdata, CD_SHAPEKEY); - BM_Vert_UpdateAllNormals(bm, v); + BM_vert_normal_update_all(bm, v); co = CustomData_bmesh_get_n(&bm->vdata, v->head.data, CD_SHAPEKEY, params->origkey); copy_v3_v3(prev_co, co); @@ -183,9 +183,9 @@ static BMVert *bm_subdivide_edge_addvert(BMesh *bm, BMEdge *edge, BMEdge *oedge, { BMVert *ev; - ev = BM_Split_Edge(bm, edge->v1, edge, out, percent); + ev = BM_edge_split(bm, edge->v1, edge, out, percent); - BMO_SetFlag(bm, ev, ELE_INNER); + BMO_elem_flag_set(bm, ev, ELE_INNER); /* offset for smooth or sphere or fractal */ alter_co(bm, ev, oedge, params, percent2, vsta, vend); @@ -215,8 +215,8 @@ static BMVert *subdivideedgenum(BMesh *bm, BMEdge *edge, BMEdge *oedge, BMVert *ev; float percent, percent2 = 0.0f; - if (BMO_TestFlag(bm, edge, EDGE_PERCENT) && totpoint == 1) - percent = BMO_Get_MapFloat(bm, params->op, "edgepercents", edge); + if (BMO_elem_flag_test(bm, edge, EDGE_PERCENT) && totpoint == 1) + percent = BMO_slot_map_float_get(bm, params->op, "edgepercents", edge); else { percent = 1.0f / (float)(totpoint + 1-curpoint); percent2 = (float)(curpoint + 1) / (float)(totpoint + 1); @@ -241,13 +241,13 @@ static void bm_subdivide_multicut(BMesh *bm, BMEdge *edge, const subdparams *par for (i = 0; i < numcuts; i++) { v = subdivideedgenum(bm, eed, &temp, i, params->numcuts, params, &newe, vsta, vend); - BMO_SetFlag(bm, v, SUBD_SPLIT); - BMO_SetFlag(bm, eed, SUBD_SPLIT); - BMO_SetFlag(bm, newe, SUBD_SPLIT); + BMO_elem_flag_set(bm, v, SUBD_SPLIT); + BMO_elem_flag_set(bm, eed, SUBD_SPLIT); + BMO_elem_flag_set(bm, newe, SUBD_SPLIT); - BMO_SetFlag(bm, v, ELE_SPLIT); - BMO_SetFlag(bm, eed, ELE_SPLIT); - BMO_SetFlag(bm, newe, SUBD_SPLIT); + BMO_elem_flag_set(bm, v, ELE_SPLIT); + BMO_elem_flag_set(bm, eed, ELE_SPLIT); + BMO_elem_flag_set(bm, newe, SUBD_SPLIT); BM_CHECK_ELEMENT(bm, v); if (v->e) BM_CHECK_ELEMENT(bm, v->e); @@ -483,8 +483,8 @@ static void quad_4edge_subdivide(BMesh *bm, BMFace *UNUSED(face), BMVert **verts if (!e) continue; - BMO_SetFlag(bm, e, ELE_INNER); - BMO_SetFlag(bm, nf, ELE_INNER); + BMO_elem_flag_set(bm, e, ELE_INNER); + BMO_elem_flag_set(bm, nf, ELE_INNER); v1 = lines[(i + 1)*s] = verts[a]; @@ -497,7 +497,7 @@ static void quad_4edge_subdivide(BMesh *bm, BMFace *UNUSED(face), BMVert **verts if (!v) bmesh_error(); - BMO_SetFlag(bm, ne, ELE_INNER); + BMO_elem_flag_set(bm, ne, ELE_INNER); lines[(i + 1) * s + a + 1] = v; } } @@ -510,8 +510,8 @@ static void quad_4edge_subdivide(BMesh *bm, BMFace *UNUSED(face), BMVert **verts if (!e) continue; - BMO_SetFlag(bm, e, ELE_INNER); - BMO_SetFlag(bm, nf, ELE_INNER); + BMO_elem_flag_set(bm, e, ELE_INNER); + BMO_elem_flag_set(bm, nf, ELE_INNER); } } @@ -583,8 +583,8 @@ static void tri_3edge_subdivide(BMesh *bm, BMFace *UNUSED(face), BMVert **verts, e = connect_smallest_face(bm, verts[a], verts[b], &nf); if (!e) goto cleanup; - BMO_SetFlag(bm, e, ELE_INNER); - BMO_SetFlag(bm, nf, ELE_INNER); + BMO_elem_flag_set(bm, e, ELE_INNER); + BMO_elem_flag_set(bm, nf, ELE_INNER); lines[i + 1][0] = verts[a]; lines[i + 1][i + 1] = verts[b]; @@ -599,7 +599,7 @@ static void tri_3edge_subdivide(BMesh *bm, BMFace *UNUSED(face), BMVert **verts, verts[a], verts[b]); lines[i + 1][j + 1] = v; - BMO_SetFlag(bm, ne, ELE_INNER); + BMO_elem_flag_set(bm, ne, ELE_INNER); } } @@ -617,13 +617,13 @@ static void tri_3edge_subdivide(BMesh *bm, BMFace *UNUSED(face), BMVert **verts, for (j = 0; j < i; j++) { e = connect_smallest_face(bm, lines[i][j], lines[i + 1][j + 1], &nf); - BMO_SetFlag(bm, e, ELE_INNER); - BMO_SetFlag(bm, nf, ELE_INNER); + BMO_elem_flag_set(bm, e, ELE_INNER); + BMO_elem_flag_set(bm, nf, ELE_INNER); e = connect_smallest_face(bm, lines[i][j + 1], lines[i + 1][j + 1], &nf); - BMO_SetFlag(bm, e, ELE_INNER); - BMO_SetFlag(bm, nf, ELE_INNER); + BMO_elem_flag_set(bm, e, ELE_INNER); + BMO_elem_flag_set(bm, nf, ELE_INNER); } } @@ -685,16 +685,16 @@ void esubdivide_exec(BMesh *bmesh, BMOperator *op) int beauty, cornertype, singleedge, gridfill; int skey, seed, i, j, matched, a, b, numcuts, totesel; - BMO_Flag_Buffer(bmesh, op, "edges", SUBD_SPLIT, BM_EDGE); + BMO_slot_buffer_flag(bmesh, op, "edges", SUBD_SPLIT, BM_EDGE); - numcuts = BMO_Get_Int(op, "numcuts"); - seed = BMO_Get_Int(op, "seed"); - smooth = BMO_Get_Float(op, "smooth"); - fractal = BMO_Get_Float(op, "fractal"); - beauty = BMO_Get_Int(op, "beauty"); - cornertype = BMO_Get_Int(op, "quadcornertype"); - singleedge = BMO_Get_Int(op, "singleedge"); - gridfill = BMO_Get_Int(op, "gridfill"); + numcuts = BMO_slot_int_get(op, "numcuts"); + seed = BMO_slot_int_get(op, "seed"); + smooth = BMO_slot_float_get(op, "smooth"); + fractal = BMO_slot_float_get(op, "fractal"); + beauty = BMO_slot_int_get(op, "beauty"); + cornertype = BMO_slot_int_get(op, "quadcornertype"); + singleedge = BMO_slot_int_get(op, "singleedge"); + gridfill = BMO_slot_int_get(op, "gridfill"); BLI_srandom(seed); @@ -731,7 +731,7 @@ void esubdivide_exec(BMesh *bmesh, BMOperator *op) } /* add a temporary shapekey layer to store displacements on current geometr */ - BM_add_data_layer(bmesh, &bmesh->vdata, CD_SHAPEKEY); + 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) { @@ -740,7 +740,7 @@ void esubdivide_exec(BMesh *bmesh, BMOperator *op) } /* first go through and tag edge */ - BMO_Flag_To_Slot(bmesh, op, "edges", + BMO_slot_from_flag(bmesh, op, "edges", SUBD_SPLIT, BM_EDGE); params.numcuts = numcuts; @@ -754,15 +754,15 @@ void esubdivide_exec(BMesh *bmesh, BMOperator *op) params.off[1] = (float)BLI_drand() * 200.0f; params.off[2] = (float)BLI_drand() * 200.0f; - BMO_Mapping_To_Flag(bmesh, op, "custompatterns", + BMO_slot_map_to_flag(bmesh, op, "custompatterns", FACE_CUSTOMFILL); - BMO_Mapping_To_Flag(bmesh, op, "edgepercents", + BMO_slot_map_to_flag(bmesh, op, "edgepercents", EDGE_PERCENT); - for (face = BMIter_New(&fiter, bmesh, BM_FACES_OF_MESH, NULL); + for (face = BM_iter_new(&fiter, bmesh, BM_FACES_OF_MESH, NULL); face; - face = BMIter_Step(&fiter)) + face = BM_iter_step(&fiter)) { BMEdge *e1 = NULL, *e2 = NULL; float vec1[3], vec2[3]; @@ -775,13 +775,13 @@ void esubdivide_exec(BMesh *bmesh, BMOperator *op) i = 0; totesel = 0; - for (nl = BMIter_New(&liter, bmesh, BM_LOOPS_OF_FACE, face); nl; nl = BMIter_Step(&liter)) { + for (nl = BM_iter_new(&liter, bmesh, BM_LOOPS_OF_FACE, face); nl; nl = BM_iter_step(&liter)) { BLI_array_growone(edges); BLI_array_growone(verts); edges[i] = nl->e; verts[i] = nl->v; - if (BMO_TestFlag(bmesh, edges[i], SUBD_SPLIT)) { + if (BMO_elem_flag_test(bmesh, edges[i], SUBD_SPLIT)) { if (!e1) e1 = edges[i]; else e2 = edges[i]; @@ -792,7 +792,7 @@ void esubdivide_exec(BMesh *bmesh, BMOperator *op) } /* make sure the two edges have a valid angle to each othe */ - if (totesel == 2 && BM_Edge_Share_Vert(e1, e2)) { + if (totesel == 2 && BM_edge_share_vert(e1, e2)) { float angle; sub_v3_v3v3(vec1, e1->v2->co, e1->v1->co); @@ -807,14 +807,14 @@ void esubdivide_exec(BMesh *bmesh, BMOperator *op) } } - if (BMO_TestFlag(bmesh, face, FACE_CUSTOMFILL)) { - pat = BMO_Get_MapData(bmesh, op, + if (BMO_elem_flag_test(bmesh, face, FACE_CUSTOMFILL)) { + pat = BMO_slot_map_data_get(bmesh, op, "custompatterns", face); for (i = 0; i < pat->len; i++) { matched = 1; for (j = 0; j < pat->len; j++) { a = (j + i) % pat->len; - if ((!!BMO_TestFlag(bmesh, edges[a], SUBD_SPLIT)) != (!!pat->seledges[j])) { + if ((!!BMO_elem_flag_test(bmesh, edges[a], SUBD_SPLIT)) != (!!pat->seledges[j])) { matched = 0; break; } @@ -826,7 +826,7 @@ void esubdivide_exec(BMesh *bmesh, BMOperator *op) facedata[b].start = verts[i]; facedata[b].face = face; facedata[b].totedgesel = totesel; - BMO_SetFlag(bmesh, face, SUBD_SPLIT); + BMO_elem_flag_set(bmesh, face, SUBD_SPLIT); break; } } @@ -844,7 +844,7 @@ void esubdivide_exec(BMesh *bmesh, BMOperator *op) matched = 1; for (b = 0; b < pat->len; b++) { j = (b + a) % pat->len; - if ((!!BMO_TestFlag(bmesh, edges[j], SUBD_SPLIT)) != (!!pat->seledges[b])) { + if ((!!BMO_elem_flag_test(bmesh, edges[j], SUBD_SPLIT)) != (!!pat->seledges[b])) { matched = 0; break; } @@ -857,7 +857,7 @@ void esubdivide_exec(BMesh *bmesh, BMOperator *op) BLI_array_growone(facedata); j = BLI_array_count(facedata) - 1; - BMO_SetFlag(bmesh, face, SUBD_SPLIT); + BMO_elem_flag_set(bmesh, face, SUBD_SPLIT); facedata[j].pat = pat; facedata[j].start = verts[a]; @@ -873,13 +873,13 @@ void esubdivide_exec(BMesh *bmesh, BMOperator *op) BLI_array_growone(facedata); j = BLI_array_count(facedata) - 1; - BMO_SetFlag(bmesh, face, SUBD_SPLIT); + BMO_elem_flag_set(bmesh, face, SUBD_SPLIT); facedata[j].totedgesel = totesel; facedata[j].face = face; } } - einput = BMO_GetSlot(op, "edges"); + einput = BMO_slot_get(op, "edges"); /* go through and split edge */ for (i = 0; i < einput->len; i++) { @@ -913,22 +913,22 @@ void esubdivide_exec(BMesh *bmesh, BMOperator *op) /* find the boundary of one of the split edge */ for (a = 1; a < vlen; a++) { - if (!BMO_TestFlag(bmesh, loops[a - 1]->v, ELE_INNER) && - BMO_TestFlag(bmesh, loops[a]->v, ELE_INNER)) + if (!BMO_elem_flag_test(bmesh, loops[a - 1]->v, ELE_INNER) && + BMO_elem_flag_test(bmesh, loops[a]->v, ELE_INNER)) { break; } } - if (BMO_TestFlag(bmesh, loops[(a + numcuts + 1) % vlen]->v, ELE_INNER)) { + if (BMO_elem_flag_test(bmesh, loops[(a + numcuts + 1) % vlen]->v, ELE_INNER)) { b = (a + numcuts + 1) % vlen; } else { /* find the boundary of the other edge. */ for (j = 0; j < vlen; j++) { b = (j + a + numcuts + 1) % vlen; - if (!BMO_TestFlag(bmesh, loops[b == 0 ? vlen - 1 : b - 1]->v, ELE_INNER) && - BMO_TestFlag(bmesh, loops[b]->v, ELE_INNER)) + if (!BMO_elem_flag_test(bmesh, loops[b == 0 ? vlen - 1 : b - 1]->v, ELE_INNER) && + BMO_elem_flag_test(bmesh, loops[b]->v, ELE_INNER)) { break; } @@ -948,12 +948,12 @@ void esubdivide_exec(BMesh *bmesh, BMOperator *op) a = (a + 1) % vlen; } - //BM_LegalSplits(bmesh, face, splits, BLI_array_count(splits)/2); + //BM_face_legal_splits(bmesh, face, splits, BLI_array_count(splits)/2); for (j = 0; j < BLI_array_count(splits) / 2; j++) { if (splits[j * 2]) { /* BMFace *nf = */ /* UNUSED */ - BM_Split_Face(bmesh, face, splits[j * 2]->v, splits[j * 2 + 1]->v, &nl, NULL); + BM_face_split(bmesh, face, splits[j * 2]->v, splits[j * 2 + 1]->v, &nl, NULL); } } @@ -964,9 +964,9 @@ void esubdivide_exec(BMesh *bmesh, BMOperator *op) } j = a = 0; - for (nl = BMIter_New(&liter, bmesh, BM_LOOPS_OF_FACE, face); + for (nl = BM_iter_new(&liter, bmesh, BM_LOOPS_OF_FACE, face); nl; - nl = BMIter_Step(&liter)) + nl = BM_iter_step(&liter)) { if (nl->v == facedata[i].start) { a = j + 1; @@ -980,7 +980,7 @@ void esubdivide_exec(BMesh *bmesh, BMOperator *op) } j = 0; - for (nl = BMIter_New(&liter, bmesh, BM_LOOPS_OF_FACE, face); nl; nl = BMIter_Step(&liter)) { + for (nl = BM_iter_new(&liter, bmesh, BM_LOOPS_OF_FACE, face); nl; nl = BM_iter_step(&liter)) { b = (j - a + face->len) % face->len; verts[b] = nl->v; j += 1; @@ -996,7 +996,7 @@ void esubdivide_exec(BMesh *bmesh, BMOperator *op) copy_v3_v3(v->co, co); } - BM_free_data_layer_n(bmesh, &bmesh->vdata, CD_SHAPEKEY, skey); + BM_data_layer_free_n(bmesh, &bmesh->vdata, CD_SHAPEKEY, skey); if (facedata) BLI_array_free(facedata); if (edges) BLI_array_free(edges); @@ -1004,12 +1004,12 @@ void esubdivide_exec(BMesh *bmesh, BMOperator *op) BLI_array_free(splits); BLI_array_free(loops); - BMO_Flag_To_Slot(bmesh, op, "outinner", + BMO_slot_from_flag(bmesh, op, "outinner", ELE_INNER, BM_ALL); - BMO_Flag_To_Slot(bmesh, op, "outsplit", + BMO_slot_from_flag(bmesh, op, "outsplit", ELE_SPLIT, BM_ALL); - BMO_Flag_To_Slot(bmesh, op, "geomout", + BMO_slot_from_flag(bmesh, op, "geomout", ELE_INNER|ELE_SPLIT|SUBD_SPLIT, BM_ALL); } @@ -1021,22 +1021,22 @@ void BM_esubdivideflag(Object *UNUSED(obedit), BMesh *bm, int flag, float smooth { BMOperator op; - BMO_InitOpf(bm, &op, "esubd edges=%he smooth=%f fractal=%f " + BMO_op_initf(bm, &op, "esubd edges=%he smooth=%f fractal=%f " "beauty=%d numcuts=%d quadcornertype=%d singleedge=%d " "gridfill=%d seed=%d", flag, smooth, fractal, beauty, numcuts, cornertype, singleedge, gridfill, seed); - BMO_Exec_Op(bm, &op); + BMO_op_exec(bm, &op); if (seltype == SUBDIV_SELECT_INNER) { BMOIter iter; BMHeader *ele; // int i; - ele = BMO_IterNew(&iter, bm, &op, "outinner", BM_EDGE|BM_VERT); - for ( ; ele; ele = BMO_IterStep(&iter)) { - BM_Select(bm, ele, TRUE); + ele = BMO_iter_new(&iter, bm, &op, "outinner", BM_EDGE|BM_VERT); + for ( ; ele; ele = BMO_iter_step(&iter)) { + BM_elem_select_set(bm, ele, TRUE); } } else if (seltype == SUBDIV_SELECT_LOOPCUT) { @@ -1047,27 +1047,27 @@ void BM_esubdivideflag(Object *UNUSED(obedit), BMesh *bm, int flag, float smooth /* deselect inpu */ BM_clear_flag_all(bm, BM_ELEM_SELECT); - ele = BMO_IterNew(&iter, bm, &op, "outinner", BM_EDGE|BM_VERT); - for ( ; ele; ele = BMO_IterStep(&iter)) { - BM_Select(bm, ele, TRUE); + ele = BMO_iter_new(&iter, bm, &op, "outinner", BM_EDGE|BM_VERT); + for ( ; ele; ele = BMO_iter_step(&iter)) { + BM_elem_select_set(bm, ele, TRUE); if (ele->htype == BM_VERT) { BMEdge *e; BMIter eiter; BM_ITER(e, &eiter, bm, BM_EDGES_OF_VERT, ele) { - if (!BM_TestHFlag(e, BM_ELEM_SELECT) && - BM_TestHFlag(e->v1, BM_ELEM_SELECT) && - BM_TestHFlag(e->v2, BM_ELEM_SELECT)) + 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)) { - BM_Select(bm, e, TRUE); + BM_elem_select_set(bm, e, TRUE); bm->totedgesel += 1; } - else if (BM_TestHFlag(e, BM_ELEM_SELECT) && - (!BM_TestHFlag(e->v1, BM_ELEM_SELECT) || - !BM_TestHFlag(e->v2, BM_ELEM_SELECT))) + else 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))) { - BM_Select(bm, e, FALSE); + BM_elem_select_set(bm, e, FALSE); bm->totedgesel -= 1; } } @@ -1075,7 +1075,7 @@ void BM_esubdivideflag(Object *UNUSED(obedit), BMesh *bm, int flag, float smooth } } - BMO_Finish_Op(bm, &op); + BMO_op_finish(bm, &op); } void esplit_exec(BMesh *bm, BMOperator *op) @@ -1085,10 +1085,10 @@ void esplit_exec(BMesh *bm, BMOperator *op) subdparams params; int skey; - params.numcuts = BMO_GetSlot(op, "numcuts")->data.i; + params.numcuts = BMO_slot_get(op, "numcuts")->data.i; params.op = op; - BM_add_data_layer(bm, &bm->vdata, CD_SHAPEKEY); + BM_data_layer_add(bm, &bm->vdata, CD_SHAPEKEY); skey = CustomData_number_of_layers(&bm->vdata, CD_SHAPEKEY) - 1; params.origkey = skey; @@ -1098,7 +1098,7 @@ void esplit_exec(BMesh *bm, BMOperator *op) bm_subdivide_multicut(bm, e, ¶ms, e->v1, e->v2); } - BMO_Flag_To_Slot(bm, op, "outsplit", ELE_SPLIT, BM_ALL); + BMO_slot_from_flag(bm, op, "outsplit", ELE_SPLIT, BM_ALL); - BM_free_data_layer_n(bm, &bm->vdata, CD_SHAPEKEY, skey); + BM_data_layer_free_n(bm, &bm->vdata, CD_SHAPEKEY, skey); } diff --git a/source/blender/bmesh/operators/triangulateop.c b/source/blender/bmesh/operators/triangulateop.c index 163f55adfae..78dd721c0f3 100644 --- a/source/blender/bmesh/operators/triangulateop.c +++ b/source/blender/bmesh/operators/triangulateop.c @@ -49,8 +49,8 @@ void triangulate_exec(BMesh *bm, BMOperator *op) BLI_array_declare(projectverts); int i, lastlen = 0 /* , count = 0 */; - face = BMO_IterNew(&siter, bm, op, "faces", BM_FACE); - for ( ; face; face = BMO_IterStep(&siter)) { + face = BMO_iter_new(&siter, bm, op, "faces", BM_FACE); + for ( ; face; face = BMO_iter_step(&siter)) { if (lastlen < face->len) { BLI_array_empty(projectverts); BLI_array_empty(newfaces); @@ -64,16 +64,16 @@ void triangulate_exec(BMesh *bm, BMOperator *op) BM_Triangulate_Face(bm, face, projectverts, EDGE_NEW, FACE_NEW, newfaces); - BMO_Insert_MapPointer(bm, op, "facemap", face, face); + BMO_slot_map_ptr_insert(bm, op, "facemap", face, face); for (i = 0; newfaces[i]; i++) { - BMO_Insert_MapPointer(bm, op, "facemap", + BMO_slot_map_ptr_insert(bm, op, "facemap", newfaces[i], face); } } - BMO_Flag_To_Slot(bm, op, "edgeout", EDGE_NEW, BM_EDGE); - BMO_Flag_To_Slot(bm, op, "faceout", FACE_NEW, BM_FACE); + BMO_slot_from_flag(bm, op, "edgeout", EDGE_NEW, BM_EDGE); + BMO_slot_from_flag(bm, op, "faceout", FACE_NEW, BM_FACE); BLI_array_free(projectverts); BLI_array_free(newfaces); @@ -87,11 +87,11 @@ void bmesh_beautify_fill_exec(BMesh *bm, BMOperator *op) BMEdge *e; int stop = 0; - BMO_Flag_Buffer(bm, op, "constrain_edges", EDGE_MARK, BM_EDGE); + BMO_slot_buffer_flag(bm, op, "constrain_edges", EDGE_MARK, BM_EDGE); BMO_ITER(f, &siter, bm, op, "faces", BM_FACE) { if (f->len == 3) - BMO_SetFlag(bm, f, FACE_MARK); + BMO_elem_flag_set(bm, f, FACE_MARK); } while (!stop) { @@ -100,9 +100,9 @@ void bmesh_beautify_fill_exec(BMesh *bm, BMOperator *op) BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) { BMVert *v1, *v2, *v3, *v4; - if (BM_Edge_FaceCount(e) != 2 || BMO_TestFlag(bm, e, EDGE_MARK)) + if (BM_edge_face_count(e) != 2 || BMO_elem_flag_test(bm, e, EDGE_MARK)) continue; - if (!BMO_TestFlag(bm, e->l->f, FACE_MARK) || !BMO_TestFlag(bm, e->l->radial_next->f, FACE_MARK)) + if (!BMO_elem_flag_test(bm, e->l->f, FACE_MARK) || !BMO_elem_flag_test(bm, e->l->radial_next->f, FACE_MARK)) continue; v1 = e->l->prev->v; @@ -133,12 +133,12 @@ void bmesh_beautify_fill_exec(BMesh *bm, BMOperator *op) fac2 = opp1 / (len2 + len3 + len6) + opp2 / (len4 + len1 + len6); if (fac1 > fac2) { - e = BM_Rotate_Edge(bm, e, 0); + e = BM_edge_rotate(bm, e, 0); if (e) { - BMO_SetFlag(bm, e, ELE_NEW); + BMO_elem_flag_set(bm, e, ELE_NEW); - BMO_SetFlag(bm, e->l->f, FACE_MARK|ELE_NEW); - BMO_SetFlag(bm, e->l->radial_next->f, FACE_MARK|ELE_NEW); + BMO_elem_flag_set(bm, e->l->f, FACE_MARK|ELE_NEW); + BMO_elem_flag_set(bm, e->l->radial_next->f, FACE_MARK|ELE_NEW); stop = 0; } } @@ -146,7 +146,7 @@ void bmesh_beautify_fill_exec(BMesh *bm, BMOperator *op) } } - BMO_Flag_To_Slot(bm, op, "geomout", ELE_NEW, BM_EDGE|BM_FACE); + BMO_slot_from_flag(bm, op, "geomout", ELE_NEW, BM_EDGE|BM_FACE); } void bmesh_triangle_fill_exec(BMesh *bm, BMOperator *op) @@ -164,7 +164,7 @@ void bmesh_triangle_fill_exec(BMesh *bm, BMOperator *op) BLI_begin_edgefill(); BMO_ITER(e, &siter, bm, op, "edges", BM_EDGE) { - BMO_SetFlag(bm, e, EDGE_MARK); + BMO_elem_flag_set(bm, e, EDGE_MARK); if (!BLI_smallhash_haskey(&hash, (uintptr_t)e->v1)) { eve = BLI_addfillvert(e->v1->co); @@ -187,16 +187,16 @@ void bmesh_triangle_fill_exec(BMesh *bm, BMOperator *op) BLI_edgefill(0); for (efa = fillfacebase.first; efa; efa = efa->next) { - BMFace *f = BM_Make_Face_QuadTri(bm, + BMFace *f = BM_face_create_quad_tri(bm, efa->v1->tmp.p, efa->v2->tmp.p, efa->v3->tmp.p, NULL, NULL, TRUE); BMLoop *l; BMIter liter; - BMO_SetFlag(bm, f, ELE_NEW); + BMO_elem_flag_set(bm, f, ELE_NEW); BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, f) { - if (!BMO_TestFlag(bm, l->e, EDGE_MARK)) { - BMO_SetFlag(bm, l->e, ELE_NEW); + if (!BMO_elem_flag_test(bm, l->e, EDGE_MARK)) { + BMO_elem_flag_set(bm, l->e, ELE_NEW); } } } @@ -205,10 +205,10 @@ void bmesh_triangle_fill_exec(BMesh *bm, BMOperator *op) BLI_smallhash_release(&hash); /* clean up fill */ - BMO_InitOpf(bm, &bmop, "beautify_fill faces=%ff constrain_edges=%fe", ELE_NEW, EDGE_MARK); - BMO_Exec_Op(bm, &bmop); - BMO_Flag_Buffer(bm, &bmop, "geomout", ELE_NEW, BM_FACE|BM_EDGE); - BMO_Finish_Op(bm, &bmop); + BMO_op_initf(bm, &bmop, "beautify_fill faces=%ff constrain_edges=%fe", ELE_NEW, EDGE_MARK); + BMO_op_exec(bm, &bmop); + BMO_slot_buffer_flag(bm, &bmop, "geomout", ELE_NEW, BM_FACE|BM_EDGE); + BMO_op_finish(bm, &bmop); - BMO_Flag_To_Slot(bm, op, "geomout", ELE_NEW, BM_EDGE|BM_FACE); + BMO_slot_from_flag(bm, op, "geomout", ELE_NEW, BM_EDGE|BM_FACE); } diff --git a/source/blender/bmesh/operators/utils.c b/source/blender/bmesh/operators/utils.c index 27cad5bf439..cf6272f5c9c 100644 --- a/source/blender/bmesh/operators/utils.c +++ b/source/blender/bmesh/operators/utils.c @@ -46,10 +46,10 @@ void bmesh_makevert_exec(BMesh *bm, BMOperator *op) { float vec[3]; - BMO_Get_Vec(op, "co", vec); + BMO_slot_vec_get(op, "co", vec); - BMO_SetFlag(bm, BM_Make_Vert(bm, vec, NULL), 1); - BMO_Flag_To_Slot(bm, op, "newvertout", 1, BM_VERT); + BMO_elem_flag_set(bm, BM_vert_create(bm, vec, NULL), 1); + BMO_slot_from_flag(bm, op, "newvertout", 1, BM_VERT); } void bmesh_transform_exec(BMesh *bm, BMOperator *op) @@ -58,7 +58,7 @@ void bmesh_transform_exec(BMesh *bm, BMOperator *op) BMVert *v; float mat[4][4]; - BMO_Get_Mat4(op, "mat", mat); + BMO_slot_mat4_set(op, "mat", mat); BMO_ITER(v, &iter, bm, op, "verts", BM_VERT) { mul_m4_v3(mat, v->co); @@ -69,44 +69,44 @@ void bmesh_translate_exec(BMesh *bm, BMOperator *op) { float mat[4][4], vec[3]; - BMO_Get_Vec(op, "vec", vec); + BMO_slot_vec_get(op, "vec", vec); unit_m4(mat); copy_v3_v3(mat[3], vec); - BMO_CallOpf(bm, "transform mat=%m4 verts=%s", mat, op, "verts"); + BMO_op_callf(bm, "transform mat=%m4 verts=%s", mat, op, "verts"); } void bmesh_scale_exec(BMesh *bm, BMOperator *op) { float mat[3][3], vec[3]; - BMO_Get_Vec(op, "vec", vec); + BMO_slot_vec_get(op, "vec", vec); unit_m3(mat); mat[0][0] = vec[0]; mat[1][1] = vec[1]; mat[2][2] = vec[2]; - BMO_CallOpf(bm, "transform mat=%m3 verts=%s", mat, op, "verts"); + BMO_op_callf(bm, "transform mat=%m3 verts=%s", mat, op, "verts"); } void bmesh_rotate_exec(BMesh *bm, BMOperator *op) { float vec[3]; - BMO_Get_Vec(op, "cent", vec); + BMO_slot_vec_get(op, "cent", vec); /* there has to be a proper matrix way to do this, but * this is how editmesh did it and I'm too tired to think * through the math right now. */ mul_v3_fl(vec, -1.0f); - BMO_CallOpf(bm, "translate verts=%s vec=%v", op, "verts", vec); + BMO_op_callf(bm, "translate verts=%s vec=%v", op, "verts", vec); - BMO_CallOpf(bm, "transform mat=%s verts=%s", op, "mat", op, "verts"); + BMO_op_callf(bm, "transform mat=%s verts=%s", op, "mat", op, "verts"); mul_v3_fl(vec, -1.0f); - BMO_CallOpf(bm, "translate verts=%s vec=%v", op, "verts", vec); + BMO_op_callf(bm, "translate verts=%s vec=%v", op, "verts", vec); } void bmesh_reversefaces_exec(BMesh *bm, BMOperator *op) @@ -115,7 +115,7 @@ void bmesh_reversefaces_exec(BMesh *bm, BMOperator *op) BMFace *f; BMO_ITER(f, &siter, bm, op, "faces", BM_FACE) { - BM_flip_normal(bm, f); + BM_face_normal_flip(bm, f); } } @@ -123,18 +123,18 @@ void bmesh_edgerotate_exec(BMesh *bm, BMOperator *op) { BMOIter siter; BMEdge *e, *e2; - int ccw = BMO_Get_Int(op, "ccw"); + int ccw = BMO_slot_int_get(op, "ccw"); BMO_ITER(e, &siter, bm, op, "edges", BM_EDGE) { - if (!(e2 = BM_Rotate_Edge(bm, e, ccw))) { - BMO_RaiseError(bm, op, BMERR_INVALID_SELECTION, "Could not rotate edge"); + if (!(e2 = BM_edge_rotate(bm, e, ccw))) { + BMO_error_raise(bm, op, BMERR_INVALID_SELECTION, "Could not rotate edge"); return; } - BMO_SetFlag(bm, e2, 1); + BMO_elem_flag_set(bm, e2, 1); } - BMO_Flag_To_Slot(bm, op, "edgeout", 1, BM_EDGE); + BMO_slot_from_flag(bm, op, "edgeout", 1, BM_EDGE); } #define SEL_FLAG 1 @@ -150,14 +150,14 @@ static void bmesh_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) { - if (!BMO_TestFlag(bm, e, SEL_ORIG)) + if (!BMO_elem_flag_test(bm, e, SEL_ORIG)) break; } if (e) { BM_ITER(e, &eiter, bm, BM_EDGES_OF_VERT, v) { - BMO_SetFlag(bm, e, SEL_FLAG); - BMO_SetFlag(bm, BM_OtherEdgeVert(e, v), SEL_FLAG); + BMO_elem_flag_set(bm, e, SEL_FLAG); + BMO_elem_flag_set(bm, BM_edge_other_vert(e, v), SEL_FLAG); } } } @@ -170,8 +170,8 @@ static void bmesh_regionextend_extend(BMesh *bm, BMOperator *op, int usefaces) 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) { - if (!BMO_TestFlag(bm, f2, SEL_ORIG)) - BMO_SetFlag(bm, f2, SEL_FLAG); + if (!BMO_elem_flag_test(bm, f2, SEL_ORIG)) + BMO_elem_flag_set(bm, f2, SEL_FLAG); } } } @@ -188,15 +188,15 @@ static void bmesh_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) { - if (!BMO_TestFlag(bm, e, SEL_ORIG)) + if (!BMO_elem_flag_test(bm, e, SEL_ORIG)) break; } if (e) { - BMO_SetFlag(bm, v, SEL_FLAG); + BMO_elem_flag_set(bm, v, SEL_FLAG); BM_ITER(e, &eiter, bm, BM_EDGES_OF_VERT, v) { - BMO_SetFlag(bm, e, SEL_FLAG); + BMO_elem_flag_set(bm, e, SEL_FLAG); } } } @@ -209,8 +209,8 @@ static void bmesh_regionextend_constrict(BMesh *bm, BMOperator *op, int usefaces 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) { - if (!BMO_TestFlag(bm, f2, SEL_ORIG)) { - BMO_SetFlag(bm, f, SEL_FLAG); + if (!BMO_elem_flag_test(bm, f2, SEL_ORIG)) { + BMO_elem_flag_set(bm, f, SEL_FLAG); break; } } @@ -221,17 +221,17 @@ static void bmesh_regionextend_constrict(BMesh *bm, BMOperator *op, int usefaces void bmesh_regionextend_exec(BMesh *bm, BMOperator *op) { - int usefaces = BMO_Get_Int(op, "usefaces"); - int constrict = BMO_Get_Int(op, "constrict"); + int usefaces = BMO_slot_int_get(op, "usefaces"); + int constrict = BMO_slot_int_get(op, "constrict"); - BMO_Flag_Buffer(bm, op, "geom", SEL_ORIG, BM_ALL); + BMO_slot_buffer_flag(bm, op, "geom", SEL_ORIG, BM_ALL); if (constrict) bmesh_regionextend_constrict(bm, op, usefaces); else bmesh_regionextend_extend(bm, op, usefaces); - BMO_Flag_To_Slot(bm, op, "geomout", SEL_FLAG, BM_ALL); + BMO_slot_from_flag(bm, op, "geomout", SEL_FLAG, BM_ALL); } /********* righthand faces implementation ****** */ @@ -270,25 +270,25 @@ void bmesh_righthandfaces_exec(BMesh *bm, BMOperator *op) BLI_array_declare(fstack); BMLoop *l, *l2; float maxx, cent[3]; - int i, maxi, flagflip = BMO_Get_Int(op, "doflip"); + int i, maxi, flagflip = BMO_slot_int_get(op, "doflip"); startf = NULL; maxx = -1.0e10; - BMO_Flag_Buffer(bm, op, "faces", FACE_FLAG, BM_FACE); + BMO_slot_buffer_flag(bm, op, "faces", FACE_FLAG, BM_FACE); /* find a starting face */ BMO_ITER(f, &siter, bm, op, "faces", BM_FACE) { /* clear dirty flag */ - BM_ClearHFlag(f, BM_ELEM_TAG); + BM_elem_flag_clear(f, BM_ELEM_TAG); - if (BMO_TestFlag(bm, f, FACE_VIS)) + if (BMO_elem_flag_test(bm, f, FACE_VIS)) continue; if (!startf) startf = f; - BM_Compute_Face_CenterBounds(bm, f, cent); + BM_face_center_bounds_calc(bm, f, cent); cent[0] = cent[0]*cent[0] + cent[1]*cent[1] + cent[2]*cent[2]; if (cent[0] > maxx) { @@ -299,15 +299,15 @@ void bmesh_righthandfaces_exec(BMesh *bm, BMOperator *op) if (!startf) return; - BM_Compute_Face_CenterBounds(bm, startf, cent); + BM_face_center_bounds_calc(bm, startf, cent); /* make sure the starting face has the correct winding */ if (dot_v3v3(cent, startf->no) < 0.0f) { - BM_flip_normal(bm, startf); - BMO_ToggleFlag(bm, startf, FACE_FLIP); + BM_face_normal_flip(bm, startf); + BMO_elem_flag_toggle(bm, startf, FACE_FLIP); if (flagflip) - BM_ToggleHFlag(startf, BM_ELEM_TAG); + BM_elem_flag_toggle(startf, BM_ELEM_TAG); } /* now that we've found our starting face, make all connected faces @@ -317,7 +317,7 @@ void bmesh_righthandfaces_exec(BMesh *bm, BMOperator *op) BLI_array_growone(fstack); fstack[0] = startf; - BMO_SetFlag(bm, startf, FACE_VIS); + BMO_elem_flag_set(bm, startf, FACE_VIS); i = 0; maxi = 1; @@ -327,24 +327,24 @@ void bmesh_righthandfaces_exec(BMesh *bm, BMOperator *op) BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, f) { BM_ITER(l2, &liter2, bm, BM_LOOPS_OF_LOOP, l) { - if (!BMO_TestFlag(bm, l2->f, FACE_FLAG) || l2 == l) + if (!BMO_elem_flag_test(bm, l2->f, FACE_FLAG) || l2 == l) continue; - if (!BMO_TestFlag(bm, l2->f, FACE_VIS)) { - BMO_SetFlag(bm, l2->f, FACE_VIS); + if (!BMO_elem_flag_test(bm, l2->f, FACE_VIS)) { + BMO_elem_flag_set(bm, l2->f, FACE_VIS); i++; if (l2->v == l->v) { - BM_flip_normal(bm, l2->f); + BM_face_normal_flip(bm, l2->f); - BMO_ToggleFlag(bm, l2->f, FACE_FLIP); + BMO_elem_flag_toggle(bm, l2->f, FACE_FLIP); if (flagflip) - BM_ToggleHFlag(l2->f, BM_ELEM_TAG); + BM_elem_flag_toggle(l2->f, BM_ELEM_TAG); } - else if (BM_TestHFlag(l2->f, BM_ELEM_TAG) || BM_TestHFlag(l->f, BM_ELEM_TAG)) { + else if (BM_elem_flag_test(l2->f, BM_ELEM_TAG) || BM_elem_flag_test(l->f, BM_ELEM_TAG)) { if (flagflip) { - BM_ClearHFlag(l->f, BM_ELEM_TAG); - BM_ClearHFlag(l2->f, BM_ELEM_TAG); + BM_elem_flag_clear(l->f, BM_ELEM_TAG); + BM_elem_flag_clear(l2->f, BM_ELEM_TAG); } } @@ -363,7 +363,7 @@ void bmesh_righthandfaces_exec(BMesh *bm, BMOperator *op) /* check if we have faces yet to do. if so, recurse */ BMO_ITER(f, &siter, bm, op, "faces", BM_FACE) { - if (!BMO_TestFlag(bm, f, FACE_VIS)) { + if (!BMO_elem_flag_test(bm, f, FACE_VIS)) { bmesh_righthandfaces_exec(bm, op); break; } @@ -378,12 +378,12 @@ void bmesh_vertexsmooth_exec(BMesh *bm, BMOperator *op) BMEdge *e; BLI_array_declare(cos); float (*cos)[3] = NULL; - float *co, *co2, clipdist = BMO_Get_Float(op, "clipdist"); + float *co, *co2, clipdist = BMO_slot_float_get(op, "clipdist"); int i, j, clipx, clipy, clipz; - clipx = BMO_Get_Int(op, "mirror_clip_x"); - clipy = BMO_Get_Int(op, "mirror_clip_y"); - clipz = BMO_Get_Int(op, "mirror_clip_z"); + clipx = BMO_slot_int_get(op, "mirror_clip_x"); + clipy = BMO_slot_int_get(op, "mirror_clip_y"); + clipz = BMO_slot_int_get(op, "mirror_clip_z"); i = 0; BMO_ITER(v, &siter, bm, op, "verts", BM_VERT) { @@ -392,7 +392,7 @@ void bmesh_vertexsmooth_exec(BMesh *bm, BMOperator *op) j = 0; BM_ITER(e, &iter, bm, BM_EDGES_OF_VERT, v) { - co2 = BM_OtherEdgeVert(e, v)->co; + co2 = BM_edge_other_vert(e, v)->co; add_v3_v3v3(co, co, co2); j += 1; } @@ -470,7 +470,7 @@ static float ngon_fake_area(BMesh *bm, BMFace *f) float v[3], sv[3], c[3]; float area = 0.0f; - BM_Compute_Face_CenterMean(bm, f, c); + BM_face_center_mean_calc(bm, f, c); BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, f) { if (num_verts == 0) { @@ -518,10 +518,10 @@ void bmesh_similarfaces_exec(BMesh *bm, BMOperator *op) tmp_face_ext *f_ext = NULL; int *indices = NULL; float t_no[3]; /* temporary normal */ - int type = BMO_Get_Int(op, "type"); - float thresh = BMO_Get_Float(op, "thresh"); + int type = BMO_slot_int_get(op, "type"); + float thresh = BMO_slot_float_get(op, "thresh"); - num_total = BM_Count_Element(bm, BM_FACE); + num_total = BM_mesh_elem_count(bm, BM_FACE); /* ** The first thing to do is to iterate through all the the selected items and mark them since @@ -531,8 +531,8 @@ void bmesh_similarfaces_exec(BMesh *bm, BMOperator *op) ** and n is the total number of faces */ BMO_ITER(fs, &fs_iter, bm, op, "faces", BM_FACE) { - if (!BMO_TestFlag(bm, fs, FACE_MARK)) { /* is this really needed ? */ - BMO_SetFlag(bm, fs, FACE_MARK); + if (!BMO_elem_flag_test(bm, fs, FACE_MARK)) { /* is this really needed ? */ + BMO_elem_flag_set(bm, fs, FACE_MARK); num_sels++; } } @@ -544,7 +544,7 @@ void bmesh_similarfaces_exec(BMesh *bm, BMOperator *op) /* loop through all the faces and fill the faces/indices structure */ BM_ITER(fm, &fm_iter, bm, BM_FACES_OF_MESH, NULL) { f_ext[i].f = fm; - if (BMO_TestFlag(bm, fm, FACE_MARK)) { + if (BMO_elem_flag_test(bm, fm, FACE_MARK)) { indices[idx] = i; idx++; } @@ -565,7 +565,7 @@ void bmesh_similarfaces_exec(BMesh *bm, BMOperator *op) case SIMFACE_COPLANAR: /* compute the center of the polygon */ - BM_Compute_Face_CenterMean(bm, f_ext[i].f, f_ext[i].c); + BM_face_center_mean_calc(bm, f_ext[i].f, f_ext[i].c); /* normalize the polygon normal */ copy_v3_v3(t_no, f_ext[i].f->no); @@ -593,21 +593,21 @@ void bmesh_similarfaces_exec(BMesh *bm, BMOperator *op) /* now select the rest (if any) */ for (i = 0; i < num_total; i++) { fm = f_ext[i].f; - if (!BMO_TestFlag(bm, fm, FACE_MARK) && !BM_TestHFlag(fm, BM_ELEM_HIDDEN)) { + if (!BMO_elem_flag_test(bm, fm, FACE_MARK) && !BM_elem_flag_test(fm, BM_ELEM_HIDDEN)) { int cont = 1; for (idx = 0; idx < num_sels && cont == 1; idx++) { fs = f_ext[indices[idx]].f; switch (type) { case SIMFACE_MATERIAL: if (fm->mat_nr == fs->mat_nr) { - BMO_SetFlag(bm, fm, FACE_MARK); + BMO_elem_flag_set(bm, fm, FACE_MARK); cont = 0; } break; case SIMFACE_IMAGE: if (f_ext[i].t == f_ext[indices[idx]].t) { - BMO_SetFlag(bm, fm, FACE_MARK); + BMO_elem_flag_set(bm, fm, FACE_MARK); cont = 0; } break; @@ -615,7 +615,7 @@ void bmesh_similarfaces_exec(BMesh *bm, BMOperator *op) case SIMFACE_NORMAL: angle = RAD2DEGF(angle_v3v3(fs->no, fm->no)); /* if the angle between the normals -> 0 */ if (angle / 180.0f <= thresh) { - BMO_SetFlag(bm, fm, FACE_MARK); + BMO_elem_flag_set(bm, fm, FACE_MARK); cont = 0; } break; @@ -624,7 +624,7 @@ void bmesh_similarfaces_exec(BMesh *bm, BMOperator *op) angle = RAD2DEGF(angle_v3v3(fs->no, fm->no)); /* angle -> 0 */ if (angle / 180.0f <= thresh) { /* and dot product difference -> 0 */ if (fabsf(f_ext[i].d - f_ext[indices[idx]].d) <= thresh) { - BMO_SetFlag(bm, fm, FACE_MARK); + BMO_elem_flag_set(bm, fm, FACE_MARK); cont = 0; } } @@ -632,14 +632,14 @@ void bmesh_similarfaces_exec(BMesh *bm, BMOperator *op) case SIMFACE_AREA: if (fabsf(f_ext[i].area - f_ext[indices[idx]].area) <= thresh) { - BMO_SetFlag(bm, fm, FACE_MARK); + BMO_elem_flag_set(bm, fm, FACE_MARK); cont = 0; } break; case SIMFACE_PERIMETER: if (fabsf(f_ext[i].perim - f_ext[indices[idx]].perim) <= thresh) { - BMO_SetFlag(bm, fm, FACE_MARK); + BMO_elem_flag_set(bm, fm, FACE_MARK); cont = 0; } break; @@ -652,7 +652,7 @@ void bmesh_similarfaces_exec(BMesh *bm, BMOperator *op) MEM_freeN(indices); /* transfer all marked faces to the output slot */ - BMO_Flag_To_Slot(bm, op, "faceout", FACE_MARK, BM_FACE); + BMO_slot_from_flag(bm, op, "faceout", FACE_MARK, BM_FACE); } /****************************************************************************** @@ -714,14 +714,14 @@ void bmesh_similaredges_exec(BMesh *bm, BMOperator *op) float angle; int num_sels = 0, num_total = 0; - int type = BMO_Get_Int(op, "type"); - float thresh = BMO_Get_Float(op, "thresh"); + int type = BMO_slot_int_get(op, "type"); + float thresh = BMO_slot_float_get(op, "thresh"); - num_total = BM_Count_Element(bm, BM_EDGE); + num_total = BM_mesh_elem_count(bm, BM_EDGE); /* iterate through all selected edges and mark them */ BMO_ITER(es, &es_iter, bm, op, "edges", BM_EDGE) { - BMO_SetFlag(bm, es, EDGE_MARK); + BMO_elem_flag_set(bm, es, EDGE_MARK); num_sels++; } @@ -732,7 +732,7 @@ void bmesh_similaredges_exec(BMesh *bm, BMOperator *op) /* loop through all the edges and fill the edges/indices structure */ BM_ITER(e, &e_iter, bm, BM_EDGES_OF_MESH, NULL) { e_ext[i].e = e; - if (BMO_TestFlag(bm, e, EDGE_MARK)) { + if (BMO_elem_flag_test(bm, e, EDGE_MARK)) { indices[idx] = i; idx++; } @@ -752,11 +752,11 @@ void bmesh_similaredges_exec(BMesh *bm, BMOperator *op) break; case SIMEDGE_FACE: /* count the faces around the edge */ - e_ext[i].faces = BM_Edge_FaceCount(e_ext[i].e); + e_ext[i].faces = BM_edge_face_count(e_ext[i].e); break; case SIMEDGE_FACE_ANGLE: - e_ext[i].faces = BM_Edge_FaceCount(e_ext[i].e); + e_ext[i].faces = BM_edge_face_count(e_ext[i].e); if (e_ext[i].faces == 2) e_ext[i].angle = edge_angle(bm, e_ext[i].e); break; @@ -767,14 +767,14 @@ void bmesh_similaredges_exec(BMesh *bm, BMOperator *op) /* select the edges if any */ for (i = 0; i < num_total; i++) { e = e_ext[i].e; - if (!BMO_TestFlag(bm, e, EDGE_MARK) && !BM_TestHFlag(e, BM_ELEM_HIDDEN)) { + if (!BMO_elem_flag_test(bm, e, EDGE_MARK) && !BM_elem_flag_test(e, BM_ELEM_HIDDEN)) { int cont = 1; for (idx = 0; idx < num_sels && cont == 1; idx++) { es = e_ext[indices[idx]].e; switch (type) { case SIMEDGE_LENGTH: if (fabsf(e_ext[i].length - e_ext[indices[idx]].length) <= thresh) { - BMO_SetFlag(bm, e, EDGE_MARK); + BMO_elem_flag_set(bm, e, EDGE_MARK); cont = 0; } break; @@ -787,14 +787,14 @@ void bmesh_similaredges_exec(BMesh *bm, BMOperator *op) angle = fabsf(angle - 180.0f); if (angle / 90.0f <= thresh) { - BMO_SetFlag(bm, e, EDGE_MARK); + BMO_elem_flag_set(bm, e, EDGE_MARK); cont = 0; } break; case SIMEDGE_FACE: if (e_ext[i].faces == e_ext[indices[idx]].faces) { - BMO_SetFlag(bm, e, EDGE_MARK); + BMO_elem_flag_set(bm, e, EDGE_MARK); cont = 0; } break; @@ -803,7 +803,7 @@ void bmesh_similaredges_exec(BMesh *bm, BMOperator *op) if (e_ext[i].faces == 2) { if (e_ext[indices[idx]].faces == 2) { if (fabsf(e_ext[i].angle - e_ext[indices[idx]].angle) <= thresh) { - BMO_SetFlag(bm, e, EDGE_MARK); + BMO_elem_flag_set(bm, e, EDGE_MARK); cont = 0; } } @@ -821,22 +821,22 @@ void bmesh_similaredges_exec(BMesh *bm, BMOperator *op) c2 = CustomData_bmesh_get(&bm->edata, es->head.data, CD_CREASE); if (c1 && c2 && fabsf(*c1 - *c2) <= thresh) { - BMO_SetFlag(bm, e, EDGE_MARK); + BMO_elem_flag_set(bm, e, EDGE_MARK); cont = 0; } } break; case SIMEDGE_SEAM: - if (BM_TestHFlag(e, BM_ELEM_SEAM) == BM_TestHFlag(es, BM_ELEM_SEAM)) { - BMO_SetFlag(bm, e, EDGE_MARK); + if (BM_elem_flag_test(e, BM_ELEM_SEAM) == BM_elem_flag_test(es, BM_ELEM_SEAM)) { + BMO_elem_flag_set(bm, e, EDGE_MARK); cont = 0; } break; case SIMEDGE_SHARP: - if (BM_TestHFlag(e, BM_ELEM_SHARP) == BM_TestHFlag(es, BM_ELEM_SHARP)) { - BMO_SetFlag(bm, e, EDGE_MARK); + if (BM_elem_flag_test(e, BM_ELEM_SHARP) == BM_elem_flag_test(es, BM_ELEM_SHARP)) { + BMO_elem_flag_set(bm, e, EDGE_MARK); cont = 0; } break; @@ -849,7 +849,7 @@ void bmesh_similaredges_exec(BMesh *bm, BMOperator *op) MEM_freeN(indices); /* transfer all marked edges to the output slot */ - BMO_Flag_To_Slot(bm, op, "edgeout", EDGE_MARK, BM_EDGE); + BMO_slot_from_flag(bm, op, "edgeout", EDGE_MARK, BM_EDGE); } /****************************************************************************** @@ -878,14 +878,14 @@ void bmesh_similarverts_exec(BMesh *bm, BMOperator *op) tmp_vert_ext *v_ext = NULL; int *indices = NULL; int num_total = 0, num_sels = 0, i = 0, idx = 0; - int type = BMO_Get_Int(op, "type"); - float thresh = BMO_Get_Float(op, "thresh"); + int type = BMO_slot_int_get(op, "type"); + float thresh = BMO_slot_float_get(op, "thresh"); - num_total = BM_Count_Element(bm, BM_VERT); + num_total = BM_mesh_elem_count(bm, BM_VERT); /* iterate through all selected edges and mark them */ BMO_ITER(vs, &vs_iter, bm, op, "verts", BM_VERT) { - BMO_SetFlag(bm, vs, VERT_MARK); + BMO_elem_flag_set(bm, vs, VERT_MARK); num_sels++; } @@ -896,15 +896,15 @@ void bmesh_similarverts_exec(BMesh *bm, BMOperator *op) /* loop through all the vertices and fill the vertices/indices structure */ BM_ITER(v, &v_iter, bm, BM_VERTS_OF_MESH, NULL) { v_ext[i].v = v; - if (BMO_TestFlag(bm, v, VERT_MARK)) { + if (BMO_elem_flag_test(bm, v, VERT_MARK)) { indices[idx] = i; idx++; } switch (type) { case SIMVERT_FACE: - /* calling BM_Vert_FaceCount every time is time consumming, so call it only once per vertex */ - v_ext[i].num_faces = BM_Vert_FaceCount(v); + /* calling BM_vert_face_count every time is time consumming, so call it only once per vertex */ + v_ext[i].num_faces = BM_vert_face_count(v); break; case SIMVERT_VGROUP: @@ -923,7 +923,7 @@ void bmesh_similarverts_exec(BMesh *bm, BMOperator *op) /* select the vertices if any */ for (i = 0; i < num_total; i++) { v = v_ext[i].v; - if (!BMO_TestFlag(bm, v, VERT_MARK) && !BM_TestHFlag(v, BM_ELEM_HIDDEN)) { + if (!BMO_elem_flag_test(bm, v, VERT_MARK) && !BM_elem_flag_test(v, BM_ELEM_HIDDEN)) { int cont = 1; for (idx = 0; idx < num_sels && cont == 1; idx++) { vs = v_ext[indices[idx]].v; @@ -931,14 +931,14 @@ void bmesh_similarverts_exec(BMesh *bm, BMOperator *op) case SIMVERT_NORMAL: /* compare the angle between the normals */ if (RAD2DEGF(angle_v3v3(v->no, vs->no)) / 180.0f <= thresh) { - BMO_SetFlag(bm, v, VERT_MARK); + BMO_elem_flag_set(bm, v, VERT_MARK); cont = 0; } break; case SIMVERT_FACE: /* number of adjacent faces */ if (v_ext[i].num_faces == v_ext[indices[idx]].num_faces) { - BMO_SetFlag(bm, v, VERT_MARK); + BMO_elem_flag_set(bm, v, VERT_MARK); cont = 0; } break; @@ -949,7 +949,7 @@ void bmesh_similarverts_exec(BMesh *bm, BMOperator *op) for (v1 = 0; v1 < v_ext[i].dvert->totweight && cont == 1; v1++) { for (v2 = 0; v2 < v_ext[indices[idx]].dvert->totweight; v2++) { if (v_ext[i].dvert->dw[v1].def_nr == v_ext[indices[idx]].dvert->dw[v2].def_nr) { - BMO_SetFlag(bm, v, VERT_MARK); + BMO_elem_flag_set(bm, v, VERT_MARK); cont = 0; break; } @@ -965,7 +965,7 @@ void bmesh_similarverts_exec(BMesh *bm, BMOperator *op) MEM_freeN(indices); MEM_freeN(v_ext); - BMO_Flag_To_Slot(bm, op, "vertout", VERT_MARK, BM_VERT); + BMO_slot_from_flag(bm, op, "vertout", VERT_MARK, BM_VERT); } /****************************************************************************** @@ -979,7 +979,7 @@ void bmesh_rotateuvs_exec(BMesh *bm, BMOperator *op) BMIter l_iter; /* iteration loop */ // int n; - int dir = BMO_Get_Int(op, "dir"); + int dir = BMO_slot_int_get(op, "dir"); BMO_ITER(fs, &fs_iter, bm, op, "faces", BM_FACE) { if (CustomData_has_layer(&(bm->ldata), CD_MLOOPUV)) { @@ -1089,7 +1089,7 @@ void bmesh_rotatecolors_exec(BMesh *bm, BMOperator *op) BMIter l_iter; /* iteration loop */ // int n; - int dir = BMO_Get_Int(op, "dir"); + int dir = BMO_slot_int_get(op, "dir"); BMO_ITER(fs, &fs_iter, bm, op, "faces", BM_FACE) { if (CustomData_has_layer(&(bm->ldata), CD_MLOOPCOL)) { @@ -1208,7 +1208,7 @@ void bmesh_vertexshortestpath_exec(BMesh *bm, BMOperator *op) element_node *vert_list = NULL; int num_total = 0 /*, num_sels = 0 */, i = 0; - int type = BMO_Get_Int(op, "type"); + int type = BMO_slot_int_get(op, "type"); BMO_ITER(vs, &vs_iter, bm, op, "startv", BM_VERT) { sv = vs; @@ -1217,7 +1217,7 @@ void bmesh_vertexshortestpath_exec(BMesh *bm, BMOperator *op) ev = vs; } - num_total = BM_Count_Element(bm, BM_VERT); + num_total = BM_mesh_elem_count(bm, BM_VERT); /* allocate memory for the nodes */ vert_list = (element_node *)MEM_mallocN(sizeof(element_node) * num_total, "vertex nodes"); @@ -1229,7 +1229,7 @@ void bmesh_vertexshortestpath_exec(BMesh *bm, BMOperator *op) vert_list[i].v = v; vert_list[i].parent = NULL; vert_list[i].weight = FLT_MAX; - BM_SetIndex(v, i); /* set_inline */ + BM_elem_index_set(v, i); /* set_inline */ i++; } bm->elem_index_dirty &= ~BM_VERT; @@ -1239,7 +1239,7 @@ void bmesh_vertexshortestpath_exec(BMesh *bm, BMOperator *op) */ /* set the distance/weight of the start vertex to 0 */ - vert_list[BM_GetIndex(sv)].weight = 0.0f; + vert_list[BM_elem_index_get(sv)].weight = 0.0f; h = BLI_heap_new(); @@ -1255,10 +1255,10 @@ void bmesh_vertexshortestpath_exec(BMesh *bm, BMOperator *op) /* take the vertex with the lowest weight out of the heap */ BMVert *v = (BMVert *)BLI_heap_popmin(h); - if (vert_list[BM_GetIndex(v)].weight == FLT_MAX) /* this means that there is no path */ + if (vert_list[BM_elem_index_get(v)].weight == FLT_MAX) /* this means that there is no path */ break; - v_weight = vert_list[BM_GetIndex(v)].weight; + v_weight = vert_list[BM_elem_index_get(v)].weight; BM_ITER(e, &e_i, bm, BM_EDGES_OF_VERT, v) { BMVert *u; @@ -1270,13 +1270,13 @@ void bmesh_vertexshortestpath_exec(BMesh *bm, BMOperator *op) u = (e->v1 == v) ? e->v2 : e->v1; - if (e_weight < vert_list[BM_GetIndex(u)].weight) { /* is this path shorter ? */ + if (e_weight < vert_list[BM_elem_index_get(u)].weight) { /* is this path shorter ? */ /* add it if so */ - vert_list[BM_GetIndex(u)].parent = v; - vert_list[BM_GetIndex(u)].weight = e_weight; + vert_list[BM_elem_index_get(u)].parent = v; + vert_list[BM_elem_index_get(u)].weight = e_weight; /* we should do a heap update node function!!! :-/ */ - BLI_heap_remove(h, vert_list[BM_GetIndex(u)].hn); + BLI_heap_remove(h, vert_list[BM_elem_index_get(u)].hn); BLI_heap_insert(h, e_weight, u); } } @@ -1285,13 +1285,13 @@ void bmesh_vertexshortestpath_exec(BMesh *bm, BMOperator *op) /* now we trace the path (if it exists) */ v = ev; - while (vert_list[BM_GetIndex(v)].parent != NULL) { - BMO_SetFlag(bm, v, VERT_MARK); - v = vert_list[BM_GetIndex(v)].parent; + while (vert_list[BM_elem_index_get(v)].parent != NULL) { + BMO_elem_flag_set(bm, v, VERT_MARK); + v = vert_list[BM_elem_index_get(v)].parent; } BLI_heap_free(h, NULL); MEM_freeN(vert_list); - BMO_Flag_To_Slot(bm, op, "vertout", VERT_MARK, BM_VERT); + BMO_slot_from_flag(bm, op, "vertout", VERT_MARK, BM_VERT); } diff --git a/source/blender/bmesh/tools/BME_bevel.c b/source/blender/bmesh/tools/BME_bevel.c index 2b7537e12e7..6821bea34f7 100644 --- a/source/blender/bmesh/tools/BME_bevel.c +++ b/source/blender/bmesh/tools/BME_bevel.c @@ -125,7 +125,7 @@ float *BME_new_transdata_float(BME_TransData_Head *td) return BLI_memarena_alloc(td->ma, sizeof(float)); } -/* BM_Dissolve_Disk is a real mess, and crashes bevel if called instead of this. +/* BM_disk_dissolve is a real mess, and crashes bevel if called instead of this. * The drawback, though, is that this code doesn't merge customdata. */ static int BME_Bevel_Dissolve_Disk(BMesh *bm, BMVert *v) { @@ -133,18 +133,18 @@ static int BME_Bevel_Dissolve_Disk(BMesh *bm, BMVert *v) BMEdge *e, *elast; BMLoop *l1, *l2; - if (BM_Nonmanifold_Vert(bm, v)) { + if (BM_vert_is_nonmanifold(bm, v)) { return 0; } BM_ITER(e, &iter, bm, BM_EDGES_OF_VERT, v) { - if (BM_Edge_FaceCount(e) != 2) { + if (BM_edge_face_count(e) != 2) { return 0; } } - if (BM_Vert_EdgeCount(v) > 2) { - while (BM_Vert_EdgeCount(v) > 2) { + if (BM_vert_edge_count(v) > 2) { + while (BM_vert_edge_count(v) > 2) { e = v->e; l1 = e->l; l2 = l1->radial_next; @@ -169,9 +169,9 @@ static int BME_bevel_is_split_vert(BMesh *bm, BMLoop *l) * beveling other polys; this can be determined by testing the * vert and the edges around it for originality */ - if ( !BMO_TestFlag(bm, l->v, BME_BEVEL_ORIG) && - BMO_TestFlag(bm, l->e, BME_BEVEL_ORIG) && - BMO_TestFlag(bm, l->prev->e, BME_BEVEL_ORIG)) + if ( !BMO_elem_flag_test(bm, l->v, BME_BEVEL_ORIG) && + BMO_elem_flag_test(bm, l->e, BME_BEVEL_ORIG) && + BMO_elem_flag_test(bm, l->prev->e, BME_BEVEL_ORIG)) { return 1; } @@ -276,8 +276,8 @@ static BMVert *BME_bevel_split_edge(BMesh *bm, BMVert *v, BMVert *v1, BMLoop *l, //printf("You need at least two edges to use BME_bevel_split_edge()\n"); return NULL; } - v2 = BM_OtherEdgeVert(e1, v); - v3 = BM_OtherEdgeVert(e2, v); + v2 = BM_edge_other_vert(e1, v); + v3 = BM_edge_other_vert(e2, v); if (v1 != v2 && v1 != v3) { //printf("Error: more than 2 edges in v's disk cycle, or v1 does not share an edge with v\n"); return NULL; @@ -288,14 +288,14 @@ static BMVert *BME_bevel_split_edge(BMesh *bm, BMVert *v, BMVert *v1, BMLoop *l, else { e1 = e2; } - ov = BM_OtherEdgeVert(e1, v); - sv = BM_Split_Edge(bm, v, e1, &ne, 0); + ov = BM_edge_other_vert(e1, v); + sv = BM_edge_split(bm, v, e1, &ne, 0); //BME_data_interp_from_verts(bm, v, ov, sv, 0.25); /* this is technically wrong.. */ //BME_data_interp_from_faceverts(bm, v, ov, sv, 0.25); //BME_data_interp_from_faceverts(bm, ov, v, sv, 0.25); BME_assign_transdata(td, bm, sv, sv->co, sv->co, NULL, sv->co, 0, -1, -1, NULL); /* quick default */ - BMO_SetFlag(bm, sv, BME_BEVEL_BEVEL); - BMO_SetFlag(bm, ne, BME_BEVEL_ORIG); /* mark edge as original, even though it isn't */ + BMO_elem_flag_set(bm, sv, BME_BEVEL_BEVEL); + BMO_elem_flag_set(bm, ne, BME_BEVEL_ORIG); /* mark edge as original, even though it isn't */ BME_bevel_get_vec(vec1, v1, v, td); BME_bevel_get_vec(vec2, v2, v, td); cross_v3_v3v3(t_up_vec, vec1, vec2); @@ -331,14 +331,14 @@ static BMVert *BME_bevel_split_edge(BMesh *bm, BMVert *v, BMVert *v1, BMLoop *l, } else { is_split_vert = 0; - ov = BM_OtherEdgeVert(l->e, v); - sv = BM_Split_Edge(bm, v, l->e, &ne, 0); + ov = BM_edge_other_vert(l->e, v); + sv = BM_edge_split(bm, v, l->e, &ne, 0); //BME_data_interp_from_verts(bm, v, ov, sv, 0.25); /* this is technically wrong.. */ //BME_data_interp_from_faceverts(bm, v, ov, sv, 0.25); //BME_data_interp_from_faceverts(bm, ov, v, sv, 0.25); BME_assign_transdata(td, bm, sv, sv->co, sv->co, NULL, sv->co, 0, -1, -1, NULL); /* quick default */ - BMO_SetFlag(bm, sv, BME_BEVEL_BEVEL); - BMO_SetFlag(bm, ne, BME_BEVEL_ORIG); /* mark edge as original, even though it isn't */ + BMO_elem_flag_set(bm, sv, BME_BEVEL_BEVEL); + BMO_elem_flag_set(bm, ne, BME_BEVEL_ORIG); /* mark edge as original, even though it isn't */ } if (BME_bevel_is_split_vert(bm, lv2)) { @@ -382,7 +382,7 @@ static BMVert *BME_bevel_split_edge(BMesh *bm, BMVert *v, BMVert *v1, BMLoop *l, } } - dis = BMO_TestFlag(bm, v1, BME_BEVEL_ORIG) ? len / 3 : len / 2; + dis = BMO_elem_flag_test(bm, v1, BME_BEVEL_ORIG) ? len / 3 : len / 2; if (is_edge || dis > maxfactor * value) { dis = maxfactor * value; } @@ -455,14 +455,14 @@ static BMVert *BME_bevel_wire(BMesh *bm, BMVert *v, float value, int res, int UN { BMVert *ov1, *ov2, *v1, *v2; - ov1 = BM_OtherEdgeVert(v->e, v); - ov2 = BM_OtherEdgeVert(bmesh_disk_nextedge(v->e, v), v); + ov1 = BM_edge_other_vert(v->e, v); + ov2 = BM_edge_other_vert(bmesh_disk_nextedge(v->e, v), v); /* split the edges */ v1 = BME_bevel_split_edge(bm, v, ov1, NULL, NULL, value, td); - BMO_SetFlag(bm, v1, BME_BEVEL_NONMAN); + BMO_elem_flag_set(bm, v1, BME_BEVEL_NONMAN); v2 = BME_bevel_split_edge(bm, v, ov2, NULL, NULL, value, td); - BMO_SetFlag(bm, v2, BME_BEVEL_NONMAN); + BMO_elem_flag_set(bm, v2, BME_BEVEL_NONMAN); if (value > 0.5) { BME_bevel_set_max(v1, ov1, value, td); @@ -473,9 +473,9 @@ static BMVert *BME_bevel_wire(BMesh *bm, BMVert *v, float value, int res, int UN if (res) { /* bmesh_jekv; */ - //void BM_Collapse_Vert_Faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac, int calcnorm){ + //void BM_vert_collapse_faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac, int calcnorm){ //hrm, why is there a fac here? it just removes a vert - BM_Collapse_Vert_Edges(bm, v->e, v); + BM_vert_collapse_edges(bm, v->e, v); } return v1; @@ -493,16 +493,16 @@ static BMLoop *BME_bevel_edge(BMesh *bm, BMLoop *l, float value, int UNUSED(opti e = l->e; /* sanity check */ - if ( !BMO_TestFlag(bm, l->e, BME_BEVEL_BEVEL) && - (BMO_TestFlag(bm, l->v, BME_BEVEL_BEVEL) || BMO_TestFlag(bm, l->next->v, BME_BEVEL_BEVEL))) + if ( !BMO_elem_flag_test(bm, l->e, BME_BEVEL_BEVEL) && + (BMO_elem_flag_test(bm, l->v, BME_BEVEL_BEVEL) || BMO_elem_flag_test(bm, l->next->v, BME_BEVEL_BEVEL))) { return l; } /* checks and operations for prev edge */ /* first, check to see if this edge was inset previously */ - if ( !BMO_TestFlag(bm, l->prev->e, BME_BEVEL_ORIG) && - !BMO_TestFlag(bm, l->v, BME_BEVEL_NONMAN)) + if ( !BMO_elem_flag_test(bm, l->prev->e, BME_BEVEL_ORIG) && + !BMO_elem_flag_test(bm, l->v, BME_BEVEL_NONMAN)) { kl = l->prev->radial_next; if (kl->v == l->v) kl = kl->prev; @@ -513,7 +513,7 @@ static BMLoop *BME_bevel_edge(BMesh *bm, BMLoop *l, float value, int UNUSED(opti kv = NULL; } /* get/make the first vert to be used in SFME */ - if (BMO_TestFlag(bm, l->v, BME_BEVEL_NONMAN)) { + if (BMO_elem_flag_test(bm, l->v, BME_BEVEL_NONMAN)) { v1 = l->v; } else { /* we'll need to split the previous edge */ @@ -524,18 +524,18 @@ static BMLoop *BME_bevel_edge(BMesh *bm, BMLoop *l, float value, int UNUSED(opti se = l->next->e; jf = NULL; if (kl->v == kv) { - BM_Split_Face(bm, kl->f, kl->prev->v, kl->next->v, &nl, kl->prev->e); + BM_face_split(bm, kl->f, kl->prev->v, kl->next->v, &nl, kl->prev->e); ke = kl->e; /* BMESH-TODO: jfke doesn't handle customdata */ jf = bmesh_jfke(bm, kl->prev->radial_next->f, kl->f, kl->prev->e); - BM_Collapse_Vert_Edges(bm, ke, kv); + BM_vert_collapse_edges(bm, ke, kv); } else { - BM_Split_Face(bm, kl->f, kl->next->next->v, kl->v, &nl, kl->next->e); + BM_face_split(bm, kl->f, kl->next->next->v, kl->v, &nl, kl->next->e); ke = kl->e; /* BMESH-TODO: jfke doesn't handle customdata */ jf = bmesh_jfke(bm, kl->next->radial_next->f, kl->f, kl->next->e); - BM_Collapse_Vert_Edges(bm, ke, kv); + BM_vert_collapse_edges(bm, ke, kv); } /* find saved loop pointer */ l = se->l; @@ -548,8 +548,8 @@ static BMLoop *BME_bevel_edge(BMesh *bm, BMLoop *l, float value, int UNUSED(opti /* checks and operations for the next edge */ /* first, check to see if this edge was inset previously */ - if ( !BMO_TestFlag(bm, l->next->e, BME_BEVEL_ORIG) && - !BMO_TestFlag(bm, l->next->v, BME_BEVEL_NONMAN)) + if ( !BMO_elem_flag_test(bm, l->next->e, BME_BEVEL_ORIG) && + !BMO_elem_flag_test(bm, l->next->v, BME_BEVEL_NONMAN)) { kl = l->next->radial_next; if (kl->v == l->next->v) kl = kl->prev; @@ -560,7 +560,7 @@ static BMLoop *BME_bevel_edge(BMesh *bm, BMLoop *l, float value, int UNUSED(opti kv = NULL; } /* get/make the second vert to be used in SFME */ - if (BMO_TestFlag(bm, l->next->v, BME_BEVEL_NONMAN)) { + if (BMO_elem_flag_test(bm, l->next->v, BME_BEVEL_NONMAN)) { v2 = l->next->v; } else { /* we'll need to split the next edge */ @@ -571,18 +571,18 @@ static BMLoop *BME_bevel_edge(BMesh *bm, BMLoop *l, float value, int UNUSED(opti se = l->e; jf = NULL; if (kl->v == kv) { - BM_Split_Face(bm, kl->f, kl->prev->v, kl->next->v, &nl, kl->prev->e); + BM_face_split(bm, kl->f, kl->prev->v, kl->next->v, &nl, kl->prev->e); ke = kl->e; /* BMESH-TODO: jfke doesn't handle customdata */ jf = bmesh_jfke(bm, kl->prev->radial_next->f, kl->f, kl->prev->e); - BM_Collapse_Vert_Edges(bm, ke, kv); + BM_vert_collapse_edges(bm, ke, kv); } else { - BM_Split_Face(bm, kl->f, kl->next->next->v, kl->v, &nl, kl->next->e); + BM_face_split(bm, kl->f, kl->next->next->v, kl->v, &nl, kl->next->e); ke = kl->e; /* BMESH-TODO: jfke doesn't handle customdata */ jf = bmesh_jfke(bm, kl->next->radial_next->f, kl->f, kl->next->e); - BM_Collapse_Vert_Edges(bm, ke, kv); + BM_vert_collapse_edges(bm, ke, kv); } /* find saved loop pointer */ l = se->l; @@ -592,9 +592,9 @@ static BMLoop *BME_bevel_edge(BMesh *bm, BMLoop *l, float value, int UNUSED(opti } } - if (!BMO_TestFlag(bm, v1, BME_BEVEL_NONMAN) || !BMO_TestFlag(bm, v2, BME_BEVEL_NONMAN)) { - BM_Split_Face(bm, f, v2, v1, &l, e); - BMO_SetFlag(bm, l->e, BME_BEVEL_BEVEL); + if (!BMO_elem_flag_test(bm, v1, BME_BEVEL_NONMAN) || !BMO_elem_flag_test(bm, v2, BME_BEVEL_NONMAN)) { + BM_face_split(bm, f, v2, v1, &l, e); + BMO_elem_flag_set(bm, l->e, BME_BEVEL_BEVEL); l = l->radial_next; } @@ -621,7 +621,7 @@ static BMLoop *BME_bevel_vert(BMesh *bm, BMLoop *l, float value, int UNUSED(opti l = l->next->next; /* "cut off" this corner */ - f = BM_Split_Face(bm, l->f, v2, v1, NULL, l->e); + f = BM_face_split(bm, l->f, v2, v1, NULL, l->e); return l; } @@ -661,13 +661,13 @@ static BMFace *BME_bevel_poly(BMesh *bm, BMFace *f, float value, int options, BM /* Can't use a BM_LOOPS_OF_FACE iterator here, because the loops are being modified * and so the end condition will never hi */ for (l = BM_FACE_FIRST_LOOP(f)->prev, i = 0, len = f->len; i < len; i++, l = l->next) { - if (BMO_TestFlag(bm, l->e, BME_BEVEL_BEVEL) && BMO_TestFlag(bm, l->e, BME_BEVEL_ORIG)) { + if (BMO_elem_flag_test(bm, l->e, BME_BEVEL_BEVEL) && BMO_elem_flag_test(bm, l->e, BME_BEVEL_ORIG)) { max = 1.0f; l = BME_bevel_edge(bm, l, value, options, up_vec, td); } - else if ( BMO_TestFlag(bm, l->v, BME_BEVEL_BEVEL) && - BMO_TestFlag(bm, l->v, BME_BEVEL_ORIG) && - !BMO_TestFlag(bm, l->prev->e, BME_BEVEL_BEVEL)) + else if ( BMO_elem_flag_test(bm, l->v, BME_BEVEL_BEVEL) && + BMO_elem_flag_test(bm, l->v, BME_BEVEL_ORIG) && + !BMO_elem_flag_test(bm, l->prev->e, BME_BEVEL_BEVEL)) { max = 1.0f; l = BME_bevel_vert(bm, l, value, options, up_vec, td); @@ -680,7 +680,7 @@ static BMFace *BME_bevel_poly(BMesh *bm, BMFace *f, float value, int options, BM if (value > 0.5f && max > 0) { max = -1; BM_ITER(l, &iter, bm, BM_LOOPS_OF_FACE, f) { - if (BMO_TestFlag(bm, l->e, BME_BEVEL_BEVEL) || BMO_TestFlag(bm, l->e, BME_BEVEL_ORIG)) { + 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); vtd2 = BME_get_transdata(td, l->next->v); @@ -733,8 +733,8 @@ static void BME_bevel_add_vweight(BME_TransData_Head *td, BMesh *bm, BMVert *v, { BME_TransData *vtd; - if (BMO_TestFlag(bm, v, BME_BEVEL_NONMAN)) return; - BMO_SetFlag(bm, v, BME_BEVEL_BEVEL); + if (BMO_elem_flag_test(bm, v, BME_BEVEL_NONMAN)) return; + BMO_elem_flag_set(bm, v, BME_BEVEL_BEVEL); if ((vtd = BME_get_transdata(td, v))) { if (options & BME_BEVEL_EMIN) { vtd->factor = 1.0; @@ -770,18 +770,18 @@ static void bevel_init_verts(BMesh *bm, int options, BME_TransData_Head *td) float weight; BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) { weight = 0.0; - if (!BMO_TestFlag(bm, v, BME_BEVEL_NONMAN)) { + if (!BMO_elem_flag_test(bm, v, BME_BEVEL_NONMAN)) { /* modifiers should not use selection */ if(options & BME_BEVEL_SELECT){ - if(BM_TestHFlag(v, BM_ELEM_SELECT)) weight = 1.0; + if(BM_elem_flag_test(v, BM_ELEM_SELECT)) weight = 1.0; } /* bevel weight NYI */ else if(options & BME_BEVEL_WEIGHT) - weight = BM_GetCDf(&bm->vdata, v, CD_BWEIGHT); + weight = BM_elem_float_data_get(&bm->vdata, v, CD_BWEIGHT); else weight = 1.0; if(weight > 0.0){ - BMO_SetFlag(bm, v, BME_BEVEL_BEVEL); + BMO_elem_flag_set(bm, v, BME_BEVEL_BEVEL); BME_assign_transdata(td, bm, v, v->co, v->co, NULL, NULL, 1.0, weight, -1, NULL); } } @@ -796,20 +796,20 @@ static void bevel_init_edges(BMesh *bm, int options, BME_TransData_Head *td) BMIter iter; BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) { weight = 0.0; - if (!BMO_TestFlag(bm, e, BME_BEVEL_NONMAN)) { + if (!BMO_elem_flag_test(bm, e, BME_BEVEL_NONMAN)) { if(options & BME_BEVEL_SELECT){ - if(BM_TestHFlag(e, BM_ELEM_SELECT)) weight = 1.0; + if(BM_elem_flag_test(e, BM_ELEM_SELECT)) weight = 1.0; } else if(options & BME_BEVEL_WEIGHT) { - weight = BM_GetCDf(&bm->edata, e, CD_BWEIGHT); + weight = BM_elem_float_data_get(&bm->edata, e, CD_BWEIGHT); } else { weight = 1.0; } if(weight > 0.0){ - BMO_SetFlag(bm, e, BME_BEVEL_BEVEL); - BMO_SetFlag(bm, e->v1, BME_BEVEL_BEVEL); - BMO_SetFlag(bm, e->v2, BME_BEVEL_BEVEL); + BMO_elem_flag_set(bm, e, BME_BEVEL_BEVEL); + BMO_elem_flag_set(bm, e->v1, BME_BEVEL_BEVEL); + BMO_elem_flag_set(bm, e->v2, BME_BEVEL_BEVEL); BME_bevel_add_vweight(td, bm, e->v1, weight, 1.0, options); BME_bevel_add_vweight(td, bm, e->v2, weight, 1.0, options); } @@ -818,9 +818,9 @@ static void bevel_init_edges(BMesh *bm, int options, BME_TransData_Head *td) /* clean up edges with 2 faces that share more than one edg */ BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) { - if(BMO_TestFlag(bm, e, BME_BEVEL_BEVEL)) { - count = BM_Face_Share_Edges(e->l->f, e->l->radial_next->f); - if(count > 1) BMO_ClearFlag(bm, e, BME_BEVEL_BEVEL); + if(BMO_elem_flag_test(bm, e, BME_BEVEL_BEVEL)) { + count = BM_face_share_edges(e->l->f, e->l->radial_next->f); + if(count > 1) BMO_elem_flag_clear(bm, e, BME_BEVEL_BEVEL); } } } @@ -835,32 +835,32 @@ static BMesh *BME_bevel_initialize(BMesh *bm, int options, int UNUSED(defgrp_ind /* tag non-manifold geometr */ BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) { - BMO_SetFlag(bm, v, BME_BEVEL_ORIG); + BMO_elem_flag_set(bm, v, BME_BEVEL_ORIG); if(v->e){ BME_assign_transdata(td, bm, v, v->co, v->co, NULL, NULL, 0, -1, -1, NULL); - if (BM_Nonmanifold_Vert(bm, v)) - BMO_SetFlag(bm, v, BME_BEVEL_NONMAN); + if (BM_vert_is_nonmanifold(bm, v)) + BMO_elem_flag_set(bm, v, BME_BEVEL_NONMAN); /* test wire ver */ - len = BM_Vert_EdgeCount(v); - if (len == 2 && BM_Wire_Vert(bm, v)) - BMO_ClearFlag(bm, v, BME_BEVEL_NONMAN); + len = BM_vert_edge_count(v); + if (len == 2 && BM_vert_is_wire(bm, v)) + BMO_elem_flag_clear(bm, v, BME_BEVEL_NONMAN); } else - BMO_SetFlag(bm, v, BME_BEVEL_NONMAN); + BMO_elem_flag_set(bm, v, BME_BEVEL_NONMAN); } BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) { - BMO_SetFlag(bm, e, BME_BEVEL_ORIG); - if (BM_Nonmanifold_Edge(bm, e)) { - BMO_SetFlag(bm, e->v1, BME_BEVEL_NONMAN); - BMO_SetFlag(bm, e->v2, BME_BEVEL_NONMAN); - BMO_SetFlag(bm, e, BME_BEVEL_NONMAN); + BMO_elem_flag_set(bm, e, BME_BEVEL_ORIG); + if (BM_edge_is_nonmanifold(bm, e)) { + BMO_elem_flag_set(bm, e->v1, BME_BEVEL_NONMAN); + BMO_elem_flag_set(bm, e->v2, BME_BEVEL_NONMAN); + BMO_elem_flag_set(bm, e, BME_BEVEL_NONMAN); } - if(BMO_TestFlag(bm, e->v1, BME_BEVEL_NONMAN) || BMO_TestFlag(bm, e->v2, BME_BEVEL_NONMAN)) BMO_SetFlag(bm, e, BME_BEVEL_NONMAN); + if(BMO_elem_flag_test(bm, e->v1, BME_BEVEL_NONMAN) || BMO_elem_flag_test(bm, e->v2, BME_BEVEL_NONMAN)) BMO_elem_flag_set(bm, e, BME_BEVEL_NONMAN); } BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) - BMO_SetFlag(bm, f, BME_BEVEL_ORIG); + BMO_elem_flag_set(bm, f, BME_BEVEL_ORIG); if(options & BME_BEVEL_VERT) bevel_init_verts(bm, options, td); else bevel_init_edges(bm, options, td); return bm; @@ -875,13 +875,13 @@ static BMesh *BME_bevel_reinitialize(BMesh *bm) BMIter iter; BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) { - BMO_SetFlag(bm, v, BME_BEVEL_ORIG); + BMO_elem_flag_set(bm, v, BME_BEVEL_ORIG); } BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) { - BMO_SetFlag(bm, e, BME_BEVEL_ORIG); + BMO_elem_flag_set(bm, e, BME_BEVEL_ORIG); } BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) { - BMO_SetFlag(bm, f, BME_BEVEL_ORIG); + BMO_elem_flag_set(bm, f, BME_BEVEL_ORIG); } return bm; @@ -913,21 +913,21 @@ static BMesh *BME_bevel_mesh(BMesh *bm, float value, int UNUSED(res), int option /* bevel poly */ BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) { - if(BMO_TestFlag(bm, f, BME_BEVEL_ORIG)) { + 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) { - if(BMO_TestFlag(bm, e, BME_BEVEL_BEVEL) && BMO_TestFlag(bm, e, BME_BEVEL_ORIG)) { - BM_Join_TwoFaces(bm, e->l->f, e->l->radial_next->f, e); + 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); } } /* link up corners and cli */ BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) { - if(BMO_TestFlag(bm, v, BME_BEVEL_ORIG) && BMO_TestFlag(bm, v, BME_BEVEL_BEVEL)) { + if(BMO_elem_flag_test(bm, v, BME_BEVEL_ORIG) && BMO_elem_flag_test(bm, v, BME_BEVEL_BEVEL)) { curedge = v->e; do{ l = curedge->l; @@ -935,9 +935,9 @@ static BMesh *BME_bevel_mesh(BMesh *bm, float value, int UNUSED(res), int option if(l->v != v) l = l->next; if(l2->v != v) l2 = l2->next; if(l->f->len > 3) - BM_Split_Face(bm, l->f, l->next->v, l->prev->v, &l, l->e); /* clip this corner off */ + BM_face_split(bm, l->f, l->next->v, l->prev->v, &l, l->e); /* clip this corner off */ if(l2->f->len > 3) - BM_Split_Face(bm, l2->f, l2->next->v, l2->prev->v, &l, l2->e); /* clip this corner off */ + BM_face_split(bm, l2->f, l2->next->v, l2->prev->v, &l, l2->e); /* clip this corner off */ curedge = bmesh_disk_nextedge(curedge, v); } while(curedge != v->e); BME_Bevel_Dissolve_Disk(bm, v); diff --git a/source/blender/bmesh/tools/BME_dupe_ops.c b/source/blender/bmesh/tools/BME_dupe_ops.c index 4e864c232fc..df4e4c0967d 100644 --- a/source/blender/bmesh/tools/BME_dupe_ops.c +++ b/source/blender/bmesh/tools/BME_dupe_ops.c @@ -20,7 +20,7 @@ static BMVert *copy_vertex(BMMesh *source_mesh, BMVert *source_vertex, BMMesh *t BMVert *target_vertex = NULL; /*create a new vertex*/ - target_vertex = BM_Make_Vert(target, source_vertex->co, NULL); + target_vertex = BM_vert_create(target, source_vertex->co, NULL); /*insert new vertex into the vert hash*/ BLI_ghash_insert(vhash, source_vertex, target_vertex); @@ -29,10 +29,10 @@ static BMVert *copy_vertex(BMMesh *source_mesh, BMVert *source_vertex, BMMesh *t CustomData_bmesh_copy_data(&source_mesh->vdata, &target_mesh->vdata, source_vertex->data, &target_vertex->data); /*Copy Markings*/ - if(BM_Is_Selected((BMHeader*)source_vertex)) BM_Select_Vert(target_mesh, target_vertex, TRUE); + if(BM_Is_Selected((BMHeader*)source_vertex)) BM_vert_select(target_mesh, target_vertex, TRUE); if(BM_Is_Hidden((BMHeader*)source_vertex)) BM_Mark_Hidden((BMHeader*)target_vertex, 1); - BMO_SetFlag(target_mesh, (BMHeader*)target_vertex, DUPE_NEW); + BMO_elem_flag_set(target_mesh, (BMHeader*)target_vertex, DUPE_NEW); return target_vertex; } @@ -54,7 +54,7 @@ static BMEdge *copy_edge(BMMesh *source_mesh, BMEdge *source_edge, BMMesh *targe target_vert2 = BLI_ghash_lookup(vhash, source_edge->v2); /*create a new edge*/ - target_edge = BM_Make_Edge(target_mesh, target_vert1, target_vert2, NULL, FALSE); + target_edge = BM_edge_create(target_mesh, target_vert1, target_vert2, NULL, FALSE); /*insert new edge into the edge hash*/ BLI_ghash_insert(ehash, source_edge, target_edge); @@ -63,13 +63,13 @@ static BMEdge *copy_edge(BMMesh *source_mesh, BMEdge *source_edge, BMMesh *targe CustomData_bmesh_copy_data(&source_mesh->edata, &target_mesh->edata, source_edge->data, &target_edge->data); /*copy flags*/ - if(BM_Is_Selected((BMHeader*) source_edge)) BM_Select_Edge(target_mesh, target_edge, TRUE); + if(BM_Is_Selected((BMHeader*) source_edge)) BM_edge_select(target_mesh, target_edge, TRUE); if(BM_Is_Hidden((BMHeader*) source_edge)) BM_Mark_Hidden(target_mesh, target_edge, 1); if(BM_Is_Sharp((BMHeader*) source_edge)) BM_Mark_Sharp(target_edge, 1); if(BM_Is_Seam((BMHeader*) source_edge)) BM_Mark_Seam(target_edge, 1); if(BM_Is_Fgon((BMHeader*) source_edge)) BM_Mark_Fgon(target_edge, 1); - BMO_SetFlag(target_mesh, (BMHeader*)target_edge, DUPE_NEW); + BMO_elem_flag_set(target_mesh, (BMHeader*)target_edge, DUPE_NEW); return target_edge; } @@ -103,7 +103,7 @@ static BMFace *copy_face(BMMesh *source_mesh, BMFace *source_face, BMMesh *targe }while(source_loop != source_face->lbase); /*create new face*/ - target_face = BM_Make_Ngon(target_mesh, target_vert1, target_vert2, edar, source_face->len, 0); + target_face = BM_face_create_ngon(target_mesh, target_vert1, target_vert2, edar, source_face->len, 0); /*we copy custom data by hand, we cannot assume that customdata byte layout will be exactly the same....*/ CustomData_bmesh_copy_data(&source_mesh->pdata, &target_mesh->pdata, source_face->data, &target_face->data); @@ -113,7 +113,7 @@ static BMFace *copy_face(BMMesh *source_mesh, BMFace *source_face, BMMesh *targe if(BM_Is_Hidden((BMHeader*)source_face)) BM_Mark_Hidden((BMHeader*)target_face, 1); /*mark the face for output*/ - BMO_SetFlag(target_mesh, (BMHeader*)target_face, DUPE_NEW); + BMO_elem_flag_set(target_mesh, (BMHeader*)target_face, DUPE_NEW); /*copy per-loop custom data*/ source_loop = source_face->lbase; @@ -162,58 +162,58 @@ static void copy_mesh(BMMesh *source, BMMesh *target) ehash = BLI_ghash_new(BLI_ghashutil_ptrrhash, BLI_ghashutil_ptrcmp); /*initialize edge pointer array*/ - for(f = BMIter_New(&faces, source, BM_FACES, source, 0, NULL); f; f = BMIter_Step(&faces)){ + for(f = BM_iter_new(&faces, source, BM_FACES, source, 0, NULL); f; f = BM_iter_step(&faces)){ if(f->len > maxlength) maxlength = f->len; } edar = MEM_callocN(sizeof(BMEdge*) * maxlength, "BM copy mesh edge pointer array"); /*first we dupe all flagged faces and their elements from source*/ - for(f = BMIter_New(&faces, source, BM_FACES, source, 0, NULL); f; f= BMIter_Step(&faces)){ - if(BMO_TestFlag(source, (BMHeader*)f, DUPE_INPUT)){ + for(f = BM_iter_new(&faces, source, BM_FACES, source, 0, NULL); f; f= BM_iter_step(&faces)){ + if(BMO_elem_flag_test(source, (BMHeader*)f, DUPE_INPUT)){ /*vertex pass*/ - for(v = BMIter_New(&verts, source, BM_VERT_OF_FACE, f, 0, NULL); v; v = BMIter_Step(&verts)){ - if(!BMO_TestFlag(source, (BMHeader*)v, DUPE_DONE)){ + for(v = BM_iter_new(&verts, source, BM_VERT_OF_FACE, f, 0, NULL); v; v = BM_iter_step(&verts)){ + if(!BMO_elem_flag_test(source, (BMHeader*)v, DUPE_DONE)){ copy_vertex(source,v, target, vhash); - BMO_SetFlag(source, (BMHeader*)v, DUPE_DONE); + BMO_elem_flag_set(source, (BMHeader*)v, DUPE_DONE); } } /*edge pass*/ - for(e = BMIter_New(&edges, source, BM_EDGE_OF_FACE, f, 0, NULL); e; e = BMeshIter_step(&edges)){ - if(!BMO_TestFlag(source, (BMHeader*)e, DUPE_DONE)){ + for(e = BM_iter_new(&edges, source, BM_EDGE_OF_FACE, f, 0, NULL); e; e = BMeshIter_step(&edges)){ + if(!BMO_elem_flag_test(source, (BMHeader*)e, DUPE_DONE)){ copy_edge(source, e, target, vhash, ehash); - BMO_SetFlag(source, (BMHeader*)e, DUPE_DONE); + BMO_elem_flag_set(source, (BMHeader*)e, DUPE_DONE); } } copy_face(source, f, target, edar, vhash, ehash); - BMO_SetFlag(source, (BMHeader*)f, DUPE_DONE); + BMO_elem_flag_set(source, (BMHeader*)f, DUPE_DONE); } } /*now we dupe all the edges*/ - for(e = BMIter_New(&edges, source, BM_EDGES, source, 0, NULL); e; e = BMIter_Step(&edges)){ - if(BMO_TestFlag(source, (BMHeader*)e, DUPE_INPUT) && (!BMO_TestFlag(source, (BMHeader*)e, DUPE_DONE))){ + for(e = BM_iter_new(&edges, source, BM_EDGES, source, 0, NULL); e; e = BM_iter_step(&edges)){ + if(BMO_elem_flag_test(source, (BMHeader*)e, DUPE_INPUT) && (!BMO_elem_flag_test(source, (BMHeader*)e, DUPE_DONE))){ /*make sure that verts are copied*/ - if(!BMO_TestFlag(source, (BMHeader*)e->v1, DUPE_DONE){ + if(!BMO_elem_flag_test(source, (BMHeader*)e->v1, DUPE_DONE){ copy_vertex(source, e->v1, target, vhash); - BMO_SetFlag(source, (BMHeader*)e->v1, DUPE_DONE); + BMO_elem_flag_set(source, (BMHeader*)e->v1, DUPE_DONE); } - if(!BMO_TestFlag(source, (BMHeader*)e->v2, DUPE_DONE){ + if(!BMO_elem_flag_test(source, (BMHeader*)e->v2, DUPE_DONE){ copy_vertex(source, e->v2, target, vhash); - BMO_SetFlag(source, (BMHeader*)e->v2, DUPE_DONE); + BMO_elem_flag_set(source, (BMHeader*)e->v2, DUPE_DONE); } /*now copy the actual edge*/ copy_edge(source, e, target, vhash, ehash); - BMO_SetFlag(source, (BMHeader*)e, DUPE_DONE); + BMO_elem_flag_set(source, (BMHeader*)e, DUPE_DONE); } } /*finally dupe all loose vertices*/ - for(v = BMIter_New(&verts, source, BM_VERTS, source, 0, NULL); v; v = BMIter_Step(&verts)){ - if(BMO_TestFlag(source, (BMHeader*)v, DUPE_INPUT) && (!BMO_TestFlag(source, (BMHeader*)v, DUPE_DONE))){ + for(v = BM_iter_new(&verts, source, BM_VERTS, source, 0, NULL); v; v = BM_iter_step(&verts)){ + if(BMO_elem_flag_test(source, (BMHeader*)v, DUPE_INPUT) && (!BMO_elem_flag_test(source, (BMHeader*)v, DUPE_DONE))){ copy_vertex(source, v, target, vhash); - BMO_SetFlag(source, (BMHeader*)v, DUPE_DONE); + BMO_elem_flag_set(source, (BMHeader*)v, DUPE_DONE); } } @@ -267,9 +267,9 @@ void dupeop_exec(BMMesh *bm, BMOperator *op) finput = BMO_Get_Slot(dupeop, BMOP_DUPE_FINPUT); /*go through vinput, einput, and finput and flag elements with private flags*/ - BMO_Flag_Buffer(bm, dupeop, BMOP_DUPE_VINPUT, DUPE_INPUT); - BMO_Flag_Buffer(bm, dupeop, BMOP_DUPE_EINPUT, DUPE_INPUT); - BMO_Flag_Buffer(bm, dupeop, BMOP_DUPE_FINPUT, DUPE_INPUT); + BMO_slot_buffer_flag(bm, dupeop, BMOP_DUPE_VINPUT, DUPE_INPUT); + BMO_slot_buffer_flag(bm, dupeop, BMOP_DUPE_EINPUT, DUPE_INPUT); + BMO_slot_buffer_flag(bm, dupeop, BMOP_DUPE_FINPUT, DUPE_INPUT); /*use the internal copy function*/ copy_mesh(bm, bm); @@ -281,9 +281,9 @@ void dupeop_exec(BMMesh *bm, BMOperator *op) BMO_Copy_Opslot_Buffer_Alloc(dupeop, finput, BMO_Get_Slot(dupeop, BMOP_DUPE_FORIGINAL)); /*Now alloc the new output buffers*/ - BMO_Flag_To_Slot(bm, dupeop, BMOP_DUPE_VNEW, DUPE_NEW, BMESH_VERT); - BMO_Flag_To_Slot(bm, dupeop, BMOP_DUPE_ENEW, DUPE_NEW, BMESH_EDGE); - BMO_Flag_To_Slot(bm, dupeop, BMOP_DUPE_FNEW, DUPE_NEW, BMESH_FACE); + BMO_slot_from_flag(bm, dupeop, BMOP_DUPE_VNEW, DUPE_NEW, BMESH_VERT); + BMO_slot_from_flag(bm, dupeop, BMOP_DUPE_ENEW, DUPE_NEW, BMESH_EDGE); + BMO_slot_from_flag(bm, dupeop, BMOP_DUPE_FNEW, DUPE_NEW, BMESH_FACE); } void splitop_exec(BMMesh *bm, BMOperator *op) @@ -293,21 +293,21 @@ void splitop_exec(BMMesh *bm, BMOperator *op) BMOperator delop; /*initialize our sub-operators*/ - BMO_Init_Op(&dupeop, BMOP_DUPE); - BMO_Init_Op(&delop, BMOP_DEL); + BMO_op_init(&dupeop, BMOP_DUPE); + BMO_op_init(&delop, BMOP_DEL); BMO_Connect(BMO_Get_Slot(splitop, BMOP_SPLIT_VINPUT),BMO_Get_Slot(&dupeop, BMOP_DUPE_VINPUT)); BMO_Connect(BMO_Get_Slot(splitop, BMOP_SPLIT_EINPUT),BMO_Get_Slot(&dupeop, BMOP_DUPE_EINPUT)); BMO_Connect(BMO_Get_Slot(splitop, BMOP_SPLIT_FINPUT),BMO_Get_Slot(&dupeop, BMOP_DUPE_FINPUT)); - BMO_Exec_Op(&dupeop); + BMO_op_exec(&dupeop); /*connect outputs of dupe to delete*/ BMO_Connect(BMO_Get_Slot(&dupeop, BMOP_DUPE_VORIGINAL), BMO_Get_Slot(&delop, BMOP_DEL_VINPUT)); BMO_Connect(BMO_Get_Slot(&dupeop, BMOP_DUPE_EORIGINAL), BMO_Get_Slot(&delop, BMOP_DEL_EINPUT)); BMO_Connect(BMO_Get_Slot(&dupeop, BMOP_DUPE_FORIGINAL), BMO_Get_Slot(&delop, BMOP_DEL_FINPUT)); - BMO_Exec_Op(&delop); + BMO_op_exec(&delop); /*now we make our outputs by copying the dupe outputs*/ BMO_Copy_Buffer_Alloc(BMO_Get_Slot(&dupeop, BMOP_DUPE_VNEW), BMO_Get_Slot(splitop, BMOP_SPLIT_VOUTPUT)); @@ -315,8 +315,8 @@ void splitop_exec(BMMesh *bm, BMOperator *op) BMO_Copy_Buffer_Alloc(BMO_Get_Slot(&dupeop, BMOP_DUPE_FNEW), BMO_Get_Slot(splitop, BMOP_SPLIT_FOUTPUT)); /*cleanup*/ - BMO_Finish_Op(&dupeop); - BMO_Finish_Op(&delop); + BMO_op_finish(&dupeop); + BMO_op_finish(&delop); } #endif diff --git a/source/blender/editors/mesh/bmesh_select.c b/source/blender/editors/mesh/bmesh_select.c index 948eb55b55f..8e09055a93b 100644 --- a/source/blender/editors/mesh/bmesh_select.c +++ b/source/blender/editors/mesh/bmesh_select.c @@ -71,11 +71,11 @@ void EDBM_select_mirrored(Object *UNUSED(obedit), BMEditMesh *em, int extend) BMIter iter; BM_ITER(v1, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (!BM_TestHFlag(v1, BM_ELEM_SELECT) || BM_TestHFlag(v1, BM_ELEM_HIDDEN)) { - BM_ClearHFlag(v1, BM_ELEM_TAG); + if (!BM_elem_flag_test(v1, BM_ELEM_SELECT) || BM_elem_flag_test(v1, BM_ELEM_HIDDEN)) { + BM_elem_flag_clear(v1, BM_ELEM_TAG); } else { - BM_SetHFlag(v1, BM_ELEM_TAG); + BM_elem_flag_set(v1, BM_ELEM_TAG); } } @@ -85,12 +85,12 @@ void EDBM_select_mirrored(Object *UNUSED(obedit), BMEditMesh *em, int extend) EDBM_clear_flag_all(em, BM_ELEM_SELECT); BM_ITER(v1, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (!BM_TestHFlag(v1, BM_ELEM_TAG) || BM_TestHFlag(v1, BM_ELEM_HIDDEN)) + if (!BM_elem_flag_test(v1, BM_ELEM_TAG) || BM_elem_flag_test(v1, BM_ELEM_HIDDEN)) continue; v2 = EDBM_GetMirrorVert(em, v1); - if (v2 && !BM_TestHFlag(v2, BM_ELEM_HIDDEN)) { - BM_Select(em->bm, v2, TRUE); + if (v2 && !BM_elem_flag_test(v2, BM_ELEM_HIDDEN)) { + BM_elem_select_set(em->bm, v2, TRUE); } } @@ -108,7 +108,7 @@ void EDBM_automerge(Scene *scene, Object *obedit, int update) if (!em) return; - BMO_CallOpf(em->bm, "automerge verts=%hv dist=%f", BM_ELEM_SELECT, scene->toolsettings->doublimit); + BMO_op_callf(em->bm, "automerge verts=%hv dist=%f", BM_ELEM_SELECT, scene->toolsettings->doublimit); if (update) { DAG_id_tag_update(obedit->data, OB_RECALC_DATA); } @@ -334,7 +334,7 @@ static void findnearestvert__doClosest(void *userData, BMVert *eve, int x, int y if (data->dist > 3) { int temp = abs(data->mval[0] - x) + abs(data->mval[1]- y); - if (BM_TestHFlag(eve, BM_ELEM_SELECT) == data->select) { + if (BM_elem_flag_test(eve, BM_ELEM_SELECT) == data->select) { if (data->strict == 1) return; else @@ -355,9 +355,9 @@ static void findnearestvert__doClosest(void *userData, BMVert *eve, int x, int y static unsigned int findnearestvert__backbufIndextest(void *handle, unsigned int index) { BMEditMesh *em = (BMEditMesh *)handle; - BMVert *eve = BM_Vert_AtIndex(em->bm, index - 1); + BMVert *eve = BM_vert_at_index(em->bm, index - 1); - if (eve && BM_TestHFlag(eve, BM_ELEM_SELECT)) return 0; + if (eve && BM_elem_flag_test(eve, BM_ELEM_SELECT)) return 0; return 1; } /** @@ -385,7 +385,7 @@ BMVert *EDBM_findnearestvert(ViewContext *vc, int *dist, short sel, short strict 0, NULL, NULL); } - eve = BM_Vert_AtIndex(vc->em->bm, index - 1); + eve = BM_vert_at_index(vc->em->bm, index - 1); if (eve && distance < *dist) { *dist = distance; @@ -401,7 +401,7 @@ BMVert *EDBM_findnearestvert(ViewContext *vc, int *dist, short sel, short strict static int lastSelectedIndex = 0; static BMVert *lastSelected = NULL; - if (lastSelected && BM_Vert_AtIndex(vc->em->bm, lastSelectedIndex) != lastSelected) { + if (lastSelected && BM_vert_at_index(vc->em->bm, lastSelectedIndex) != lastSelected) { lastSelectedIndex = 0; lastSelected = NULL; } @@ -462,7 +462,7 @@ static void findnearestedge__doClosest(void *userData, BMEdge *eed, int x0, int distance = dist_to_line_segment_v2(data->mval, v1, v2); - if (BM_TestHFlag(eed, BM_ELEM_SELECT)) { + if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) { distance += 5; } @@ -498,7 +498,7 @@ BMEdge *EDBM_findnearestedge(ViewContext *vc, int *dist) view3d_validate_backbuf(vc); index = view3d_sample_backbuf_rect(vc, vc->mval, 50, bm_solidoffs, bm_wireoffs, &distance,0, NULL, NULL); - eed = BM_Edge_AtIndex(vc->em->bm, index - 1); + eed = BM_edge_at_index(vc->em->bm, index - 1); if (eed && distance < *dist) { *dist = distance; @@ -570,7 +570,7 @@ BMFace *EDBM_findnearestface(ViewContext *vc, int *dist) view3d_validate_backbuf(vc); index = view3d_sample_backbuf(vc, vc->mval[0], vc->mval[1]); - efa = BM_Face_AtIndex(vc->em->bm, index - 1); + efa = BM_face_at_index(vc->em->bm, index - 1); if (efa) { struct { short mval[2]; int dist; BMFace *toFace; } data; @@ -595,7 +595,7 @@ BMFace *EDBM_findnearestface(ViewContext *vc, int *dist) static int lastSelectedIndex = 0; static BMFace *lastSelected = NULL; - if (lastSelected && BM_Face_AtIndex(vc->em->bm, lastSelectedIndex) != lastSelected) { + if (lastSelected && BM_face_at_index(vc->em->bm, lastSelectedIndex) != lastSelected) { lastSelectedIndex = 0; lastSelected = NULL; } @@ -704,13 +704,13 @@ static int similar_face_select_exec(bContext *C, wmOperator *op) EDBM_InitOpf(em, &bmop, op, "similarfaces faces=%hf type=%d thresh=%f", BM_ELEM_SELECT, type, thresh); /* execute the operator */ - BMO_Exec_Op(em->bm, &bmop); + BMO_op_exec(em->bm, &bmop); /* clear the existing selection */ EDBM_clear_flag_all(em, BM_ELEM_SELECT); /* select the output */ - BMO_HeaderFlag_Buffer(em->bm, &bmop, "faceout", BM_ELEM_SELECT, BM_ALL); + BMO_slot_buffer_hflag(em->bm, &bmop, "faceout", BM_ELEM_SELECT, BM_ALL); /* finish the operator */ if (!EDBM_FinishOp(em, &bmop, op, TRUE)) { @@ -745,13 +745,13 @@ static int similar_edge_select_exec(bContext *C, wmOperator *op) EDBM_InitOpf(em, &bmop, op, "similaredges edges=%he type=%d thresh=%f", BM_ELEM_SELECT, type, thresh); /* execute the operator */ - BMO_Exec_Op(em->bm, &bmop); + BMO_op_exec(em->bm, &bmop); /* clear the existing selection */ EDBM_clear_flag_all(em, BM_ELEM_SELECT); /* select the output */ - BMO_HeaderFlag_Buffer(em->bm, &bmop, "edgeout", BM_ELEM_SELECT, BM_ALL); + BMO_slot_buffer_hflag(em->bm, &bmop, "edgeout", BM_ELEM_SELECT, BM_ALL); EDBM_selectmode_flush(em); /* finish the operator */ @@ -790,13 +790,13 @@ static int similar_vert_select_exec(bContext *C, wmOperator *op) EDBM_InitOpf(em, &bmop, op, "similarverts verts=%hv type=%d thresh=%f", BM_ELEM_SELECT, type, thresh); /* execute the operator */ - BMO_Exec_Op(em->bm, &bmop); + BMO_op_exec(em->bm, &bmop); /* clear the existing selection */ EDBM_clear_flag_all(em, BM_ELEM_SELECT); /* select the output */ - BMO_HeaderFlag_Buffer(em->bm, &bmop, "vertout", BM_ELEM_SELECT, BM_ALL); + BMO_slot_buffer_hflag(em->bm, &bmop, "vertout", BM_ELEM_SELECT, BM_ALL); /* finish the operator */ if (!EDBM_FinishOp(em, &bmop, op, TRUE)) { @@ -892,17 +892,17 @@ static void walker_select(BMEditMesh *em, int walkercode, void *start, int selec BMHeader *h; BMWalker walker; - BMW_Init(&walker, bm, walkercode, + BMW_init(&walker, bm, walkercode, BMW_MASK_NOP, BMW_MASK_NOP, BMW_MASK_NOP, BMW_MASK_NOP, BMW_NIL_LAY); - h = BMW_Begin(&walker, start); - for ( ; h; h = BMW_Step(&walker)) { + h = BMW_begin(&walker, start); + for ( ; h; h = BMW_step(&walker)) { if (!select) { - BM_remove_selection(bm, h); + BM_select_history_remove(bm, h); } - BM_Select(bm, h, select); + BM_elem_select_set(bm, h, select); } - BMW_End(&walker); + BMW_end(&walker); } static int loop_multiselect(bContext *C, wmOperator *op) @@ -917,10 +917,10 @@ static int loop_multiselect(bContext *C, wmOperator *op) BMIter iter; int totedgesel = 0; - for (eed = BMIter_New(&iter, em->bm, BM_EDGES_OF_MESH, NULL); - eed; eed = BMIter_Step(&iter)) { + for (eed = BM_iter_new(&iter, em->bm, BM_EDGES_OF_MESH, NULL); + eed; eed = BM_iter_step(&iter)) { - if (BM_TestHFlag(eed, BM_ELEM_SELECT)) { + if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) { totedgesel++; } } @@ -929,12 +929,12 @@ static int loop_multiselect(bContext *C, wmOperator *op) edarray = MEM_mallocN(sizeof(BMEdge *)*totedgesel,"edge array"); edindex = 0; - for (eed = BMIter_New(&iter, em->bm, BM_EDGES_OF_MESH, NULL); + for (eed = BM_iter_new(&iter, em->bm, BM_EDGES_OF_MESH, NULL); eed; - eed = BMIter_Step(&iter)) + eed = BM_iter_step(&iter)) { - if (BM_TestHFlag(eed, BM_ELEM_SELECT)) { + if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) { edarray[edindex] = eed; edindex++; } @@ -1008,7 +1008,7 @@ static void mouse_mesh_loop(bContext *C, int mval[2], short extend, short ring) EDBM_clear_flag_all(em, BM_ELEM_SELECT); } - if (BM_TestHFlag(eed, BM_ELEM_SELECT) == 0) { + if (BM_elem_flag_test(eed, BM_ELEM_SELECT) == 0) { select = TRUE; } else if (extend) { @@ -1159,15 +1159,15 @@ static void edgetag_context_set(BMEditMesh *em, Scene *scene, BMEdge *e, int val switch (scene->toolsettings->edge_mode) { case EDGE_MODE_SELECT: - BM_Select(em->bm, e, val); + BM_elem_select_set(em->bm, e, val); break; case EDGE_MODE_TAG_SEAM: - if (val) {BM_SetHFlag(e, BM_ELEM_SEAM);} - else {BM_ClearHFlag(e, BM_ELEM_SEAM);} + if (val) {BM_elem_flag_set(e, BM_ELEM_SEAM);} + else {BM_elem_flag_clear(e, BM_ELEM_SEAM);} break; case EDGE_MODE_TAG_SHARP: - if (val) {BM_SetHFlag(e, BM_ELEM_SEAM);} - else {BM_ClearHFlag(e, BM_ELEM_SEAM);} + if (val) {BM_elem_flag_set(e, BM_ELEM_SEAM);} + else {BM_elem_flag_clear(e, BM_ELEM_SEAM);} break; case EDGE_MODE_TAG_CREASE: { @@ -1192,15 +1192,15 @@ static int edgetag_context_check(Scene *scene, BMEditMesh *em, BMEdge *e) { switch (scene->toolsettings->edge_mode) { case EDGE_MODE_SELECT: - return BM_TestHFlag(e, BM_ELEM_SELECT) ? 1 : 0; + return BM_elem_flag_test(e, BM_ELEM_SELECT) ? 1 : 0; case EDGE_MODE_TAG_SEAM: - return BM_TestHFlag(e, BM_ELEM_SEAM); + return BM_elem_flag_test(e, BM_ELEM_SEAM); case EDGE_MODE_TAG_SHARP: - return BM_TestHFlag(e, BM_ELEM_SHARP); + return BM_elem_flag_test(e, BM_ELEM_SHARP); case EDGE_MODE_TAG_CREASE: - return BM_GetCDf(&em->bm->edata, e, CD_CREASE) ? 1 : 0; + return BM_elem_float_data_get(&em->bm->edata, e, CD_CREASE) ? 1 : 0; case EDGE_MODE_TAG_BEVEL: - return BM_GetCDf(&em->bm->edata, e, CD_BWEIGHT) ? 1 : 0; + return BM_elem_float_data_get(&em->bm->edata, e, CD_BWEIGHT) ? 1 : 0; } return 0; } @@ -1218,15 +1218,15 @@ static int edgetag_shortest_path(Scene *scene, BMEditMesh *em, BMEdge *source, B BLI_smallhash_init(&visithash); /* note, would pass BM_EDGE except we are looping over all edges anyway */ - BM_ElemIndex_Ensure(em->bm, BM_VERT /* | BM_EDGE */); + BM_mesh_elem_index_ensure(em->bm, BM_VERT /* | BM_EDGE */); BM_ITER(e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) { e->head.flags[0].f = 0; - if (BM_TestHFlag(e, BM_ELEM_HIDDEN)) { + if (BM_elem_flag_test(e, BM_ELEM_HIDDEN)) { BLI_smallhash_insert(&visithash, (uintptr_t)e, NULL); } - BM_SetIndex(e, totedge); /* set_inline */ + BM_elem_index_set(e, totedge); /* set_inline */ totedge++; } em->bm->elem_index_dirty &= ~BM_EDGE; @@ -1240,8 +1240,8 @@ static int edgetag_shortest_path(Scene *scene, BMEditMesh *em, BMEdge *source, B /* count edges, compute adjacent edges offsets and fill adjacent */ BM_ITER(e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) { - nedges[BM_GetIndex(e->v1) + 1]++; - nedges[BM_GetIndex(e->v2) + 1]++; + nedges[BM_elem_index_get(e->v1) + 1]++; + nedges[BM_elem_index_get(e->v2) + 1]++; } for (i = 1; i < totvert; i++) { @@ -1253,8 +1253,8 @@ static int edgetag_shortest_path(Scene *scene, BMEditMesh *em, BMEdge *source, B i = 0; BM_ITER(e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) { - edges[nedges[BM_GetIndex(e->v1) + 1]++] = i; - edges[nedges[BM_GetIndex(e->v2) + 1]++] = i; + edges[nedges[BM_elem_index_get(e->v1) + 1]++] = i; + edges[nedges[BM_elem_index_get(e->v2) + 1]++] = i; cost[i] = 1e20f; prevedge[i] = -1; @@ -1286,10 +1286,10 @@ static int edgetag_shortest_path(Scene *scene, BMEditMesh *em, BMEdge *source, B /* regular dijkstra shortest path, but over edges instead of vertices */ heap = BLI_heap_new(); - BLI_heap_insert(heap, 0.0f, SET_INT_IN_POINTER(BM_GetIndex(source))); - cost[BM_GetIndex(source)] = 0.0f; + BLI_heap_insert(heap, 0.0f, SET_INT_IN_POINTER(BM_elem_index_get(source))); + cost[BM_elem_index_get(source)] = 0.0f; EDBM_init_index_arrays(em, 1, 1, 0); - targetnum = BM_GetIndex(target); + targetnum = BM_elem_index_get(target); while (!BLI_heap_empty(heap)) { mednum = GET_INT_FROM_POINTER(BLI_heap_popmin(heap)); @@ -1303,8 +1303,8 @@ static int edgetag_shortest_path(Scene *scene, BMEditMesh *em, BMEdge *source, B BLI_smallhash_insert(&visithash, (uintptr_t)e, NULL); - edgetag_add_adjacent(em, &visithash, heap, mednum, BM_GetIndex(e->v1), nedges, edges, prevedge, cost); - edgetag_add_adjacent(em, &visithash, heap, mednum, BM_GetIndex(e->v2), nedges, edges, prevedge, cost); + edgetag_add_adjacent(em, &visithash, heap, mednum, BM_elem_index_get(e->v1), nedges, edges, prevedge, cost); + edgetag_add_adjacent(em, &visithash, heap, mednum, BM_elem_index_get(e->v2), nedges, edges, prevedge, cost); } if (mednum == targetnum) { @@ -1320,7 +1320,7 @@ static int edgetag_shortest_path(Scene *scene, BMEditMesh *em, BMEdge *source, B break; } mednum = prevedge[mednum]; - } while (mednum != BM_GetIndex(source)); + } while (mednum != BM_elem_index_get(source)); /* Follow path back and source and add or remove tags */ mednum = targetnum; @@ -1465,35 +1465,35 @@ int mouse_mesh(bContext *C, const int mval[2], short extend) if (efa) { /* set the last selected face */ - BM_set_actFace(vc.em->bm, efa); + BM_active_face_set(vc.em->bm, efa); - if (!BM_TestHFlag(efa, BM_ELEM_SELECT)) { + if (!BM_elem_flag_test(efa, BM_ELEM_SELECT)) { EDBM_store_selection(vc.em, efa); - BM_Select(vc.em->bm, efa, TRUE); + BM_elem_select_set(vc.em->bm, efa, TRUE); } else if (extend) { EDBM_remove_selection(vc.em, efa); - BM_Select(vc.em->bm, efa, FALSE); + BM_elem_select_set(vc.em->bm, efa, FALSE); } } else if (eed) { - if (!BM_TestHFlag(eed, BM_ELEM_SELECT)) { + if (!BM_elem_flag_test(eed, BM_ELEM_SELECT)) { EDBM_store_selection(vc.em, eed); - BM_Select(vc.em->bm, eed, TRUE); + BM_elem_select_set(vc.em->bm, eed, TRUE); } else if (extend) { EDBM_remove_selection(vc.em, eed); - BM_Select(vc.em->bm, eed, FALSE); + BM_elem_select_set(vc.em->bm, eed, FALSE); } } else if (eve) { - if (!BM_TestHFlag(eve, BM_ELEM_SELECT)) { + if (!BM_elem_flag_test(eve, BM_ELEM_SELECT)) { EDBM_store_selection(vc.em, eve); - BM_Select(vc.em->bm, eve, TRUE); + BM_elem_select_set(vc.em->bm, eve, TRUE); } else if (extend) { EDBM_remove_selection(vc.em, eve); - BM_Select(vc.em->bm, eve, FALSE); + BM_elem_select_set(vc.em->bm, eve, FALSE); } } @@ -1562,13 +1562,13 @@ void EDBM_selectmode_set(BMEditMesh *em) } else if (em->selectmode & SCE_SELECT_EDGE) { /* deselect vertices, and select again based on edge select */ - eve = BMIter_New(&iter, em->bm, BM_VERTS_OF_MESH, NULL); - for ( ; eve; eve = BMIter_Step(&iter)) BM_Select(em->bm, eve, FALSE); + eve = BM_iter_new(&iter, em->bm, BM_VERTS_OF_MESH, NULL); + for ( ; eve; eve = BM_iter_step(&iter)) BM_elem_select_set(em->bm, eve, FALSE); - eed = BMIter_New(&iter, em->bm, BM_EDGES_OF_MESH, NULL); - for ( ; eed; eed = BMIter_Step(&iter)) { - if (BM_TestHFlag(eed, BM_ELEM_SELECT)) { - BM_Select(em->bm, eed, TRUE); + eed = BM_iter_new(&iter, em->bm, BM_EDGES_OF_MESH, NULL); + for ( ; eed; eed = BM_iter_step(&iter)) { + if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) { + BM_elem_select_set(em->bm, eed, TRUE); } } @@ -1577,13 +1577,13 @@ void EDBM_selectmode_set(BMEditMesh *em) } else if (em->selectmode & SCE_SELECT_FACE) { /* deselect eges, and select again based on face select */ - eed = BMIter_New(&iter, em->bm, BM_EDGES_OF_MESH, NULL); - for ( ; eed; eed = BMIter_Step(&iter)) BM_Select(em->bm, eed, FALSE); + eed = BM_iter_new(&iter, em->bm, BM_EDGES_OF_MESH, NULL); + for ( ; eed; eed = BM_iter_step(&iter)) BM_elem_select_set(em->bm, eed, FALSE); - efa = BMIter_New(&iter, em->bm, BM_FACES_OF_MESH, NULL); - for ( ; efa; efa = BMIter_Step(&iter)) { - if (BM_TestHFlag(efa, BM_ELEM_SELECT)) { - BM_Select(em->bm, efa, TRUE); + efa = BM_iter_new(&iter, em->bm, BM_FACES_OF_MESH, NULL); + for ( ; efa; efa = BM_iter_step(&iter)) { + if (BM_elem_flag_test(efa, BM_ELEM_SELECT)) { + BM_elem_select_set(em->bm, efa, TRUE); } } } @@ -1599,12 +1599,12 @@ void EDBM_convertsel(BMEditMesh *em, short oldmode, short selectmode) if (oldmode == SCE_SELECT_VERTEX) { if (selectmode == SCE_SELECT_EDGE) { /* select all edges associated with every selected vertex */ - eed = BMIter_New(&iter, em->bm, BM_EDGES_OF_MESH, NULL); - for ( ; eed; eed = BMIter_Step(&iter)) { - if ( (BM_TestHFlag(eed->v1, BM_ELEM_SELECT) || - BM_TestHFlag(eed->v2, BM_ELEM_SELECT))) + eed = BM_iter_new(&iter, em->bm, BM_EDGES_OF_MESH, NULL); + for ( ; eed; eed = BM_iter_step(&iter)) { + if ( (BM_elem_flag_test(eed->v1, BM_ELEM_SELECT) || + BM_elem_flag_test(eed->v2, BM_ELEM_SELECT))) { - BM_Select(em->bm, eed, TRUE); + BM_elem_select_set(em->bm, eed, TRUE); } } } @@ -1613,12 +1613,12 @@ void EDBM_convertsel(BMEditMesh *em, short oldmode, short selectmode) BMLoop *l; /* select all faces associated with every selected vertex */ - efa = BMIter_New(&iter, em->bm, BM_FACES_OF_MESH, NULL); - for ( ; efa; efa = BMIter_Step(&iter)) { - l = BMIter_New(&liter, em->bm, BM_LOOPS_OF_FACE, efa); - for (; l; l = BMIter_Step(&liter)) { - if (BM_TestHFlag(l->v, BM_ELEM_SELECT)) { - BM_Select(em->bm, efa, TRUE); + efa = BM_iter_new(&iter, em->bm, BM_FACES_OF_MESH, NULL); + for ( ; efa; efa = BM_iter_step(&iter)) { + l = BM_iter_new(&liter, em->bm, BM_LOOPS_OF_FACE, efa); + for (; l; l = BM_iter_step(&liter)) { + if (BM_elem_flag_test(l->v, BM_ELEM_SELECT)) { + BM_elem_select_set(em->bm, efa, TRUE); break; } } @@ -1632,12 +1632,12 @@ void EDBM_convertsel(BMEditMesh *em, short oldmode, short selectmode) BMLoop *l; /* select all faces associated with every selected vertex */ - efa = BMIter_New(&iter, em->bm, BM_FACES_OF_MESH, NULL); - for ( ; efa; efa = BMIter_Step(&iter)) { - l = BMIter_New(&liter, em->bm, BM_LOOPS_OF_FACE, efa); - for (; l; l = BMIter_Step(&liter)) { - if (BM_TestHFlag(l->v, BM_ELEM_SELECT)) { - BM_Select(em->bm, efa, TRUE); + efa = BM_iter_new(&iter, em->bm, BM_FACES_OF_MESH, NULL); + for ( ; efa; efa = BM_iter_step(&iter)) { + l = BM_iter_new(&liter, em->bm, BM_LOOPS_OF_FACE, efa); + for (; l; l = BM_iter_step(&liter)) { + if (BM_elem_flag_test(l->v, BM_ELEM_SELECT)) { + BM_elem_select_set(em->bm, efa, TRUE); break; } } @@ -1653,10 +1653,10 @@ void EDBM_deselect_by_material(struct BMEditMesh *em, const short index, const s BMFace *efa; BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (BM_TestHFlag(efa, BM_ELEM_HIDDEN)) + if (BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) continue; if (efa->mat_nr == index) { - BM_Select(em->bm, efa, select); + BM_elem_select_set(em->bm, efa, select); } } } @@ -1671,23 +1671,23 @@ void EDBM_select_swap(BMEditMesh *em) /* exported for UV */ if (em->bm->selectmode & SCE_SELECT_VERTEX) { BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (BM_TestHFlag(eve, BM_ELEM_HIDDEN)) + if (BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) continue; - BM_Select(em->bm, eve, !BM_TestHFlag(eve, BM_ELEM_SELECT)); + 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) { - if (BM_TestHFlag(eed, BM_ELEM_HIDDEN)) + if (BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) continue; - BM_Select(em->bm, eed, !BM_TestHFlag(eed, BM_ELEM_SELECT)); + 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) { - if (BM_TestHFlag(efa, BM_ELEM_HIDDEN)) + if (BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) continue; - BM_Select(em->bm, efa, !BM_TestHFlag(efa, BM_ELEM_SELECT)); + BM_elem_select_set(em->bm, efa, !BM_elem_flag_test(efa, BM_ELEM_SELECT)); } } @@ -1755,21 +1755,21 @@ static int select_linked_pick_invoke(bContext *C, wmOperator *op, wmEvent *event if (limit) { BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) { - if (!BM_TestHFlag(e, BM_ELEM_SEAM)) BMO_SetFlag(bm, e, BM_ELEM_SELECT); - else BMO_ClearFlag(bm, e, BM_ELEM_SELECT); /* is this needed ? */ + if (!BM_elem_flag_test(e, BM_ELEM_SEAM)) BMO_elem_flag_set(bm, e, BM_ELEM_SELECT); + else BMO_elem_flag_clear(bm, e, BM_ELEM_SELECT); /* is this needed ? */ } } /* walk */ - BMW_Init(&walker, bm, BMW_ISLAND, + BMW_init(&walker, bm, BMW_ISLAND, BMW_MASK_NOP, limit ? BM_ELEM_SELECT : BMW_MASK_NOP, BMW_MASK_NOP, BMW_MASK_NOP, BMW_NIL_LAY); - e = BMW_Begin(&walker, efa); - for (; efa; efa = BMW_Step(&walker)) { - BM_Select(bm, efa, sel); + e = BMW_begin(&walker, efa); + for (; efa; efa = BMW_step(&walker)) { + BM_elem_select_set(bm, efa, sel); } - BMW_End(&walker); + BMW_end(&walker); } else { if (efa) { @@ -1782,15 +1782,15 @@ static int select_linked_pick_invoke(bContext *C, wmOperator *op, wmEvent *event eed = eve->e; } - BMW_Init(&walker, bm, BMW_SHELL, + BMW_init(&walker, bm, BMW_SHELL, BMW_MASK_NOP, BMW_MASK_NOP, BMW_MASK_NOP, BMW_MASK_NOP, BMW_NIL_LAY); - e = BMW_Begin(&walker, eed->v1); - for ( ; e; e = BMW_Step(&walker)) { - BM_Select(bm, e, sel); + e = BMW_begin(&walker, eed->v1); + for ( ; e; e = BMW_step(&walker)) { + BM_elem_select_set(bm, e, sel); } - BMW_End(&walker); + BMW_end(&walker); } WM_event_add_notifier(C, NC_GEOM|ND_SELECT, obedit); @@ -1836,58 +1836,58 @@ static int select_linked_exec(bContext *C, wmOperator *op) BMFace *efa; BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (BM_TestHFlag(efa, BM_ELEM_SELECT) && !BM_TestHFlag(efa, BM_ELEM_HIDDEN)) { - BM_SetHFlag(efa, BM_ELEM_TAG); + if (BM_elem_flag_test(efa, BM_ELEM_SELECT) && !BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) { + BM_elem_flag_set(efa, BM_ELEM_TAG); } else { - BM_ClearHFlag(efa, BM_ELEM_TAG); + BM_elem_flag_clear(efa, BM_ELEM_TAG); } } if (limit) { BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) { - if (!BM_TestHFlag(e, BM_ELEM_SEAM)) BMO_SetFlag(bm, e, BM_ELEM_SELECT); - else BMO_ClearFlag(bm, e, BM_ELEM_SELECT); /* is this needed ? */ + if (!BM_elem_flag_test(e, BM_ELEM_SEAM)) BMO_elem_flag_set(bm, e, BM_ELEM_SELECT); + else BMO_elem_flag_clear(bm, e, BM_ELEM_SELECT); /* is this needed ? */ } } - BMW_Init(&walker, bm, BMW_ISLAND, + BMW_init(&walker, bm, BMW_ISLAND, BMW_MASK_NOP, limit ? BM_ELEM_SELECT : BMW_MASK_NOP, BMW_MASK_NOP, BMW_MASK_NOP, BMW_NIL_LAY); BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (BM_TestHFlag(efa, BM_ELEM_TAG)) { - e = BMW_Begin(&walker, efa); - for (; efa; efa = BMW_Step(&walker)) { - BM_Select(bm, efa, TRUE); + if (BM_elem_flag_test(efa, BM_ELEM_TAG)) { + e = BMW_begin(&walker, efa); + for (; efa; efa = BMW_step(&walker)) { + BM_elem_select_set(bm, efa, TRUE); } } } - BMW_End(&walker); + BMW_end(&walker); } else { BM_ITER(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (BM_TestHFlag(v, BM_ELEM_SELECT) && !BM_TestHFlag(v, BM_ELEM_HIDDEN)) { - BM_SetHFlag(v, BM_ELEM_TAG); + if (BM_elem_flag_test(v, BM_ELEM_SELECT) && !BM_elem_flag_test(v, BM_ELEM_HIDDEN)) { + BM_elem_flag_set(v, BM_ELEM_TAG); } else { - BM_ClearHFlag(v, BM_ELEM_TAG); + BM_elem_flag_clear(v, BM_ELEM_TAG); } } - BMW_Init(&walker, em->bm, BMW_SHELL, + BMW_init(&walker, em->bm, BMW_SHELL, BMW_MASK_NOP, BMW_MASK_NOP, BMW_MASK_NOP, BMW_MASK_NOP, BMW_NIL_LAY); BM_ITER(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (BM_TestHFlag(v, BM_ELEM_TAG)) { - e = BMW_Begin(&walker, v); - for (; e; e = BMW_Step(&walker)) { - BM_Select(em->bm, e->v1, TRUE); - BM_Select(em->bm, e->v2, TRUE); + if (BM_elem_flag_test(v, BM_ELEM_TAG)) { + e = BMW_begin(&walker, v); + for (; e; e = BMW_step(&walker)) { + BM_elem_select_set(em->bm, e->v1, TRUE); + BM_elem_select_set(em->bm, e->v2, TRUE); } } } - BMW_End(&walker); + BMW_end(&walker); } EDBM_selectmode_flush_ex(em, SCE_SELECT_VERTEX); @@ -2011,24 +2011,24 @@ static void walker_deselect_nth(BMEditMesh *em, int nth, int offset, BMHeader *h * so transfer BM_ELEM_SELECT from HFlags onto a BMO flag layer. */ BMO_push(bm, NULL); BM_ITER(h, &iter, bm, itertype, NULL) { - if (BM_TestHFlag(h, BM_ELEM_SELECT)) { - BMO_SetFlag(bm, h, BM_ELEM_SELECT); + if (BM_elem_flag_test(h, BM_ELEM_SELECT)) { + BMO_elem_flag_set(bm, h, BM_ELEM_SELECT); } } /* Walk over selected elements starting at active */ - BMW_Init(&walker, bm, walktype, + BMW_init(&walker, bm, walktype, mask_vert, mask_edge, mask_loop, mask_face, BMW_NIL_LAY); BLI_assert(walker.order == BMW_BREADTH_FIRST); - for (h = BMW_Begin(&walker, h_act); h != NULL; h = BMW_Step(&walker)) { + for (h = BMW_begin(&walker, h_act); h != NULL; h = BMW_step(&walker)) { /* Deselect elements that aren't at "nth" depth from active */ - if ((offset + BMW_CurrentDepth(&walker)) % nth) { - BM_Select(bm, h, FALSE); + if ((offset + BMW_current_depth(&walker)) % nth) { + BM_elem_select_set(bm, h, FALSE); } } - BMW_End(&walker); + BMW_end(&walker); BMO_pop(bm); @@ -2067,7 +2067,7 @@ static void deselect_nth_active(BMEditMesh *em, BMVert **v_p, BMEdge **e_p, BMFa if (em->selectmode & SCE_SELECT_VERTEX) { BM_ITER(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (BM_TestHFlag(v, BM_ELEM_SELECT)) { + if (BM_elem_flag_test(v, BM_ELEM_SELECT)) { *v_p = v; return; } @@ -2075,14 +2075,14 @@ static void deselect_nth_active(BMEditMesh *em, BMVert **v_p, BMEdge **e_p, BMFa } else if (em->selectmode & SCE_SELECT_EDGE) { BM_ITER(e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) { - if (BM_TestHFlag(e, BM_ELEM_SELECT)) { + if (BM_elem_flag_test(e, BM_ELEM_SELECT)) { *e_p = e; return; } } } else if (em->selectmode & SCE_SELECT_FACE) { - f = BM_get_actFace(em->bm, TRUE); + f = BM_active_face_get(em->bm, TRUE); if (f) { *f_p = f; return; @@ -2188,7 +2188,7 @@ static int select_sharp_edges_exec(bContext *C, wmOperator *op) sharp = DEG2RADF(sharp); BM_ITER(e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) { - if (BM_TestHFlag(e, BM_ELEM_HIDDEN) || !e->l) + if (BM_elem_flag_test(e, BM_ELEM_HIDDEN) || !e->l) continue; l1 = e->l; @@ -2201,7 +2201,7 @@ static int select_sharp_edges_exec(bContext *C, wmOperator *op) angle = angle_normalized_v3v3(l1->f->no, l2->f->no); if (fabsf(angle) > sharp) { - BM_Select(em->bm, e, TRUE); + BM_elem_select_set(em->bm, e, TRUE); } } @@ -2243,11 +2243,11 @@ static int 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_ClearHFlag(f, BM_ELEM_TAG); + BM_elem_flag_clear(f, BM_ELEM_TAG); } BM_ITER(f, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (BM_TestHFlag(f, BM_ELEM_HIDDEN) || !BM_TestHFlag(f, BM_ELEM_SELECT) || BM_TestHFlag(f, BM_ELEM_TAG)) + 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; BLI_array_empty(stack); @@ -2260,15 +2260,15 @@ static int select_linked_flat_faces_exec(bContext *C, wmOperator *op) f = stack[i - 1]; i--; - BM_Select(em->bm, f, TRUE); + BM_elem_select_set(em->bm, f, TRUE); - BM_SetHFlag(f, BM_ELEM_TAG); + BM_elem_flag_set(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) { float angle; - if (BM_TestHFlag(l2->f, BM_ELEM_TAG) || BM_TestHFlag(l2->f, BM_ELEM_HIDDEN)) + if (BM_elem_flag_test(l2->f, BM_ELEM_TAG) || BM_elem_flag_test(l2->f, BM_ELEM_HIDDEN)) continue; /* edge has exactly two neighboring faces, check angle */ @@ -2328,14 +2328,14 @@ static int select_non_manifold_exec(bContext *C, wmOperator *op) } BM_ITER(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (!BM_TestHFlag(em->bm, BM_ELEM_HIDDEN) && BM_Nonmanifold_Vert(em->bm, v)) { - BM_Select(em->bm, v, TRUE); + if (!BM_elem_flag_test(em->bm, BM_ELEM_HIDDEN) && BM_vert_is_nonmanifold(em->bm, v)) { + BM_elem_select_set(em->bm, v, TRUE); } } BM_ITER(e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) { - if (!BM_TestHFlag(em->bm, BM_ELEM_HIDDEN) && BM_Edge_FaceCount(e) != 2) { - BM_Select(em->bm, e, TRUE); + if (!BM_elem_flag_test(em->bm, BM_ELEM_HIDDEN) && BM_edge_face_count(e) != 2) { + BM_elem_select_set(em->bm, e, TRUE); } } @@ -2376,24 +2376,24 @@ static int mesh_select_random_exec(bContext *C, wmOperator *op) if (em->selectmode & SCE_SELECT_VERTEX) { BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (!BM_TestHFlag(eve, BM_ELEM_HIDDEN) && BLI_frand() < randfac) { - BM_Select(em->bm, eve, TRUE); + if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN) && BLI_frand() < randfac) { + BM_elem_select_set(em->bm, eve, TRUE); } } EDBM_selectmode_flush(em); } else if (em->selectmode & SCE_SELECT_EDGE) { BM_ITER(eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) { - if (!BM_TestHFlag(eed, BM_ELEM_HIDDEN) && BLI_frand() < randfac) { - BM_Select(em->bm, eed, TRUE); + if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN) && BLI_frand() < randfac) { + BM_elem_select_set(em->bm, eed, TRUE); } } EDBM_selectmode_flush(em); } else { BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (!BM_TestHFlag(efa, BM_ELEM_HIDDEN) && BLI_frand() < randfac) { - BM_Select(em->bm, efa, TRUE); + if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN) && BLI_frand() < randfac) { + BM_elem_select_set(em->bm, efa, TRUE); } } EDBM_selectmode_flush(em); @@ -2434,7 +2434,7 @@ static int select_next_loop(bContext *C, wmOperator *UNUSED(op)) BMIter iter; BM_ITER(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - BM_ClearHFlag(v, BM_ELEM_TAG); + BM_elem_flag_clear(v, BM_ELEM_TAG); } BM_ITER(f, &iter, em->bm, BM_FACES_OF_MESH, NULL) { @@ -2442,16 +2442,16 @@ static int select_next_loop(bContext *C, wmOperator *UNUSED(op)) BMIter liter; BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, f) { - if (BM_TestHFlag(l->v, BM_ELEM_SELECT) && !BM_TestHFlag(l->v, BM_ELEM_HIDDEN)) { - BM_SetHFlag(l->next->v, BM_ELEM_TAG); - BM_Select(em->bm, l->v, FALSE); + if (BM_elem_flag_test(l->v, BM_ELEM_SELECT) && !BM_elem_flag_test(l->v, BM_ELEM_HIDDEN)) { + BM_elem_flag_set(l->next->v, BM_ELEM_TAG); + BM_elem_select_set(em->bm, l->v, FALSE); } } } BM_ITER(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (BM_TestHFlag(v, BM_ELEM_TAG)) { - BM_Select(em->bm, v, TRUE); + if (BM_elem_flag_test(v, BM_ELEM_TAG)) { + BM_elem_select_set(em->bm, v, TRUE); } } @@ -2487,7 +2487,7 @@ static int region_to_loop(bContext *C, wmOperator *UNUSED(op)) em_setup_viewcontext(C, &vc); BM_ITER(e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) { - BM_ClearHFlag(e, BM_ELEM_TAG); + BM_elem_flag_clear(e, BM_ELEM_TAG); } BM_ITER(f, &iter, em->bm, BM_FACES_OF_MESH, NULL) { @@ -2499,19 +2499,19 @@ static int region_to_loop(bContext *C, wmOperator *UNUSED(op)) BM_ITER(l2, &liter2, em->bm, BM_LOOPS_OF_EDGE, l1->e) { tot++; - totsel += BM_TestHFlag(l2->f, BM_ELEM_SELECT) != 0; + totsel += BM_elem_flag_test(l2->f, BM_ELEM_SELECT) != 0; } if ((tot != totsel && totsel > 0) || (totsel == 1 && tot == 1)) - BM_SetHFlag(l1->e, BM_ELEM_TAG); + BM_elem_flag_set(l1->e, BM_ELEM_TAG); } } EDBM_clear_flag_all(em, BM_ELEM_SELECT); BM_ITER(e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) { - if (BM_TestHFlag(e, BM_ELEM_TAG) && !BM_TestHFlag(e, BM_ELEM_HIDDEN)) - BM_Select_Edge(em->bm, e, TRUE); + if (BM_elem_flag_test(e, BM_ELEM_TAG) && !BM_elem_flag_test(e, BM_ELEM_HIDDEN)) + BM_edge_select(em->bm, e, TRUE); } /* If in face-only select mode, switch to edge select mode so that @@ -2560,7 +2560,7 @@ static int loop_find_region(BMEditMesh *em, BMLoop *l, int flag, BLI_array_append(region, f); BM_ITER(l1, &liter1, em->bm, BM_LOOPS_OF_FACE, f) { - if (BM_TestHFlag(l1->e, flag)) + if (BM_elem_flag_test(l1->e, flag)) continue; BM_ITER(l2, &liter2, em->bm, BM_LOOPS_OF_EDGE, l1->e) { @@ -2585,8 +2585,8 @@ static int verg_radial(const void *va, const void *vb) BMEdge *e2 = *((void **)vb); int a, b; - a = BM_Edge_FaceCount(e1); - b = BM_Edge_FaceCount(e2); + a = BM_edge_face_count(e1); + b = BM_edge_face_count(e2); if (a > b) return -1; if (a == b) return 0; @@ -2607,16 +2607,16 @@ 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_ClearHFlag(f, BM_ELEM_TAG); + BM_elem_flag_clear(f, BM_ELEM_TAG); } BM_ITER(e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) { - if (BM_TestHFlag(e, BM_ELEM_SELECT)) { + if (BM_elem_flag_test(e, BM_ELEM_SELECT)) { BLI_array_append(edges, e); - BM_SetHFlag(e, BM_ELEM_TAG); + BM_elem_flag_set(e, BM_ELEM_TAG); } else { - BM_ClearHFlag(e, BM_ELEM_TAG); + BM_elem_flag_clear(e, BM_ELEM_TAG); } } @@ -2631,7 +2631,7 @@ static int loop_find_regions(BMEditMesh *em, int selbigger) e = edges[i]; - if (!BM_TestHFlag(e, BM_ELEM_TAG)) + if (!BM_elem_flag_test(e, BM_ELEM_TAG)) continue; BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_EDGE, e) { @@ -2660,9 +2660,9 @@ static int loop_find_regions(BMEditMesh *em, int selbigger) int j; for (j = 0; j < tot; j++) { - BM_SetHFlag(region[j], BM_ELEM_TAG); + BM_elem_flag_set(region[j], BM_ELEM_TAG); BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, region[j]) { - BM_ClearHFlag(l->e, BM_ELEM_TAG); + BM_elem_flag_clear(l->e, BM_ELEM_TAG); } } @@ -2698,8 +2698,8 @@ static int loop_to_region(bContext *C, wmOperator *op) EDBM_clear_flag_all(em, BM_ELEM_SELECT); BM_ITER(f, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (BM_TestHFlag(f, BM_ELEM_TAG) && !BM_TestHFlag(f, BM_ELEM_HIDDEN)) { - BM_Select_Face(em->bm, f, TRUE); + if (BM_elem_flag_test(f, BM_ELEM_TAG) && !BM_elem_flag_test(f, BM_ELEM_HIDDEN)) { + BM_face_select(em->bm, f, TRUE); } } diff --git a/source/blender/editors/mesh/bmesh_selecthistory.c b/source/blender/editors/mesh/bmesh_selecthistory.c index 5a1fdeebdbc..a242356f1ab 100644 --- a/source/blender/editors/mesh/bmesh_selecthistory.c +++ b/source/blender/editors/mesh/bmesh_selecthistory.c @@ -55,15 +55,15 @@ void EDBM_editselection_plane(BMEditMesh *em, float *plane, BMEditSelection *ese void EDBM_remove_selection(BMEditMesh *em, void *data) { - BM_remove_selection(em->bm, data); + BM_select_history_remove(em->bm, data); } void EDBM_store_selection(BMEditMesh *em, void *data) { - BM_store_selection(em->bm, data); + BM_select_history_store(em->bm, data); } void EDBM_validate_selections(BMEditMesh *em) { - BM_validate_selections(em->bm); + BM_select_history_validate(em->bm); } diff --git a/source/blender/editors/mesh/bmesh_tools.c b/source/blender/editors/mesh/bmesh_tools.c index 2d274526110..c7a3fc14dbd 100644 --- a/source/blender/editors/mesh/bmesh_tools.c +++ b/source/blender/editors/mesh/bmesh_tools.c @@ -150,7 +150,7 @@ void EMBM_project_snap_verts(bContext *C, ARegion *ar, Object *obedit, BMEditMes BMVert *eve; BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (BM_TestHFlag(eve, BM_ELEM_SELECT)) { + if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) { float mval[2], vec[3], no_dummy[3]; int dist_dummy; mul_v3_m4v3(vec, obedit->obmat, eve->co); @@ -178,10 +178,10 @@ static short EDBM_Extrude_face_indiv(BMEditMesh *em, wmOperator *op, const char /* deselect original verts */ EDBM_clear_flag_all(em, BM_ELEM_SELECT); - BMO_Exec_Op(em->bm, &bmop); + BMO_op_exec(em->bm, &bmop); BMO_ITER(f, &siter, em->bm, &bmop, "faceout", BM_FACE) { - BM_Select(em->bm, f, TRUE); + 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) { @@ -206,8 +206,8 @@ static short EDBM_Extrude_edges_indiv(BMEditMesh *em, wmOperator *op, const char /* deselect original verts */ EDBM_clear_flag_all(em, BM_ELEM_SELECT); - BMO_Exec_Op(em->bm, &bmop); - BMO_HeaderFlag_Buffer(em->bm, &bmop, "geomout", BM_ELEM_SELECT, BM_VERT|BM_EDGE); + BMO_op_exec(em->bm, &bmop); + BMO_slot_buffer_hflag(em->bm, &bmop, "geomout", BM_ELEM_SELECT, BM_VERT|BM_EDGE); if (!EDBM_FinishOp(em, &bmop, op, TRUE)) { return 0; @@ -224,10 +224,10 @@ static short EDBM_Extrude_verts_indiv(BMEditMesh *em, wmOperator *op, const char EDBM_InitOpf(em, &bmop, op, "extrude_vert_indiv verts=%hv", hflag); /* deselect original verts */ - BMO_UnHeaderFlag_Buffer(em->bm, &bmop, "verts", BM_ELEM_SELECT, BM_VERT); + BMO_slot_buffer_hflag_clear(em->bm, &bmop, "verts", BM_ELEM_SELECT, BM_VERT); - BMO_Exec_Op(em->bm, &bmop); - BMO_HeaderFlag_Buffer(em->bm, &bmop, "vertout", BM_ELEM_SELECT, BM_VERT); + BMO_op_exec(em->bm, &bmop); + BMO_slot_buffer_hflag(em->bm, &bmop, "vertout", BM_ELEM_SELECT, BM_VERT); if (!EDBM_FinishOp(em, &bmop, op, TRUE)) { return 0; @@ -247,8 +247,8 @@ static short EDBM_Extrude_edge(Object *obedit, BMEditMesh *em, const char hflag, ModifierData *md; BMHeader *el; - BMO_Init_Op(bm, &extop, "extrudefaceregion"); - BMO_HeaderFlag_To_Slot(bm, &extop, "edgefacein", + BMO_op_init(bm, &extop, "extrudefaceregion"); + BMO_slot_from_hflag(bm, &extop, "edgefacein", hflag, BM_VERT|BM_EDGE|BM_FACE); /* If a mirror modifier with clipping is on, we need to adjust some @@ -267,11 +267,11 @@ static short EDBM_Extrude_edge(Object *obedit, BMEditMesh *em, const char hflag, mult_m4_m4m4(mtx, imtx, obedit->obmat); } - for (edge = BMIter_New(&iter, bm, BM_EDGES_OF_MESH, NULL); + for (edge = BM_iter_new(&iter, bm, BM_EDGES_OF_MESH, NULL); edge; - edge = BMIter_Step(&iter)) + edge = BM_iter_step(&iter)) { - if (BM_TestHFlag(edge, hflag)) { + if (BM_elem_flag_test(edge, hflag)) { float co1[3], co2[3]; copy_v3_v3(co1, edge->v1->co); @@ -286,21 +286,21 @@ static short EDBM_Extrude_edge(Object *obedit, BMEditMesh *em, const char hflag, if ( (fabs(co1[0]) < mmd->tolerance) && (fabs(co2[0]) < mmd->tolerance) ) { - BMO_Insert_MapPointer(bm, &extop, "exclude", edge, NULL); + BMO_slot_map_ptr_insert(bm, &extop, "exclude", edge, NULL); } } if (mmd->flag & MOD_MIR_AXIS_Y) { if ( (fabs(co1[1]) < mmd->tolerance) && (fabs(co2[1]) < mmd->tolerance) ) { - BMO_Insert_MapPointer(bm, &extop, "exclude", edge, NULL); + BMO_slot_map_ptr_insert(bm, &extop, "exclude", edge, NULL); } } if (mmd->flag & MOD_MIR_AXIS_Z) { if ( (fabs(co1[2]) < mmd->tolerance) && (fabs(co2[2]) < mmd->tolerance) ) { - BMO_Insert_MapPointer(bm, &extop, "exclude", edge, NULL); + BMO_slot_map_ptr_insert(bm, &extop, "exclude", edge, NULL); } } } @@ -311,12 +311,12 @@ static short EDBM_Extrude_edge(Object *obedit, BMEditMesh *em, const char hflag, EDBM_clear_flag_all(em, BM_ELEM_SELECT); - BMO_Exec_Op(bm, &extop); + BMO_op_exec(bm, &extop); nor[0] = nor[1] = nor[2] = 0.0f; BMO_ITER(el, &siter, bm, &extop, "geomout", BM_ALL) { - BM_Select(bm, el, TRUE); + BM_elem_select_set(bm, el, TRUE); if (el->htype == BM_FACE) { f = (BMFace *)el; @@ -326,7 +326,7 @@ static short EDBM_Extrude_edge(Object *obedit, BMEditMesh *em, const char hflag, normalize_v3(nor); - BMO_Finish_Op(bm, &extop); + BMO_op_finish(bm, &extop); if (nor[0] == 0.0f && nor[1] == 0.0f && nor[2] == 0.0f) return 'g'; // grab return 'n'; // normal constraint @@ -338,24 +338,24 @@ static short EDBM_Extrude_vert(Object *obedit, BMEditMesh *em, const char hflag, BMEdge *eed; /* ensure vert flags are consistent for edge selections */ - eed = BMIter_New(&iter, em->bm, BM_EDGES_OF_MESH, NULL); - for ( ; eed; eed = BMIter_Step(&iter)) { - if (BM_TestHFlag(eed, hflag)) { + eed = BM_iter_new(&iter, em->bm, BM_EDGES_OF_MESH, NULL); + for ( ; eed; eed = BM_iter_step(&iter)) { + if (BM_elem_flag_test(eed, hflag)) { if (hflag & BM_ELEM_SELECT) { - BM_Select(em->bm, eed->v1, TRUE); - BM_Select(em->bm, eed->v2, TRUE); + BM_elem_select_set(em->bm, eed->v1, TRUE); + BM_elem_select_set(em->bm, eed->v2, TRUE); } - BM_SetHFlag(eed->v1, hflag & ~BM_ELEM_SELECT); - BM_SetHFlag(eed->v2, hflag & ~BM_ELEM_SELECT); + BM_elem_flag_set(eed->v1, hflag & ~BM_ELEM_SELECT); + BM_elem_flag_set(eed->v2, hflag & ~BM_ELEM_SELECT); } else { - if (BM_TestHFlag(eed->v1, hflag) && BM_TestHFlag(eed->v2, hflag)) { + if (BM_elem_flag_test(eed->v1, hflag) && BM_elem_flag_test(eed->v2, hflag)) { if (hflag & BM_ELEM_SELECT) { - BM_Select(em->bm, eed, TRUE); + BM_elem_select_set(em->bm, eed, TRUE); } - BM_SetHFlag(eed, hflag & ~BM_ELEM_SELECT); + BM_elem_flag_set(eed, hflag & ~BM_ELEM_SELECT); } } } @@ -386,8 +386,8 @@ static int extrude_repeat_mesh(bContext *C, wmOperator *op) for (a = 0; a < steps; a++) { EDBM_Extrude_edge(obedit, em, BM_ELEM_SELECT, nor); - //BMO_CallOpf(em->bm, "extrudefaceregion edgefacein=%hef", BM_ELEM_SELECT); - BMO_CallOpf(em->bm, "translate vec=%v verts=%hv", (float *)dvec, BM_ELEM_SELECT); + //BMO_op_callf(em->bm, "extrudefaceregion edgefacein=%hef", BM_ELEM_SELECT); + BMO_op_callf(em->bm, "translate vec=%v verts=%hv", (float *)dvec, BM_ELEM_SELECT); //extrudeflag(obedit, em, SELECT, nor); //translateflag(em, SELECT, dvec); } @@ -698,7 +698,7 @@ static int dupli_extrude_cursor(bContext *C, wmOperator *op, wmEvent *event) INIT_MINMAX(min, max); BM_ITER(v1, &iter, vc.em->bm, BM_VERTS_OF_MESH, NULL) { - if (BM_TestHFlag(v1, BM_ELEM_SELECT)) { + if (BM_elem_flag_test(v1, BM_ELEM_SELECT)) { DO_MINMAX(v1->co, min, max); done = 1; } @@ -720,7 +720,7 @@ static int dupli_extrude_cursor(bContext *C, wmOperator *op, wmEvent *event) /* check for edges that are half selected, use for rotation */ done = 0; BM_ITER(eed, &iter, vc.em->bm, BM_EDGES_OF_MESH, NULL) { - if (BM_TestHFlag(eed, BM_ELEM_SELECT)) { + if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) { float co1[3], co2[3]; mul_v3_m4v3(co1, vc.obedit->obmat, eed->v1->co); mul_v3_m4v3(co2, vc.obedit->obmat, eed->v2->co); @@ -824,10 +824,10 @@ static int dupli_extrude_cursor(bContext *C, wmOperator *op, wmEvent *event) mul_m4_v3(vc.obedit->imat, min); // back in object space EDBM_InitOpf(vc.em, &bmop, op, "makevert co=%v", min); - BMO_Exec_Op(vc.em->bm, &bmop); + BMO_op_exec(vc.em->bm, &bmop); BMO_ITER(v1, &oiter, vc.em->bm, &bmop, "newvertout", BM_VERT) { - BM_Select(vc.em->bm, v1, TRUE); + BM_elem_select_set(vc.em->bm, v1, TRUE); } if (!EDBM_FinishOp(vc.em, &bmop, op, TRUE)) { @@ -998,8 +998,8 @@ static int addedgeface_mesh_exec(bContext *C, wmOperator *op) if (!EDBM_InitOpf(em, &bmop, op, "contextual_create geom=%hfev", BM_ELEM_SELECT)) return OPERATOR_CANCELLED; - BMO_Exec_Op(em->bm, &bmop); - BMO_HeaderFlag_Buffer(em->bm, &bmop, "faceout", BM_ELEM_SELECT, BM_FACE); + BMO_op_exec(em->bm, &bmop); + BMO_slot_buffer_hflag(em->bm, &bmop, "faceout", BM_ELEM_SELECT, BM_FACE); if (!EDBM_FinishOp(em, &bmop, op, TRUE)) { return OPERATOR_CANCELLED; @@ -1045,17 +1045,17 @@ static int editbmesh_mark_seam(bContext *C, wmOperator *op) if (clear) { BM_ITER(eed, &iter, bm, BM_EDGES_OF_MESH, NULL) { - if (!BM_TestHFlag(eed, BM_ELEM_SELECT) || BM_TestHFlag(eed, BM_ELEM_HIDDEN)) + if (!BM_elem_flag_test(eed, BM_ELEM_SELECT) || BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) continue; - BM_ClearHFlag(eed, BM_ELEM_SEAM); + BM_elem_flag_clear(eed, BM_ELEM_SEAM); } } else { BM_ITER(eed, &iter, bm, BM_EDGES_OF_MESH, NULL) { - if (!BM_TestHFlag(eed, BM_ELEM_SELECT) || BM_TestHFlag(eed, BM_ELEM_HIDDEN)) + if (!BM_elem_flag_test(eed, BM_ELEM_SELECT) || BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) continue; - BM_SetHFlag(eed, BM_ELEM_SEAM); + BM_elem_flag_set(eed, BM_ELEM_SEAM); } } @@ -1099,18 +1099,18 @@ static int editbmesh_mark_sharp(bContext *C, wmOperator *op) if (!clear) { BM_ITER(eed, &iter, bm, BM_EDGES_OF_MESH, NULL) { - if (!BM_TestHFlag(eed, BM_ELEM_SELECT) || BM_TestHFlag(eed, BM_ELEM_HIDDEN)) + if (!BM_elem_flag_test(eed, BM_ELEM_SELECT) || BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) continue; - BM_SetHFlag(eed, BM_ELEM_SHARP); + BM_elem_flag_set(eed, BM_ELEM_SHARP); } } else { BM_ITER(eed, &iter, bm, BM_EDGES_OF_MESH, NULL) { - if (!BM_TestHFlag(eed, BM_ELEM_SELECT) || BM_TestHFlag(eed, BM_ELEM_HIDDEN)) + if (!BM_elem_flag_test(eed, BM_ELEM_SELECT) || BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) continue; - BM_ClearHFlag(eed, BM_ELEM_SHARP); + BM_elem_flag_clear(eed, BM_ELEM_SHARP); } } @@ -1150,8 +1150,8 @@ static int editbmesh_vert_connect(bContext *C, wmOperator *op) if (!EDBM_InitOpf(em, &bmop, op, "connectverts verts=%hv", BM_ELEM_SELECT)) { return OPERATOR_CANCELLED; } - BMO_Exec_Op(bm, &bmop); - len = BMO_GetSlot(&bmop, "edgeout")->len; + BMO_op_exec(bm, &bmop); + len = BMO_slot_get(&bmop, "edgeout")->len; if (!EDBM_FinishOp(em, &bmop, op, TRUE)) { return OPERATOR_CANCELLED; } @@ -1188,8 +1188,8 @@ static int editbmesh_edge_split(bContext *C, wmOperator *op) BM_ELEM_SELECT, RNA_int_get(op->ptr,"number_cuts"))) { return OPERATOR_CANCELLED; } - BMO_Exec_Op(bm, &bmop); - len = BMO_GetSlot(&bmop, "outsplit")->len; + BMO_op_exec(bm, &bmop); + len = BMO_slot_get(&bmop, "outsplit")->len; if (!EDBM_FinishOp(em, &bmop, op, TRUE)) { return OPERATOR_CANCELLED; } @@ -1226,10 +1226,10 @@ static int mesh_duplicate_exec(bContext *C, wmOperator *op) EDBM_InitOpf(em, &bmop, op, "dupe geom=%hvef", BM_ELEM_SELECT); - BMO_Exec_Op(em->bm, &bmop); + BMO_op_exec(em->bm, &bmop); EDBM_clear_flag_all(em, BM_ELEM_SELECT); - BMO_HeaderFlag_Buffer(em->bm, &bmop, "newout", BM_ELEM_SELECT, BM_ALL); + BMO_slot_buffer_hflag(em->bm, &bmop, "newout", BM_ELEM_SELECT, BM_ALL); if (!EDBM_FinishOp(em, &bmop, op, TRUE)) { return OPERATOR_CANCELLED; @@ -1326,9 +1326,9 @@ static int edge_rotate_selected(bContext *C, wmOperator *op) /* first see if we have two adjacent faces */ BM_ITER(eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) { - if (BM_Edge_FaceCount(eed) == 2) { - if ((BM_TestHFlag(eed->l->f, BM_ELEM_SELECT) && BM_TestHFlag(eed->l->radial_next->f, BM_ELEM_SELECT)) - && !(BM_TestHFlag(eed->l->f, BM_ELEM_HIDDEN) || BM_TestHFlag(eed->l->radial_next->f, BM_ELEM_HIDDEN))) + if (BM_edge_face_count(eed) == 2) { + if ((BM_elem_flag_test(eed->l->f, BM_ELEM_SELECT) && BM_elem_flag_test(eed->l->radial_next->f, BM_ELEM_SELECT)) + && !(BM_elem_flag_test(eed->l->f, BM_ELEM_HIDDEN) || BM_elem_flag_test(eed->l->radial_next->f, BM_ELEM_HIDDEN))) { break; } @@ -1344,7 +1344,7 @@ static int edge_rotate_selected(bContext *C, wmOperator *op) if (!eed) { BM_ITER(eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) { - if (BM_TestHFlag(eed, BM_ELEM_SELECT) && !BM_TestHFlag(eed, BM_ELEM_HIDDEN)) { + if (BM_elem_flag_test(eed, BM_ELEM_SELECT) && !BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) { /* de-select the edge before */ do_deselect = TRUE; break; @@ -1361,10 +1361,10 @@ static int edge_rotate_selected(bContext *C, wmOperator *op) /* avoid adding to the selection if we start off with only a selected edge, * we could also just deselect the single edge easily but use the BMO api * since it seems this is more 'correct' */ - if (do_deselect) BMO_UnHeaderFlag_Buffer(em->bm, &bmop, "edges", BM_ELEM_SELECT, BM_EDGE); + if (do_deselect) BMO_slot_buffer_hflag_clear(em->bm, &bmop, "edges", BM_ELEM_SELECT, BM_EDGE); - BMO_Exec_Op(em->bm, &bmop); - BMO_HeaderFlag_Buffer(em->bm, &bmop, "edgeout", BM_ELEM_SELECT, BM_EDGE); + BMO_op_exec(em->bm, &bmop); + BMO_slot_buffer_hflag(em->bm, &bmop, "edgeout", BM_ELEM_SELECT, BM_EDGE); if (!EDBM_FinishOp(em, &bmop, op, TRUE)) { return OPERATOR_CANCELLED; @@ -1411,8 +1411,8 @@ void EDBM_hide_mesh(BMEditMesh *em, int swap) itermode = BM_FACES_OF_MESH; BM_ITER(h, &iter, em->bm, itermode, NULL) { - if (BM_TestHFlag(h, BM_ELEM_SELECT) ^ swap) - BM_Hide(em->bm, h, TRUE); + if (BM_elem_flag_test(h, BM_ELEM_SELECT) ^ swap) + BM_elem_hide_set(em->bm, h, TRUE); } EDBM_selectmode_flush(em); @@ -1477,11 +1477,11 @@ void EDBM_reveal_mesh(BMEditMesh *em) /* Use index field to remember what was hidden before all is revealed. */ for (i = 0; i < 3; i++) { BM_ITER(ele, &iter, em->bm, iter_types[i], NULL) { - if (BM_TestHFlag(ele, BM_ELEM_HIDDEN)) { - BM_SetHFlag(ele, BM_ELEM_TAG); + if (BM_elem_flag_test(ele, BM_ELEM_HIDDEN)) { + BM_elem_flag_set(ele, BM_ELEM_TAG); } else { - BM_ClearHFlag(ele, BM_ELEM_TAG); + BM_elem_flag_clear(ele, BM_ELEM_TAG); } } } @@ -1496,8 +1496,8 @@ void EDBM_reveal_mesh(BMEditMesh *em) } BM_ITER(ele, &iter, em->bm, iter_types[i], NULL) { - if (BM_TestHFlag(ele, BM_ELEM_TAG)) { - BM_Select(em->bm, ele, TRUE); + if (BM_elem_flag_test(ele, BM_ELEM_TAG)) { + BM_elem_select_set(em->bm, ele, TRUE); } } } @@ -1660,11 +1660,11 @@ static int bm_test_exec(bContext *C, wmOperator *UNUSED(op)) /* hide all back edges */ BM_ITER(e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) { - if (!BM_TestHFlag(e, BM_ELEM_SELECT)) + if (!BM_elem_flag_test(e, BM_ELEM_SELECT)) continue; if (!BMBVH_EdgeVisible(tree, e, ar, v3d, obedit)) - BM_Select(em->bm, e, FALSE); + BM_elem_select_set(em->bm, e, FALSE); } BMBVH_FreeBVH(tree); @@ -1683,14 +1683,14 @@ static int bm_test_exec(bContext *C, wmOperator *UNUSED(op)) } } - BMW_Init(&walker, em->bm, BMW_UVISLAND, BMW_NIL_LAY); + BMW_init(&walker, em->bm, BMW_UVISLAND, BMW_NIL_LAY); BM_ITER(f, &iter, em->bm, BM_FACES_OF_MESH, NULL) { BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, f) { luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV); if (luv->flag & MLOOPUV_VERTSEL) { - l2 = BMW_Begin(&walker, l); - for (; l2; l2 = BMW_Step(&walker)) { + l2 = BMW_begin(&walker, l); + for (; l2; l2 = BMW_step(&walker)) { luv = CustomData_bmesh_get(&em->bm->ldata, l2->head.data, CD_MLOOPUV); luv->flag |= MLOOPUV_VERTSEL; } @@ -1698,7 +1698,7 @@ static int bm_test_exec(bContext *C, wmOperator *UNUSED(op)) } } - BMW_End(&walker); + BMW_end(&walker); #endif DAG_id_tag_update(obedit->data, OB_RECALC_DATA); WM_event_add_notifier(C, NC_GEOM|ND_DATA, obedit->data); @@ -1732,11 +1732,11 @@ 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) { - if (BM_TestHFlag(efa, BM_ELEM_SELECT)) { + if (BM_elem_flag_test(efa, BM_ELEM_SELECT)) { if (smooth) - BM_SetHFlag(efa, BM_ELEM_SMOOTH); + BM_elem_flag_set(efa, BM_ELEM_SMOOTH); else - BM_ClearHFlag(efa, BM_ELEM_SMOOTH); + BM_elem_flag_clear(efa, BM_ELEM_SMOOTH); } } } @@ -1819,7 +1819,7 @@ static int mesh_rotate_uvs(bContext *C, wmOperator *op) EDBM_InitOpf(em, &bmop, op, "meshrotateuvs faces=%hf dir=%d", BM_ELEM_SELECT, dir); /* execute the operator */ - BMO_Exec_Op(em->bm, &bmop); + BMO_op_exec(em->bm, &bmop); /* finish the operator */ if (!EDBM_FinishOp(em, &bmop, op, TRUE)) { @@ -1844,7 +1844,7 @@ static int mesh_reverse_uvs(bContext *C, wmOperator *op) EDBM_InitOpf(em, &bmop, op, "meshreverseuvs faces=%hf", BM_ELEM_SELECT); /* execute the operator */ - BMO_Exec_Op(em->bm, &bmop); + BMO_op_exec(em->bm, &bmop); /* finish the operator */ if (!EDBM_FinishOp(em, &bmop, op, TRUE)) { @@ -1872,7 +1872,7 @@ static int mesh_rotate_colors(bContext *C, wmOperator *op) EDBM_InitOpf(em, &bmop, op, "meshrotatecolors faces=%hf dir=%d", BM_ELEM_SELECT, dir); /* execute the operator */ - BMO_Exec_Op(em->bm, &bmop); + BMO_op_exec(em->bm, &bmop); /* finish the operator */ if (!EDBM_FinishOp(em, &bmop, op, TRUE)) { @@ -1900,7 +1900,7 @@ static int mesh_reverse_colors(bContext *C, wmOperator *op) EDBM_InitOpf(em, &bmop, op, "meshreversecolors faces=%hf", BM_ELEM_SELECT); /* execute the operator */ - BMO_Exec_Op(em->bm, &bmop); + BMO_op_exec(em->bm, &bmop); /* finish the operator */ if (!EDBM_FinishOp(em, &bmop, op, TRUE)) { @@ -1999,7 +1999,7 @@ static int merge_firstlast(BMEditMesh *em, int first, int uvmerge, wmOperator *w mergevert = (BMVert *)ese->data; } - if (!BM_TestHFlag(mergevert, BM_ELEM_SELECT)) + if (!BM_elem_flag_test(mergevert, BM_ELEM_SELECT)) return OPERATOR_CANCELLED; if (uvmerge) { @@ -2029,7 +2029,7 @@ static int merge_target(BMEditMesh *em, Scene *scene, View3D *v3d, Object *ob, float fac; int i = 0; BM_ITER(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (!BM_TestHFlag(v, BM_ELEM_SELECT)) + if (!BM_elem_flag_test(v, BM_ELEM_SELECT)) continue; add_v3_v3(cent, v->co); i++; @@ -2175,12 +2175,12 @@ static int removedoublesflag_exec(bContext *C, wmOperator *op) EDBM_InitOpf(em, &bmop, op, "finddoubles verts=%hv dist=%f", BM_ELEM_SELECT, RNA_float_get(op->ptr, "mergedist")); - BMO_Exec_Op(em->bm, &bmop); + BMO_op_exec(em->bm, &bmop); - /* count = BMO_CountSlotMap(em->bm, &bmop, "targetmapout"); */ /* UNUSED */ + /* count = BMO_slot_map_count(em->bm, &bmop, "targetmapout"); */ /* UNUSED */ if (!EDBM_CallOpf(em, op, "weldverts targetmap=%s", &bmop, "targetmapout")) { - BMO_Finish_Op(em->bm, &bmop); + BMO_op_finish(em->bm, &bmop); return OPERATOR_CANCELLED; } @@ -2262,13 +2262,13 @@ static int select_vertex_path_exec(bContext *C, wmOperator *op) EDBM_InitOpf(em, &bmop, op, "vertexshortestpath startv=%e endv=%e type=%d", sv->data, ev->data, type); /* execute the operator */ - BMO_Exec_Op(em->bm, &bmop); + BMO_op_exec(em->bm, &bmop); /* DO NOT clear the existing selection */ /* EDBM_clear_flag_all(em, BM_ELEM_SELECT); */ /* select the output */ - BMO_HeaderFlag_Buffer(em->bm, &bmop, "vertout", BM_ELEM_SELECT, BM_ALL); + BMO_slot_buffer_hflag(em->bm, &bmop, "vertout", BM_ELEM_SELECT, BM_ALL); /* finish the operator */ if (!EDBM_FinishOp(em, &bmop, op, TRUE)) { @@ -2348,11 +2348,11 @@ static int mesh_rip_invoke(bContext *C, wmOperator *op, wmEvent *event) ED_view3d_ob_project_mat_get(rv3d, obedit, projectMat); BM_ITER(e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) { - if (BM_TestHFlag(e, BM_ELEM_SELECT)) { - BM_SetHFlag(e, BM_ELEM_TAG); + if (BM_elem_flag_test(e, BM_ELEM_SELECT)) { + BM_elem_flag_set(e, BM_ELEM_TAG); } else { - BM_ClearHFlag(e, BM_ELEM_TAG); + BM_elem_flag_clear(e, BM_ELEM_TAG); } } @@ -2364,7 +2364,7 @@ static int mesh_rip_invoke(bContext *C, wmOperator *op, wmEvent *event) /* find selected vert */ BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) { - if (BM_TestHFlag(v, BM_ELEM_SELECT)) + if (BM_elem_flag_test(v, BM_ELEM_SELECT)) break; } @@ -2391,25 +2391,25 @@ static int mesh_rip_invoke(bContext *C, wmOperator *op, wmEvent *event) return OPERATOR_CANCELLED; /* rip two adjacent edges */ - if (BM_Edge_FaceCount(e2) == 1 || BM_Vert_FaceCount(v) == 2) { + if (BM_edge_face_count(e2) == 1 || BM_vert_face_count(v) == 2) { l = e2->l; - ripvert = BM_Rip_Vertex(bm, l->f, v); + ripvert = BM_vert_rip(bm, l->f, v); BLI_assert(ripvert); if (!ripvert) { return OPERATOR_CANCELLED; } } - else if (BM_Edge_FaceCount(e2) == 2) { + else if (BM_edge_face_count(e2) == 2) { l = e2->l; - e = BM_OtherFaceLoop(e2, l->f, v)->e; - BM_SetHFlag(e, BM_ELEM_TAG); - BM_Select(bm, e, TRUE); + e = BM_face_other_loop(e2, l->f, v)->e; + BM_elem_flag_set(e, BM_ELEM_TAG); + BM_elem_select_set(bm, e, TRUE); l = e2->l->radial_next; - e = BM_OtherFaceLoop(e2, l->f, v)->e; - BM_SetHFlag(e, BM_ELEM_TAG); - BM_Select(bm, e, TRUE); + e = BM_face_other_loop(e2, l->f, v)->e; + BM_elem_flag_set(e, BM_ELEM_TAG); + BM_elem_select_set(bm, e, TRUE); } dist = FLT_MAX; @@ -2420,19 +2420,19 @@ static int mesh_rip_invoke(bContext *C, wmOperator *op, wmEvent *event) e2 = NULL; i = 0; BM_ITER(e, &eiter, bm, BM_EDGES_OF_VERT, v) { - if (BM_TestHFlag(e, BM_ELEM_TAG)) { + if (BM_elem_flag_test(e, BM_ELEM_TAG)) { e2 = e; i++; } } if (i == 1 && e2->l) { - l = BM_OtherFaceLoop(e2, e2->l->f, v); + l = BM_face_other_loop(e2, e2->l->f, v); l = l->radial_next; - l = BM_OtherFaceLoop(l->e, l->f, v); + l = BM_face_other_loop(l->e, l->f, v); if (l) { - BM_Select(bm, l->e, TRUE); + BM_elem_select_set(bm, l->e, TRUE); } } } @@ -2442,7 +2442,7 @@ static int mesh_rip_invoke(bContext *C, wmOperator *op, wmEvent *event) return OPERATOR_CANCELLED; } - BMO_Exec_Op(bm, &bmop); + BMO_op_exec(bm, &bmop); /* build bvh tree for edge visibility tests */ bvhtree = BMBVH_NewBVH(em, 0, NULL, NULL); @@ -2486,14 +2486,14 @@ static int mesh_rip_invoke(bContext *C, wmOperator *op, wmEvent *event) BMBVH_FreeBVH(bvhtree); EDBM_clear_flag_all(em, BM_ELEM_SELECT); - BMO_HeaderFlag_Buffer(bm, &bmop, side?"edgeout2":"edgeout1", BM_ELEM_SELECT, BM_EDGE); + BMO_slot_buffer_hflag(bm, &bmop, side?"edgeout2":"edgeout1", BM_ELEM_SELECT, BM_EDGE); BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) { - if (BM_TestHFlag(e, BM_ELEM_SELECT)) { - BM_SetHFlag(e, BM_ELEM_TAG); + if (BM_elem_flag_test(e, BM_ELEM_SELECT)) { + BM_elem_flag_set(e, BM_ELEM_TAG); } else { - BM_ClearHFlag(e, BM_ELEM_TAG); + BM_elem_flag_clear(e, BM_ELEM_TAG); } } @@ -2502,7 +2502,7 @@ static int mesh_rip_invoke(bContext *C, wmOperator *op, wmEvent *event) e2 = NULL; i = 0; BM_ITER(e, &eiter, bm, BM_EDGES_OF_VERT, v) { - if (BM_TestHFlag(e, BM_ELEM_TAG)) { + if (BM_elem_flag_test(e, BM_ELEM_TAG)) { e2 = e; i++; } @@ -2510,14 +2510,14 @@ static int mesh_rip_invoke(bContext *C, wmOperator *op, wmEvent *event) if (i == 1) { if (singlesel) - BM_Select(bm, v, FALSE); + BM_elem_select_set(bm, v, FALSE); else - BM_Select(bm, e2, FALSE); + BM_elem_select_set(bm, e2, FALSE); } } if (ripvert) { - BM_Select(bm, ripvert, TRUE); + BM_elem_select_set(bm, ripvert, TRUE); } EDBM_selectmode_flush(em); @@ -2572,7 +2572,7 @@ static void shape_propagate(Object *obedit, BMEditMesh *em, wmOperator *op) } BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (!BM_TestHFlag(eve, BM_ELEM_SELECT) || BM_TestHFlag(eve, BM_ELEM_HIDDEN)) + if (!BM_elem_flag_test(eve, BM_ELEM_SELECT) || BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) continue; for (i = 0; i < totshape; i++) { @@ -2644,7 +2644,7 @@ static int blend_from_shape_exec(bContext *C, wmOperator *op) return OPERATOR_CANCELLED; BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (!BM_TestHFlag(eve, BM_ELEM_SELECT) || BM_TestHFlag(eve, BM_ELEM_HIDDEN)) + if (!BM_elem_flag_test(eve, BM_ELEM_SELECT) || BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) continue; sco = CustomData_bmesh_get_n(&em->bm->vdata, eve->head.data, CD_SHAPEKEY, shape); @@ -2748,19 +2748,19 @@ static int select_axis_exec(bContext *C, wmOperator *op) value += limit; BM_ITER(ev, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (!BM_TestHFlag(ev, BM_ELEM_HIDDEN)) { + if (!BM_elem_flag_test(ev, BM_ELEM_HIDDEN)) { switch(mode) { case -1: /* aligned */ if (fabs(ev->co[axis] - value) < limit) - BM_Select(em->bm, ev, TRUE); + BM_elem_select_set(em->bm, ev, TRUE); break; case 0: /* neg */ if (ev->co[axis] > value) - BM_Select(em->bm, ev, TRUE); + BM_elem_select_set(em->bm, ev, TRUE); break; case 1: /* pos */ if (ev->co[axis] < value) - BM_Select(em->bm, ev, TRUE); + BM_elem_select_set(em->bm, ev, TRUE); break; } } @@ -2821,13 +2821,13 @@ static int solidify_exec(bContext *C, wmOperator *op) /* deselect only the faces in the region to be solidified (leave wire edges and loose verts selected, as there will be no corresponding geometry selected below) */ - BMO_UnHeaderFlag_Buffer(bm, &bmop, "geom", BM_ELEM_SELECT, BM_FACE); + BMO_slot_buffer_hflag_clear(bm, &bmop, "geom", BM_ELEM_SELECT, BM_FACE); /* run the solidify operator */ - BMO_Exec_Op(bm, &bmop); + BMO_op_exec(bm, &bmop); /* select the newly generated faces */ - BMO_HeaderFlag_Buffer(bm, &bmop, "geomout", BM_ELEM_SELECT, BM_FACE); + BMO_slot_buffer_hflag(bm, &bmop, "geomout", BM_ELEM_SELECT, BM_FACE); if (!EDBM_FinishOp(em, &bmop, op, TRUE)) { return OPERATOR_CANCELLED; @@ -3102,7 +3102,7 @@ static int knife_cut_exec(bContext *C, wmOperator *op) /* the floating point coordinates of verts in screen space will be stored in a hash table according to the vertices pointer */ gh = BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, "knife cut exec"); - for (bv = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL); bv; bv = BMIter_Step(&iter)) { + for (bv = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL); bv; bv = BM_iter_step(&iter)) { scr = MEM_mallocN(sizeof(float)*2, "Vertex Screen Coordinates"); copy_v3_v3(co, bv->co); co[3] = 1.0f; @@ -3116,41 +3116,41 @@ static int knife_cut_exec(bContext *C, wmOperator *op) } /* store percentage of edge cut for KNIFE_EXACT here.*/ - for (be = BMIter_New(&iter, bm, BM_EDGES_OF_MESH, NULL); be; be = BMIter_Step(&iter)) { - if (BM_Selected(bm, be)) { + for (be = BM_iter_new(&iter, bm, BM_EDGES_OF_MESH, NULL); be; be = BM_iter_step(&iter)) { + if (BM_elem_select_test(bm, be)) { isect = bm_seg_intersect(be, curve, len, mode, gh, &isected); if (isect != 0.0f) { if (mode != KNIFE_MULTICUT && mode != KNIFE_MIDPOINT) { - BMO_Insert_MapFloat(bm, &bmop, + BMO_slot_map_float_insert(bm, &bmop, "edgepercents", be, isect); } - BMO_SetFlag(bm, be, 1); + BMO_elem_flag_set(bm, be, 1); } else { - BMO_ClearFlag(bm, be, 1); + BMO_elem_flag_clear(bm, be, 1); } } else { - BMO_ClearFlag(bm, be, 1); + BMO_elem_flag_clear(bm, be, 1); } } - BMO_Flag_To_Slot(bm, &bmop, "edges", 1, BM_EDGE); + BMO_slot_from_flag(bm, &bmop, "edges", 1, BM_EDGE); if (mode == KNIFE_MIDPOINT) numcuts = 1; - BMO_Set_Int(&bmop, "numcuts", numcuts); + BMO_slot_int_set(&bmop, "numcuts", numcuts); - BMO_Set_Int(&bmop, "flag", B_KNIFE); - BMO_Set_Int(&bmop, "quadcornertype", SUBD_STRAIGHT_CUT); - BMO_Set_Int(&bmop, "singleedge", 0); - BMO_Set_Int(&bmop, "gridfill", 0); + BMO_slot_int_set(&bmop, "flag", B_KNIFE); + BMO_slot_int_set(&bmop, "quadcornertype", SUBD_STRAIGHT_CUT); + BMO_slot_int_set(&bmop, "singleedge", 0); + BMO_slot_int_set(&bmop, "gridfill", 0); - BMO_Set_Float(&bmop, "radius", 0); + BMO_slot_float_set(&bmop, "radius", 0); - BMO_Exec_Op(bm, &bmop); + BMO_op_exec(bm, &bmop); if (!EDBM_FinishOp(em, &bmop, op, TRUE)) { return OPERATOR_CANCELLED; } @@ -3203,7 +3203,7 @@ static int mesh_separate_selected(Main *bmain, Scene *scene, Base *editbase, wmO if (!em) return OPERATOR_CANCELLED; - bmnew = BM_Make_Mesh(obedit, allocsize); + bmnew = BM_mesh_create(obedit, allocsize); CustomData_copy(&em->bm->vdata, &bmnew->vdata, CD_MASK_BMESH, CD_CALLOC, 0); CustomData_copy(&em->bm->edata, &bmnew->edata, CD_MASK_BMESH, CD_CALLOC, 0); CustomData_copy(&em->bm->ldata, &bmnew->ldata, CD_MASK_BMESH, CD_CALLOC, 0); @@ -3224,31 +3224,31 @@ static int mesh_separate_selected(Main *bmain, Scene *scene, Base *editbase, wmO /* clean up any loose edges */ BM_ITER(e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) { - if (BM_TestHFlag(e, BM_ELEM_HIDDEN)) + if (BM_elem_flag_test(e, BM_ELEM_HIDDEN)) continue; - if (BM_Edge_FaceCount(e) != 0) { - BM_Select(em->bm, e, FALSE); + if (BM_edge_face_count(e) != 0) { + BM_elem_select_set(em->bm, e, FALSE); } } EDBM_CallOpf(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) { - if (BM_TestHFlag(v, BM_ELEM_HIDDEN)) + if (BM_elem_flag_test(v, BM_ELEM_HIDDEN)) continue; - if (BM_Vert_EdgeCount(v) != 0) { - BM_Select(em->bm, v, FALSE); + if (BM_vert_edge_count(v) != 0) { + BM_elem_select_set(em->bm, v, FALSE); } } EDBM_CallOpf(em, wmop, "del geom=%hvef context=%i", BM_ELEM_SELECT, DEL_VERTS); - BM_Compute_Normals(bmnew); - BMO_CallOpf(bmnew, "bmesh_to_mesh mesh=%p object=%p", basenew->object->data, basenew->object); + BM_mesh_normals_update(bmnew); + BMO_op_callf(bmnew, "bmesh_to_mesh mesh=%p object=%p", basenew->object->data, basenew->object); - BM_Free_Mesh(bmnew); + BM_mesh_free(bmnew); ((Mesh *)basenew->object->data)->edit_btmesh = NULL; return 1; @@ -3277,7 +3277,7 @@ static int mesh_separate_loose(Main *bmain, Scene *scene, Base *editbase, wmOper /* Clear all selected vertices */ BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) { - BM_Select(bm, v, FALSE); + BM_elem_select_set(bm, v, FALSE); } /* Flush the selection to clear edge/face selections to match @@ -3303,20 +3303,20 @@ static int mesh_separate_loose(Main *bmain, Scene *scene, Base *editbase, wmOper } /* Select the seed explicitly, in case it has no edges */ - BM_Select(bm, v_seed, TRUE); + BM_elem_select_set(bm, v_seed, TRUE); /* Walk from the single vertex, selecting everything connected * to it */ - BMW_Init(&walker, bm, BMW_SHELL, + BMW_init(&walker, bm, BMW_SHELL, BMW_MASK_NOP, BMW_MASK_NOP, BMW_MASK_NOP, BMW_MASK_NOP, BMW_NIL_LAY); - e = BMW_Begin(&walker, v_seed); - for (; e; e = BMW_Step(&walker)) { - BM_Select(bm, e->v1, TRUE); - BM_Select(bm, e->v2, TRUE); + e = BMW_begin(&walker, v_seed); + for (; e; e = BMW_step(&walker)) { + BM_elem_select_set(bm, e->v1, TRUE); + BM_elem_select_set(bm, e->v2, TRUE); } - BMW_End(&walker); + BMW_end(&walker); /* Flush the selection to get edge/face selections matching * the vertex selection */ @@ -3394,10 +3394,10 @@ static int fill_mesh_exec(bContext *C, wmOperator *op) if (!EDBM_InitOpf(em, &bmop, op, "triangle_fill edges=%he", BM_ELEM_SELECT)) return OPERATOR_CANCELLED; - BMO_Exec_Op(em->bm, &bmop); + BMO_op_exec(em->bm, &bmop); /* select new geometry */ - BMO_HeaderFlag_Buffer(em->bm, &bmop, "geomout", BM_ELEM_SELECT, BM_FACE|BM_EDGE); + BMO_slot_buffer_hflag(em->bm, &bmop, "geomout", BM_ELEM_SELECT, BM_FACE|BM_EDGE); if (!EDBM_FinishOp(em, &bmop, op, TRUE)) { return OPERATOR_CANCELLED; @@ -3570,9 +3570,9 @@ static int split_mesh_exec(bContext *C, wmOperator *op) BMOperator bmop; EDBM_InitOpf(em, &bmop, op, "split geom=%hvef", BM_ELEM_SELECT); - BMO_Exec_Op(em->bm, &bmop); + BMO_op_exec(em->bm, &bmop); BM_clear_flag_all(em->bm, BM_ELEM_SELECT); - BMO_HeaderFlag_Buffer(em->bm, &bmop, "geomout", BM_ELEM_SELECT, BM_ALL); + BMO_slot_buffer_hflag(em->bm, &bmop, "geomout", BM_ELEM_SELECT, BM_ALL); if (!EDBM_FinishOp(em, &bmop, op, TRUE)) { return OPERATOR_CANCELLED; } @@ -3632,9 +3632,9 @@ static int spin_mesh_exec(bContext *C, wmOperator *op) BM_ELEM_SELECT, cent, axis, d, steps, degr, dupli)) { return OPERATOR_CANCELLED; } - BMO_Exec_Op(bm, &spinop); + BMO_op_exec(bm, &spinop); EDBM_clear_flag_all(em, BM_ELEM_SELECT); - BMO_HeaderFlag_Buffer(bm, &spinop, "lastout", BM_ELEM_SELECT, BM_ALL); + BMO_slot_buffer_hflag(bm, &spinop, "lastout", BM_ELEM_SELECT, BM_ALL); if (!EDBM_FinishOp(em, &spinop, op, TRUE)) { return OPERATOR_CANCELLED; } @@ -3712,15 +3712,15 @@ static int screw_mesh_exec(bContext *C, wmOperator *op) /* find two vertices with valence count == 1, more or less is wrong */ v1 = NULL; v2 = NULL; - for (eve = BMIter_New(&iter, em->bm, BM_VERTS_OF_MESH, NULL); - eve; eve = BMIter_Step(&iter)) { + for (eve = BM_iter_new(&iter, em->bm, BM_VERTS_OF_MESH, NULL); + eve; eve = BM_iter_step(&iter)) { valence = 0; - for (eed = BMIter_New(&eiter, em->bm, BM_EDGES_OF_VERT, eve); - eed; eed = BMIter_Step(&eiter)) { + for (eed = BM_iter_new(&eiter, em->bm, BM_EDGES_OF_VERT, eve); + eed; eed = BM_iter_step(&eiter)) { - if (BM_TestHFlag(eed, BM_ELEM_SELECT)) { + if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) { valence++; } @@ -3758,9 +3758,9 @@ static int screw_mesh_exec(bContext *C, wmOperator *op) { return OPERATOR_CANCELLED; } - BMO_Exec_Op(bm, &spinop); + BMO_op_exec(bm, &spinop); EDBM_clear_flag_all(em, BM_ELEM_SELECT); - BMO_HeaderFlag_Buffer(bm, &spinop, "lastout", BM_ELEM_SELECT, BM_ALL); + BMO_slot_buffer_hflag(bm, &spinop, "lastout", BM_ELEM_SELECT, BM_ALL); if (!EDBM_FinishOp(em, &spinop, op, TRUE)) { return OPERATOR_CANCELLED; } @@ -3817,8 +3817,8 @@ static int select_by_number_vertices_exec(bContext *C, wmOperator *op) int numverts = RNA_int_get(op->ptr, "number"); int type = RNA_enum_get(op->ptr, "type"); - for (efa = BMIter_New(&iter, em->bm, BM_FACES_OF_MESH, NULL); - efa; efa = BMIter_Step(&iter)) { + for (efa = BM_iter_new(&iter, em->bm, BM_FACES_OF_MESH, NULL); + efa; efa = BM_iter_step(&iter)) { int select = 0; @@ -3831,7 +3831,7 @@ static int select_by_number_vertices_exec(bContext *C, wmOperator *op) } if (select) { - BM_Select(em->bm, efa, TRUE); + BM_elem_select_set(em->bm, efa, TRUE); } } @@ -3875,19 +3875,19 @@ static int select_loose_verts_exec(bContext *C, wmOperator *UNUSED(op)) BMEdge *eed; BMIter iter; - for (eve = BMIter_New(&iter, em->bm, BM_VERTS_OF_MESH, NULL); - eve; eve = BMIter_Step(&iter)) { + for (eve = BM_iter_new(&iter, em->bm, BM_VERTS_OF_MESH, NULL); + eve; eve = BM_iter_step(&iter)) { if (!eve->e) { - BM_Select(em->bm, eve, TRUE); + BM_elem_select_set(em->bm, eve, TRUE); } } - for (eed = BMIter_New(&iter, em->bm, BM_EDGES_OF_MESH, NULL); - eed; eed = BMIter_Step(&iter)) { + for (eed = BM_iter_new(&iter, em->bm, BM_EDGES_OF_MESH, NULL); + eed; eed = BM_iter_step(&iter)) { if (!eed->l) { - BM_Select(em->bm, eed, TRUE); + BM_elem_select_set(em->bm, eed, TRUE); } } @@ -4009,7 +4009,7 @@ static void xsortvert_flag(bContext *UNUSED(C), int UNUSED(flag)) amount = em->bm->totvert; sortblock = MEM_callocN(sizeof(xvertsort)*amount,"xsort"); BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (BM_TestHFlag(eve, BM_ELEM_SELECT)) + if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) sortblock[i].v1 = eve; } @@ -4354,7 +4354,7 @@ static int mesh_noise_exec(bContext *C, wmOperator *op) float b2, vec[3]; float ofs = tex->turbul / 200.0; BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (BM_TestHFlag(eve, BM_ELEM_SELECT) && !BM_TestHFlag(eve, BM_ELEM_HIDDEN)) { + if (BM_elem_flag_test(eve, BM_ELEM_SELECT) && !BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) { b2 = BLI_hnoise(tex->noisesize, eve->co[0], eve->co[1], eve->co[2]); if (tex->stype) ofs *= (b2 * b2); vec[0] = fac * (b2 - BLI_hnoise(tex->noisesize, eve->co[0] + ofs, eve->co[1], eve->co[2])); @@ -4367,7 +4367,7 @@ static int mesh_noise_exec(bContext *C, wmOperator *op) } else { BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (BM_TestHFlag(eve, BM_ELEM_SELECT) && !BM_TestHFlag(eve, BM_ELEM_HIDDEN)) { + if (BM_elem_flag_test(eve, BM_ELEM_SELECT) && !BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) { float tin, dum; externtex(ma->mtex[0], eve->co, &tin, &dum, &dum, &dum, &dum, 0); eve->co[2] += fac * tin; @@ -4415,7 +4415,7 @@ static int mesh_bevel_exec(bContext *C, wmOperator *op) float *w = NULL, ftot; int li; - BM_add_data_layer(em->bm, &em->bm->edata, CD_PROP_FLT); + 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) { @@ -4456,12 +4456,12 @@ static int mesh_bevel_exec(bContext *C, wmOperator *op) return OPERATOR_CANCELLED; } - BMO_Exec_Op(em->bm, &bmop); + BMO_op_exec(em->bm, &bmop); if (!EDBM_FinishOp(em, &bmop, op, TRUE)) return OPERATOR_CANCELLED; } - BM_free_data_layer_n(em->bm, &em->bm->edata, CD_MASK_PROP_FLT, li); + BM_data_layer_free_n(em->bm, &em->bm->edata, CD_MASK_PROP_FLT, li); MEM_freeN(w); diff --git a/source/blender/editors/mesh/bmeshutils.c b/source/blender/editors/mesh/bmeshutils.c index ec72b0ebd54..5fa455a13d1 100644 --- a/source/blender/editors/mesh/bmeshutils.c +++ b/source/blender/editors/mesh/bmeshutils.c @@ -49,13 +49,13 @@ void EDBM_RecalcNormals(BMEditMesh *em) { - BM_Compute_Normals(em->bm); + BM_mesh_normals_update(em->bm); } void EDBM_ClearMesh(BMEditMesh *em) { /* clear bmesh */ - BM_Clear_Mesh(em->bm); + BM_mesh_clear(em->bm); /* free derived meshes */ if (em->derivedCage) { @@ -93,9 +93,9 @@ void EDBM_stats_update(BMEditMesh *em) em->bm->totvertsel = em->bm->totedgesel = em->bm->totfacesel = 0; for (i = 0; i < 3; i++) { - ele = BMIter_New(&iter, em->bm, iter_types[i], NULL); - for ( ; ele; ele = BMIter_Step(&iter)) { - if (BM_TestHFlag(ele, BM_ELEM_SELECT)) { + ele = BM_iter_new(&iter, em->bm, iter_types[i], NULL); + for ( ; ele; ele = BM_iter_step(&iter)) { + if (BM_elem_flag_test(ele, BM_ELEM_SELECT)) { (*tots[i])++; } } @@ -109,7 +109,7 @@ int EDBM_InitOpf(BMEditMesh *em, BMOperator *bmop, wmOperator *op, const char *f va_start(list, fmt); - if (!BMO_VInitOpf(bm, bmop, fmt, list)) { + if (!BMO_op_vinitf(bm, bmop, fmt, list)) { BKE_report(op->reports, RPT_ERROR, "Parse error in EDBM_CallOpf"); va_end(list); @@ -131,9 +131,9 @@ int EDBM_FinishOp(BMEditMesh *em, BMOperator *bmop, wmOperator *op, const int re { const char *errmsg; - BMO_Finish_Op(em->bm, bmop); + BMO_op_finish(em->bm, bmop); - if (BMO_GetError(em->bm, &errmsg, NULL)) { + if (BMO_error_get(em->bm, &errmsg, NULL)) { BMEditMesh *emcopy = em->emcopy; if (report) BKE_report(op->reports, RPT_ERROR, errmsg); @@ -171,7 +171,7 @@ int EDBM_CallOpf(BMEditMesh *em, wmOperator *op, const char *fmt, ...) va_start(list, fmt); - if (!BMO_VInitOpf(bm, &bmop, fmt, list)) { + if (!BMO_op_vinitf(bm, &bmop, fmt, list)) { BKE_report(op->reports, RPT_ERROR, "Parse error in EDBM_CallOpf"); va_end(list); @@ -182,7 +182,7 @@ int EDBM_CallOpf(BMEditMesh *em, wmOperator *op, const char *fmt, ...) em->emcopy = BMEdit_Copy(em); em->emcopyusers++; - BMO_Exec_Op(bm, &bmop); + BMO_op_exec(bm, &bmop); va_end(list); return EDBM_FinishOp(em, &bmop, op, TRUE); @@ -196,7 +196,7 @@ int EDBM_CallAndSelectOpf(BMEditMesh *em, wmOperator *op, const char *selectslot va_start(list, fmt); - if (!BMO_VInitOpf(bm, &bmop, fmt, list)) { + if (!BMO_op_vinitf(bm, &bmop, fmt, list)) { BKE_report(op->reports, RPT_ERROR, "Parse error in EDBM_CallOpf"); va_end(list); @@ -207,8 +207,8 @@ int EDBM_CallAndSelectOpf(BMEditMesh *em, wmOperator *op, const char *selectslot em->emcopy = BMEdit_Copy(em); em->emcopyusers++; - BMO_Exec_Op(bm, &bmop); - BMO_HeaderFlag_Buffer(em->bm, &bmop, selectslot, BM_ELEM_SELECT, BM_ALL); + BMO_op_exec(bm, &bmop); + BMO_slot_buffer_hflag(em->bm, &bmop, selectslot, BM_ELEM_SELECT, BM_ALL); va_end(list); return EDBM_FinishOp(em, &bmop, op, TRUE); @@ -222,7 +222,7 @@ int EDBM_CallOpfSilent(BMEditMesh *em, const char *fmt, ...) va_start(list, fmt); - if (!BMO_VInitOpf(bm, &bmop, fmt, list)) { + if (!BMO_op_vinitf(bm, &bmop, fmt, list)) { va_end(list); return 0; } @@ -231,7 +231,7 @@ int EDBM_CallOpfSilent(BMEditMesh *em, const char *fmt, ...) em->emcopy = BMEdit_Copy(em); em->emcopyusers++; - BMO_Exec_Op(bm, &bmop); + BMO_op_exec(bm, &bmop); va_end(list); return EDBM_FinishOp(em, &bmop, NULL, FALSE); @@ -291,7 +291,7 @@ void EDBM_LoadEditBMesh(Scene *scene, Object *ob) Mesh *me = ob->data; BMesh *bm = me->edit_btmesh->bm; - BMO_CallOpf(bm, "object_load_bmesh scene=%p object=%p", scene, ob); + BMO_op_callf(bm, "object_load_bmesh scene=%p object=%p", scene, ob); } void EDBM_FreeEditBMesh(BMEditMesh *tm) @@ -310,8 +310,8 @@ void EDBM_init_index_arrays(BMEditMesh *tm, int forvert, int foredge, int forfac tm->vert_index = MEM_mallocN(sizeof(void **) * tm->bm->totvert, "tm->vert_index"); - ele = BMIter_New(&iter, tm->bm, BM_VERTS_OF_MESH, NULL); - for ( ; ele; ele = BMIter_Step(&iter)) { + ele = BM_iter_new(&iter, tm->bm, BM_VERTS_OF_MESH, NULL); + for ( ; ele; ele = BM_iter_step(&iter)) { tm->vert_index[i++] = ele; } } @@ -323,8 +323,8 @@ void EDBM_init_index_arrays(BMEditMesh *tm, int forvert, int foredge, int forfac tm->edge_index = MEM_mallocN(sizeof(void **) * tm->bm->totedge, "tm->edge_index"); - ele = BMIter_New(&iter, tm->bm, BM_EDGES_OF_MESH, NULL); - for ( ; ele; ele = BMIter_Step(&iter)) { + ele = BM_iter_new(&iter, tm->bm, BM_EDGES_OF_MESH, NULL); + for ( ; ele; ele = BM_iter_step(&iter)) { tm->edge_index[i++] = ele; } } @@ -336,8 +336,8 @@ void EDBM_init_index_arrays(BMEditMesh *tm, int forvert, int foredge, int forfac tm->face_index = MEM_mallocN(sizeof(void **) * tm->bm->totface, "tm->face_index"); - ele = BMIter_New(&iter, tm->bm, BM_FACES_OF_MESH, NULL); - for ( ; ele; ele = BMIter_Step(&iter)) { + ele = BM_iter_new(&iter, tm->bm, BM_FACES_OF_MESH, NULL); + for ( ; ele; ele = BM_iter_step(&iter)) { tm->face_index[i++] = ele; } } @@ -379,7 +379,7 @@ BMFace *EDBM_get_face_for_index(BMEditMesh *tm, int index) void EDBM_selectmode_flush_ex(BMEditMesh *em, int selectmode) { em->bm->selectmode = selectmode; - BM_SelectMode_Flush(em->bm); + BM_mesh_select_mode_flush(em->bm); em->bm->selectmode = em->selectmode; } @@ -392,7 +392,7 @@ void EDBM_deselect_flush(BMEditMesh *em) { /* function below doesnt use. just do this to keep the values in sync */ em->bm->selectmode = em->selectmode; - BM_DeSelect_Flush(em->bm); + BM_mesh_deselect_flush(em->bm); } @@ -400,7 +400,7 @@ void EDBM_select_flush(BMEditMesh *em) { /* function below doesnt use. just do this to keep the values in sync */ em->bm->selectmode = em->selectmode; - BM_Select_Flush(em->bm); + BM_mesh_select_flush(em->bm); } void EDBM_select_more(BMEditMesh *em) @@ -408,12 +408,12 @@ void EDBM_select_more(BMEditMesh *em) BMOperator bmop; int usefaces = em->selectmode > SCE_SELECT_EDGE; - BMO_InitOpf(em->bm, &bmop, + BMO_op_initf(em->bm, &bmop, "regionextend geom=%hvef constrict=%d usefaces=%d", BM_ELEM_SELECT, 0, usefaces); - BMO_Exec_Op(em->bm, &bmop); - BMO_HeaderFlag_Buffer(em->bm, &bmop, "geomout", BM_ELEM_SELECT, BM_ALL); - BMO_Finish_Op(em->bm, &bmop); + BMO_op_exec(em->bm, &bmop); + BMO_slot_buffer_hflag(em->bm, &bmop, "geomout", BM_ELEM_SELECT, BM_ALL); + BMO_op_finish(em->bm, &bmop); EDBM_selectmode_flush(em); } @@ -423,12 +423,12 @@ void EDBM_select_less(BMEditMesh *em) BMOperator bmop; int usefaces = em->selectmode > SCE_SELECT_EDGE; - BMO_InitOpf(em->bm, &bmop, + BMO_op_initf(em->bm, &bmop, "regionextend geom=%hvef constrict=%d usefaces=%d", BM_ELEM_SELECT, 0, usefaces); - BMO_Exec_Op(em->bm, &bmop); - BMO_HeaderFlag_Buffer(em->bm, &bmop, "geomout", BM_ELEM_SELECT, BM_ALL); - BMO_Finish_Op(em->bm, &bmop); + BMO_op_exec(em->bm, &bmop); + BMO_slot_buffer_hflag(em->bm, &bmop, "geomout", BM_ELEM_SELECT, BM_ALL); + BMO_op_finish(em->bm, &bmop); EDBM_selectmode_flush(em); } @@ -436,7 +436,7 @@ void EDBM_select_less(BMEditMesh *em) int EDBM_get_actSelection(BMEditMesh *em, BMEditSelection *ese) { BMEditSelection *ese_last = em->bm->selected.last; - BMFace *efa = BM_get_actFace(em->bm, FALSE); + BMFace *efa = BM_active_face_get(em->bm, FALSE); ese->next = ese->prev = NULL; @@ -476,12 +476,12 @@ void EDBM_clear_flag_all(BMEditMesh *em, const char hflag) int i; if (hflag & BM_ELEM_SELECT) - BM_clear_selection_history(em->bm); + BM_select_history_clear(em->bm); for (i = 0; i < 3; i++) { BM_ITER(ele, &iter, em->bm, iter_types[i], NULL) { - if (hflag & BM_ELEM_SELECT) BM_Select(em->bm, ele, FALSE); - BM_ClearHFlag(ele, hflag); + if (hflag & BM_ELEM_SELECT) BM_elem_select_set(em->bm, ele, FALSE); + BM_elem_flag_clear(ele, hflag); } } } @@ -496,13 +496,13 @@ void EDBM_set_flag_all(BMEditMesh *em, const char hflag) int i; for (i = 0; i < 3; i++) { - ele = BMIter_New(&iter, em->bm, iter_types[i], NULL); - for ( ; ele; ele = BMIter_Step(&iter)) { + ele = BM_iter_new(&iter, em->bm, iter_types[i], NULL); + for ( ; ele; ele = BM_iter_step(&iter)) { if (hflag & BM_ELEM_SELECT) { - BM_Select(em->bm, ele, TRUE); + BM_elem_select_set(em->bm, ele, TRUE); } else { - BM_SetHFlag(ele, hflag); + BM_elem_flag_set(ele, hflag); } } } @@ -548,7 +548,7 @@ static void *editbtMesh_to_undoMesh(void *emv, void *obdata) #endif - BMO_CallOpf(em->bm, "bmesh_to_mesh mesh=%p notesselation=%i", &um->me, 1); + BMO_op_callf(em->bm, "bmesh_to_mesh mesh=%p notesselation=%i", &um->me, 1); um->selectmode = em->selectmode; return um; @@ -567,8 +567,8 @@ static void undoMesh_to_editbtMesh(void *umv, void *emv, void *UNUSED(obdata)) BMEdit_Free(em); - bm = BM_Make_Mesh(ob, allocsize); - BMO_CallOpf(bm, "mesh_to_bmesh mesh=%p object=%p set_shapekey=%i", &um->me, ob, 0); + bm = BM_mesh_create(ob, allocsize); + BMO_op_callf(bm, "mesh_to_bmesh mesh=%p object=%p set_shapekey=%i", &um->me, ob, 0); em2 = BMEdit_Create(bm, TRUE); *em = *em2; @@ -614,14 +614,14 @@ UvVertMap *EDBM_make_uv_vert_map(BMEditMesh *em, int selected, int do_face_idx_a if (do_face_idx_array) EDBM_init_index_arrays(em, 0, 0, 1); - BM_ElemIndex_Ensure(em->bm, BM_VERT); + BM_mesh_elem_index_ensure(em->bm, BM_VERT); totverts = em->bm->totvert; totuv = 0; /* generate UvMapVert array */ BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (!selected || ((!BM_TestHFlag(efa, BM_ELEM_HIDDEN)) && BM_TestHFlag(efa, BM_ELEM_SELECT))) + if (!selected || ((!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) && BM_elem_flag_test(efa, BM_ELEM_SELECT))) totuv += efa->len; } @@ -649,15 +649,15 @@ UvVertMap *EDBM_make_uv_vert_map(BMEditMesh *em, int selected, int do_face_idx_a a = 0; BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (!selected || ((!BM_TestHFlag(efa, BM_ELEM_HIDDEN)) && BM_TestHFlag(efa, BM_ELEM_SELECT))) { + 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) { buf->tfindex = i; buf->f = a; buf->separate = 0; - buf->next = vmap->vert[BM_GetIndex(l->v)]; - vmap->vert[BM_GetIndex(l->v)] = buf; + buf->next = vmap->vert[BM_elem_index_get(l->v)]; + vmap->vert[BM_elem_index_get(l->v)] = buf; buf++; i++; @@ -683,7 +683,7 @@ UvVertMap *EDBM_make_uv_vert_map(BMEditMesh *em, int selected, int do_face_idx_a efa = EDBM_get_face_for_index(em, v->f); /* tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); */ /* UNUSED */ - l = BMIter_AtIndex(em->bm, BM_LOOPS_OF_FACE, efa, v->tfindex); + l = BM_iter_at_index(em->bm, BM_LOOPS_OF_FACE, efa, v->tfindex); luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV); uv = luv->uv; @@ -695,7 +695,7 @@ UvVertMap *EDBM_make_uv_vert_map(BMEditMesh *em, int selected, int do_face_idx_a efa = EDBM_get_face_for_index(em, iterv->f); /* tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); */ /* UNUSED */ - l = BMIter_AtIndex(em->bm, BM_LOOPS_OF_FACE, efa, iterv->tfindex); + l = BM_iter_at_index(em->bm, BM_LOOPS_OF_FACE, efa, iterv->tfindex); luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV); uv2 = luv->uv; @@ -754,14 +754,14 @@ UvElementMap *EDBM_make_uv_element_map(BMEditMesh *em, int selected, int do_isla BMFace **stack; int stacksize = 0; - BM_ElemIndex_Ensure(em->bm, BM_VERT | BM_FACE); + BM_mesh_elem_index_ensure(em->bm, BM_VERT | BM_FACE); totverts = em->bm->totvert; totuv = 0; /* generate UvElement array */ BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (!selected || ((!BM_TestHFlag(efa, BM_ELEM_HIDDEN)) && BM_TestHFlag(efa, BM_ELEM_SELECT))) + if (!selected || ((!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) && BM_elem_flag_test(efa, BM_ELEM_SELECT))) totuv += efa->len; } @@ -782,7 +782,7 @@ UvElementMap *EDBM_make_uv_element_map(BMEditMesh *em, int selected, int do_isla } BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (!selected || ((!BM_TestHFlag(efa, BM_ELEM_HIDDEN)) && BM_TestHFlag(efa, BM_ELEM_SELECT))) { + 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) { buf->tfindex = i; @@ -790,8 +790,8 @@ UvElementMap *EDBM_make_uv_element_map(BMEditMesh *em, int selected, int do_isla buf->separate = 0; buf->island = INVALID_ISLAND; - buf->next = element_map->vert[BM_GetIndex(l->v)]; - element_map->vert[BM_GetIndex(l->v)] = buf; + buf->next = element_map->vert[BM_elem_index_get(l->v)]; + element_map->vert[BM_elem_index_get(l->v)] = buf; buf++; i++; @@ -815,7 +815,7 @@ UvElementMap *EDBM_make_uv_element_map(BMEditMesh *em, int selected, int do_isla efa = v->face; /* tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); */ /* UNUSED */ - l = BMIter_AtIndex(em->bm, BM_LOOPS_OF_FACE, efa, v->tfindex); + l = BM_iter_at_index(em->bm, BM_LOOPS_OF_FACE, efa, v->tfindex); luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV); uv = luv->uv; @@ -827,7 +827,7 @@ UvElementMap *EDBM_make_uv_element_map(BMEditMesh *em, int selected, int do_isla efa = iterv->face; /* tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); */ /* UNUSED */ - l = BMIter_AtIndex(em->bm, BM_LOOPS_OF_FACE, efa, iterv->tfindex); + l = BM_iter_at_index(em->bm, BM_LOOPS_OF_FACE, efa, iterv->tfindex); luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV); uv2 = luv->uv; @@ -866,14 +866,14 @@ UvElementMap *EDBM_make_uv_element_map(BMEditMesh *em, int selected, int do_isla if (element_map->buf[i].island == INVALID_ISLAND) { element_map->buf[i].island = nislands; stack[0] = element_map->buf[i].face; - island_number[BM_GetIndex(stack[0])] = nislands; + island_number[BM_elem_index_get(stack[0])] = nislands; stacksize = 1; while (stacksize > 0) { efa = stack[--stacksize]; BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { - UvElement *element, *initelement = element_map->vert[BM_GetIndex(l->v)]; + UvElement *element, *initelement = element_map->vert[BM_elem_index_get(l->v)]; for (element = initelement; element; element = element->next) { if (element->separate) @@ -893,9 +893,9 @@ UvElementMap *EDBM_make_uv_element_map(BMEditMesh *em, int selected, int do_isla if (element->separate && element != initelement) break; - if (island_number[BM_GetIndex(element->face)] == INVALID_ISLAND) { + if (island_number[BM_elem_index_get(element->face)] == INVALID_ISLAND) { stack[stacksize++] = element->face; - island_number[BM_GetIndex(element->face)] = nislands; + island_number[BM_elem_index_get(element->face)] = nislands; } } break; @@ -984,7 +984,7 @@ MTexPoly *EDBM_get_active_mtexpoly(BMEditMesh *em, BMFace **act_efa, int sloppy) if (!EDBM_texFaceCheck(em)) return NULL; - efa = BM_get_actFace(em->bm, sloppy); + efa = BM_active_face_get(em->bm, sloppy); if (efa) { if (act_efa) *act_efa = efa; @@ -1041,14 +1041,14 @@ void EDBM_CacheMirrorVerts(BMEditMesh *em, const short use_select) } if (!CustomData_get_layer_named(&bm->vdata, CD_PROP_INT, BM_CD_LAYER_ID)) { - BM_add_data_layer_named(bm, &bm->vdata, CD_PROP_INT, BM_CD_LAYER_ID); + BM_data_layer_add_named(bm, &bm->vdata, CD_PROP_INT, BM_CD_LAYER_ID); } li = CustomData_get_named_layer_index(&bm->vdata, CD_PROP_INT, BM_CD_LAYER_ID); bm->vdata.layers[li].flag |= CD_FLAG_TEMPORARY; - BM_ElemIndex_Ensure(bm, BM_VERT); + BM_mesh_elem_index_ensure(bm, BM_VERT); if (topo) { ED_mesh_mirrtopo_init(me, -1, &mesh_topo_store, TRUE); @@ -1060,7 +1060,7 @@ void EDBM_CacheMirrorVerts(BMEditMesh *em, const short use_select) BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) { /* temporary for testing, check for selection */ - if (use_select && !BM_TestHFlag(v, BM_ELEM_SELECT)) { + if (use_select && !BM_elem_flag_test(v, BM_ELEM_SELECT)) { /* do nothing */ } else { @@ -1068,7 +1068,7 @@ void EDBM_CacheMirrorVerts(BMEditMesh *em, const short use_select) int *idx = CustomData_bmesh_get_layer_n(&bm->vdata, v->head.data, li); if (topo) { - mirr = cache_mirr_intptr_as_bmvert(mesh_topo_store.index_lookup, BM_GetIndex(v)); + mirr = cache_mirr_intptr_as_bmvert(mesh_topo_store.index_lookup, BM_elem_index_get(v)); } else { float co[3] = {-v->co[0], v->co[1], v->co[2]}; @@ -1076,9 +1076,9 @@ void EDBM_CacheMirrorVerts(BMEditMesh *em, const short use_select) } if (mirr && mirr != v) { - *idx = BM_GetIndex(mirr); + *idx = BM_elem_index_get(mirr); idx = CustomData_bmesh_get_layer_n(&bm->vdata, mirr->head.data, li); - *idx = BM_GetIndex(v); + *idx = BM_elem_index_get(v); } else { *idx = -1; @@ -1146,10 +1146,10 @@ void EDBM_ApplyMirrorCache(BMEditMesh *em, const int sel_from, const int sel_to) BLI_assert(em->vert_index != NULL); BM_ITER(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (BM_TestHFlag(v, BM_ELEM_SELECT) == sel_from) { + if (BM_elem_flag_test(v, BM_ELEM_SELECT) == sel_from) { BMVert *mirr = EDBM_GetMirrorVert(em, v); if (mirr) { - if (BM_TestHFlag(mirr, BM_ELEM_SELECT) == sel_to) { + if (BM_elem_flag_test(mirr, BM_ELEM_SELECT) == sel_to) { copy_v3_v3(mirr->co, v->co); mirr->co[0] *= -1.0f; } diff --git a/source/blender/editors/mesh/editbmesh_bvh.c b/source/blender/editors/mesh/editbmesh_bvh.c index 7c7b1eb52e0..cc1f89e2c8b 100644 --- a/source/blender/editors/mesh/editbmesh_bvh.c +++ b/source/blender/editors/mesh/editbmesh_bvh.c @@ -108,7 +108,7 @@ BMBVHTree *BMBVH_NewBVH(BMEditMesh *em, int flag, Scene *scene, Object *obedit) 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_SetIndex(v, i); /* set_inline */ + BM_elem_index_set(v, i); /* set_inline */ copy_v3_v3(tree->cos[i], v->co); } em->bm->elem_index_dirty &= ~BM_VERT; @@ -128,9 +128,9 @@ BMBVHTree *BMBVH_NewBVH(BMEditMesh *em, int flag, Scene *scene, Object *obedit) for (i=0; i<em->tottri; i++) { if (flag & BMBVH_USE_CAGE) { - copy_v3_v3(cos[0], cagecos[BM_GetIndex(em->looptris[i][0]->v)]); - copy_v3_v3(cos[1], cagecos[BM_GetIndex(em->looptris[i][1]->v)]); - copy_v3_v3(cos[2], cagecos[BM_GetIndex(em->looptris[i][2]->v)]); + copy_v3_v3(cos[0], cagecos[BM_elem_index_get(em->looptris[i][0]->v)]); + copy_v3_v3(cos[1], cagecos[BM_elem_index_get(em->looptris[i][1]->v)]); + copy_v3_v3(cos[2], cagecos[BM_elem_index_get(em->looptris[i][2]->v)]); } else { copy_v3_v3(cos[0], em->looptris[i][0]->v->co); copy_v3_v3(cos[1], em->looptris[i][1]->v->co); @@ -339,7 +339,7 @@ static BMFace *edge_ray_cast(BMBVHTree *tree, float *co, float *dir, float *hito { BMFace *f = BMBVH_RayCast(tree, co, dir, hitout, NULL); - if (f && BM_Edge_In_Face(f, e)) + if (f && BM_edge_in_face(f, e)) return NULL; return f; diff --git a/source/blender/editors/mesh/editface.c b/source/blender/editors/mesh/editface.c index 4709a4ba831..bec1403a8dd 100644 --- a/source/blender/editors/mesh/editface.c +++ b/source/blender/editors/mesh/editface.c @@ -803,7 +803,7 @@ void ED_mesh_mirrtopo_init(Mesh *me, const int ob_mode, MirrTopoStore_t *mesh_to mesh_topo_store->prev_ob_mode = ob_mode; if(em) { - BM_ElemIndex_Ensure(em->bm, BM_VERT); + BM_mesh_elem_index_ensure(em->bm, BM_VERT); totvert = em->bm->totvert; } @@ -818,8 +818,8 @@ void ED_mesh_mirrtopo_init(Mesh *me, const int ob_mode, MirrTopoStore_t *mesh_to totedge = me->edit_btmesh->bm->totedge; BM_ITER(eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) { - topo_hash[BM_GetIndex(eed->v1)]++; - topo_hash[BM_GetIndex(eed->v2)]++; + topo_hash[BM_elem_index_get(eed->v1)]++; + topo_hash[BM_elem_index_get(eed->v2)]++; } } else { @@ -839,8 +839,8 @@ void ED_mesh_mirrtopo_init(Mesh *me, const int ob_mode, MirrTopoStore_t *mesh_to if(em) { BM_ITER(eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) { - topo_hash[BM_GetIndex(eed->v1)] += topo_hash_prev[BM_GetIndex(eed->v2)]; - topo_hash[BM_GetIndex(eed->v2)] += topo_hash_prev[BM_GetIndex(eed->v1)]; + 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)]; } } else { diff --git a/source/blender/editors/mesh/knifetool.c b/source/blender/editors/mesh/knifetool.c index b5d938c12e1..c72c61d14f3 100755 --- a/source/blender/editors/mesh/knifetool.c +++ b/source/blender/editors/mesh/knifetool.c @@ -220,7 +220,7 @@ static KnifeVert *get_bm_knife_vert(knifetool_opdata *kcd, BMVert *v) KnifeVert *kfv = BLI_ghash_lookup(kcd->origvertmap, v); if (!kfv) { - kfv = new_knife_vert(kcd, v->co, kcd->cagecos[BM_GetIndex(v)]); + kfv = new_knife_vert(kcd, v->co, kcd->cagecos[BM_elem_index_get(v)]); kfv->v = v; BLI_ghash_insert(kcd->origvertmap, v, kfv); } @@ -281,7 +281,7 @@ static void knife_start_cut(knifetool_opdata *kcd) knife_input_ray_cast(kcd, kcd->vc.mval, origin, ray); add_v3_v3v3(co, origin, ray); - v0 = BM_Vert_AtIndex(kcd->em->bm, 0); + v0 = BM_vert_at_index(kcd->em->bm, 0); if (v0) { closest_to_line_v3(kcd->prevcage, v0->co, co, origin); copy_v3_v3(kcd->prevco, kcd->prevcage); @@ -1651,12 +1651,12 @@ static void remerge_faces(knifetool_opdata *kcd) BMOperator bmop; int idx; - BMO_InitOpf(bm, &bmop, "beautify_fill faces=%ff constrain_edges=%fe", FACE_NEW, BOUNDARY); + BMO_op_initf(bm, &bmop, "beautify_fill faces=%ff constrain_edges=%fe", FACE_NEW, BOUNDARY); - BMO_Exec_Op(bm, &bmop); - BMO_Flag_Buffer(bm, &bmop, "geomout", FACE_NEW, BM_FACE); + BMO_op_exec(bm, &bmop); + BMO_slot_buffer_flag(bm, &bmop, "geomout", FACE_NEW, BM_FACE); - BMO_Finish_Op(bm, &bmop); + BMO_op_finish(bm, &bmop); BLI_smallhash_init(visit); BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) { @@ -1664,7 +1664,7 @@ static void remerge_faces(knifetool_opdata *kcd) BMEdge *e; BMFace *f2; - if (!BMO_TestFlag(bm, f, FACE_NEW)) + if (!BMO_elem_flag_test(bm, f, FACE_NEW)) continue; if (BLI_smallhash_haskey(visit, (intptr_t)f)) @@ -1684,11 +1684,11 @@ static void remerge_faces(knifetool_opdata *kcd) BMIter fiter; BMFace *f3; - if (BMO_TestFlag(bm, e, BOUNDARY)) + if (BMO_elem_flag_test(bm, e, BOUNDARY)) continue; BM_ITER(f3, &fiter, bm, BM_FACES_OF_EDGE, e) { - if (!BMO_TestFlag(bm, f3, FACE_NEW)) + if (!BMO_elem_flag_test(bm, f3, FACE_NEW)) continue; if (BLI_smallhash_haskey(visit, (intptr_t)f3)) continue; @@ -1700,12 +1700,12 @@ static void remerge_faces(knifetool_opdata *kcd) } while (BLI_array_count(stack) > 0); if (BLI_array_count(faces) > 0) { - idx = BM_GetIndex(faces[0]); + idx = BM_elem_index_get(faces[0]); - f2 = BM_Join_Faces(bm, faces, BLI_array_count(faces)); + f2 = BM_faces_join(bm, faces, BLI_array_count(faces)); if (f2) { - BMO_SetFlag(bm, f2, FACE_NEW); - BM_SetIndex(f2, idx); /* set_dirty! */ /* BMESH_TODO, check if this is valid or not */ + BMO_elem_flag_set(bm, f2, FACE_NEW); + BM_elem_index_set(f2, idx); /* set_dirty! */ /* BMESH_TODO, check if this is valid or not */ } } } @@ -1741,14 +1741,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_SetIndex(f, i); /* set_inline */ + 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) { - BMO_SetFlag(bm, e, BOUNDARY); + BMO_elem_flag_set(bm, e, BOUNDARY); } /* turn knife verts into real verts, as necassary */ @@ -1756,16 +1756,16 @@ static void knifenet_fill_faces(knifetool_opdata *kcd) for (kfv = BLI_mempool_iterstep(&iter); kfv; kfv = BLI_mempool_iterstep(&iter)) { if (!kfv->v) { /* shouldn't we be at least copying the normal? - if not some comment here should explain why - campbell */ - kfv->v = BM_Make_Vert(bm, kfv->co, NULL); + kfv->v = BM_vert_create(bm, kfv->co, NULL); kfv->flag = 1; - BMO_SetFlag(bm, kfv->v, DEL); + BMO_elem_flag_set(bm, kfv->v, DEL); } else { kfv->flag = 0; - BMO_SetFlag(bm, kfv->v, VERT_ORIG); + BMO_elem_flag_set(bm, kfv->v, VERT_ORIG); } - BMO_SetFlag(bm, kfv->v, MARK); + BMO_elem_flag_set(bm, kfv->v, MARK); } /* we want to only do changed faces. first, go over new edges and add to @@ -1789,20 +1789,20 @@ static void knifenet_fill_faces(knifetool_opdata *kcd) if (kfe->e) { kfe->oe = kfe->e; - BMO_SetFlag(bm, kfe->e, DEL); - BMO_ClearFlag(bm, kfe->e, BOUNDARY); + BMO_elem_flag_set(bm, kfe->e, DEL); + BMO_elem_flag_clear(bm, kfe->e, BOUNDARY); kfe->e = NULL; } - kfe->e = BM_Make_Edge(bm, kfe->v1->v, kfe->v2->v, NULL, TRUE); - BMO_SetFlag(bm, kfe->e, BOUNDARY); + kfe->e = BM_edge_create(bm, kfe->v1->v, kfe->v2->v, NULL, TRUE); + BMO_elem_flag_set(bm, kfe->e, BOUNDARY); for (ref = kfe->faces.first; ref; ref = ref->next) { f = ref->ref; entry = BLI_memarena_alloc(arena, sizeof(*entry)); entry->kfe = kfe; - BLI_addtail(face_nets + BM_GetIndex(f), entry); + BLI_addtail(face_nets + BM_elem_index_get(f), entry); } } @@ -1818,16 +1818,16 @@ static void knifenet_fill_faces(knifetool_opdata *kcd) k++; - BMO_SetFlag(bm, kfe->e, BOUNDARY); + BMO_elem_flag_set(bm, kfe->e, BOUNDARY); kfe->oe = kfe->e; for (ref = kfe->faces.first; ref; ref = ref->next) { f = ref->ref; - if (face_nets[BM_GetIndex(f)].first) { + if (face_nets[BM_elem_index_get(f)].first) { entry = BLI_memarena_alloc(arena, sizeof(*entry)); entry->kfe = kfe; - BLI_addtail(face_nets + BM_GetIndex(f), entry); + BLI_addtail(face_nets + BM_elem_index_get(f), entry); } } } @@ -1842,7 +1842,7 @@ static void knifenet_fill_faces(knifetool_opdata *kcd) BLI_smallhash_init(hash); if (face_nets[i].first) - BMO_SetFlag(bm, f, DEL); + BMO_elem_flag_set(bm, f, DEL); BLI_begin_edgefill(); @@ -1882,8 +1882,8 @@ static void knifenet_fill_faces(knifetool_opdata *kcd) if (entry->kfe->oe) eed->f = FILLBOUNDARY; /* mark as original boundary edge */ - BMO_ClearFlag(bm, entry->kfe->e->v1, DEL); - BMO_ClearFlag(bm, entry->kfe->e->v2, DEL); + BMO_elem_flag_clear(bm, entry->kfe->e->v1, DEL); + BMO_elem_flag_clear(bm, entry->kfe->e->v2, DEL); } else { if (lasteve->xs < 2) @@ -1903,27 +1903,27 @@ static void knifenet_fill_faces(knifetool_opdata *kcd) if (v1 == v2 || v2 == v3 || v1 == v3) continue; - if (BM_Face_Exists(bm, verts, 3, &f2)) + if (BM_face_exists(bm, verts, 3, &f2)) continue; - f2 = BM_Make_Face_QuadTri(bm, + f2 = BM_face_create_quad_tri(bm, v1, v2, v3, NULL, NULL, FALSE); - BMO_SetFlag(bm, f2, FACE_NEW); + BMO_elem_flag_set(bm, f2, FACE_NEW); l = BM_FACE_FIRST_LOOP(f2); do { - BMO_ClearFlag(bm, l->e, DEL); + BMO_elem_flag_clear(bm, l->e, DEL); l = l->next; } while (l != BM_FACE_FIRST_LOOP(f2)); - BMO_ClearFlag(bm, f2, DEL); - BM_SetIndex(f2, i); /* set_dirty! */ /* note, not 100% sure this is dirty? need to check */ + BMO_elem_flag_clear(bm, f2, DEL); + BM_elem_index_set(f2, i); /* set_dirty! */ /* note, not 100% sure this is dirty? need to check */ - BM_Face_UpdateNormal(bm, f2); + BM_face_normal_update(bm, f2); if (dot_v3v3(f->no, f2->no) < 0.0f) { - BM_flip_normal(bm, f2); + BM_face_normal_flip(bm, f2); } } @@ -1938,15 +1938,15 @@ static void knifenet_fill_faces(knifetool_opdata *kcd) BMFace *f2; BMIter liter1; - if (!BMO_TestFlag(bm, f, FACE_NEW)) + if (!BMO_elem_flag_test(bm, f, FACE_NEW)) continue; - f2 = faces[BM_GetIndex(f)]; - if (BM_GetIndex(f) < 0 || BM_GetIndex(f) >= totface) { + f2 = faces[BM_elem_index_get(f)]; + if (BM_elem_index_get(f) < 0 || BM_elem_index_get(f) >= totface) { fprintf(stderr, "%s: face index out of range! (bmesh internal error)\n", __func__); } - BM_Copy_Attributes(bm, bm, f2, f); + BM_elem_copy_attrs(bm, bm, f2, f); BM_ITER(l1, &liter1, bm, BM_LOOPS_OF_FACE, f) { BM_loop_interp_from_face(bm, l1, f2, TRUE, TRUE); @@ -1957,9 +1957,9 @@ static void knifenet_fill_faces(knifetool_opdata *kcd) remerge_faces(kcd); /* delete left over faces */ - BMO_CallOpf(bm, "del geom=%ff context=%i", DEL, DEL_ONLYFACES); - BMO_CallOpf(bm, "del geom=%fe context=%i", DEL, DEL_EDGES); - BMO_CallOpf(bm, "del geom=%fv context=%i", DEL, DEL_VERTS); + BMO_op_callf(bm, "del geom=%ff context=%i", DEL, DEL_ONLYFACES); + BMO_op_callf(bm, "del geom=%fe context=%i", DEL, DEL_EDGES); + BMO_op_callf(bm, "del geom=%fv context=%i", DEL, DEL_VERTS); if (face_nets) MEM_freeN(face_nets); @@ -1968,7 +1968,7 @@ static void knifenet_fill_faces(knifetool_opdata *kcd) BLI_memarena_free(arena); BLI_smallhash_release(hash); - BMO_ClearStack(bm); /* remerge_faces sometimes raises errors, so make sure to clear them */ + BMO_error_clear(bm); /* remerge_faces sometimes raises errors, so make sure to clear them */ bmesh_end_edit(bm, BMOP_UNTAN_MULTIRES); BMO_pop(bm); @@ -2084,7 +2084,7 @@ static int knifetool_init(bContext *C, wmOperator *op, int UNUSED(do_cut)) kcd->em = ((Mesh *)kcd->ob->data)->edit_btmesh; - BM_ElemIndex_Ensure(kcd->em->bm, BM_VERT); + BM_mesh_elem_index_ensure(kcd->em->bm, BM_VERT); cage = editbmesh_get_derived_cage_and_final(scene, obedit, kcd->em, &final, CD_MASK_DERIVEDMESH); kcd->cagecos = MEM_callocN(sizeof(float) * 3 * kcd->em->bm->totvert, "knife cagecos"); diff --git a/source/blender/editors/mesh/loopcut.c b/source/blender/editors/mesh/loopcut.c index ee99443e8ef..5667b4b13b6 100644 --- a/source/blender/editors/mesh/loopcut.c +++ b/source/blender/editors/mesh/loopcut.c @@ -145,9 +145,9 @@ static void edgering_find_order(BMEditMesh *em, BMEdge *lasteed, BMEdge *eed, l = eed->l; /*find correct order for v[1]*/ - if (!(BM_Edge_In_Face(l->f, eed) && BM_Edge_In_Face(l->f, lasteed))) { + 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) { - if (BM_Edge_In_Face(l->f, eed) && BM_Edge_In_Face(l->f, lasteed)) + if (BM_edge_in_face(l->f, eed) && BM_edge_in_face(l->f, lasteed)) break; } } @@ -161,7 +161,7 @@ static void edgering_find_order(BMEditMesh *em, BMEdge *lasteed, BMEdge *eed, return; } - l2 = BM_OtherFaceLoop(l->e, l->f, eed->v1); + l2 = BM_face_other_loop(l->e, l->f, eed->v1); rev = (l2 == l->prev); while (l2->v != lasteed->v1 && l2->v != lasteed->v2) { l2 = rev ? l2->prev : l2->next; @@ -204,26 +204,26 @@ static void edgering_sel(tringselOpData *lcd, int previewlines, int select) } if (select) { - BMW_Init(&walker, em->bm, BMW_EDGERING, + BMW_init(&walker, em->bm, BMW_EDGERING, BMW_MASK_NOP, BMW_MASK_NOP, BMW_MASK_NOP, BMW_MASK_NOP, BMW_NIL_LAY); - eed = BMW_Begin(&walker, startedge); - for (; eed; eed=BMW_Step(&walker)) { - BM_Select(em->bm, eed, TRUE); + eed = BMW_begin(&walker, startedge); + for (; eed; eed=BMW_step(&walker)) { + BM_elem_select_set(em->bm, eed, TRUE); } - BMW_End(&walker); + BMW_end(&walker); return; } - BMW_Init(&walker, em->bm, BMW_EDGERING, + BMW_init(&walker, em->bm, BMW_EDGERING, BMW_MASK_NOP, BMW_MASK_NOP, BMW_MASK_NOP, BMW_MASK_NOP, BMW_NIL_LAY); - eed = startedge = BMW_Begin(&walker, startedge); + eed = startedge = BMW_begin(&walker, startedge); lastv1 = NULL; - for (lasteed=NULL; eed; eed=BMW_Step(&walker)) { + for (lasteed=NULL; eed; eed=BMW_step(&walker)) { if (lasteed) { if (lastv1) { v[1][0] = v[0][0]; @@ -255,7 +255,7 @@ static void edgering_sel(tringselOpData *lcd, int previewlines, int select) lasteed = eed; } - if (lasteed != startedge && BM_Edge_Share_Faces(lasteed, startedge)) { + if (lasteed != startedge && BM_edge_share_faces(lasteed, startedge)) { v[1][0] = v[0][0]; v[1][1] = v[0][1]; @@ -280,7 +280,7 @@ static void edgering_sel(tringselOpData *lcd, int previewlines, int select) } } - BMW_End(&walker); + BMW_end(&walker); lcd->edges = edges; lcd->totedge = tot; } diff --git a/source/blender/editors/mesh/mesh_data.c b/source/blender/editors/mesh/mesh_data.c index 9ed177f0f7d..e818f8aad93 100644 --- a/source/blender/editors/mesh/mesh_data.c +++ b/source/blender/editors/mesh/mesh_data.c @@ -109,7 +109,7 @@ static void delete_customdata_layer(bContext *C, Object *ob, CustomDataLayer *la CustomData_set_layer_active(data, type, layer - &data->layers[index]); if(me->edit_btmesh) { - BM_free_data_layer(me->edit_btmesh->bm, data, type); + BM_data_layer_free(me->edit_btmesh->bm, data, type); } else { CustomData_free_layer_active(data, type, tot); @@ -215,7 +215,7 @@ int ED_mesh_uv_loop_reset(struct bContext *C, struct Mesh *me) BLI_assert(CustomData_has_layer(&em->bm->ldata, CD_MLOOPUV)); BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (!BM_TestHFlag(efa, BM_ELEM_SELECT)) + if (!BM_elem_flag_test(efa, BM_ELEM_SELECT)) continue; i = 0; @@ -312,7 +312,7 @@ int ED_mesh_uv_texture_add(bContext *C, Mesh *me, const char *name, int active_s if (layernum >= MAX_MTFACE) return -1; - BM_add_data_layer(em->bm, &em->bm->pdata, CD_MTEXPOLY); + BM_data_layer_add(em->bm, &em->bm->pdata, CD_MTEXPOLY); CustomData_set_layer_active(&em->bm->pdata, CD_MTEXPOLY, layernum); CustomData_set_layer_name(&em->bm->pdata, CD_MTEXPOLY, layernum, name); @@ -324,7 +324,7 @@ int ED_mesh_uv_texture_add(bContext *C, Mesh *me, const char *name, int active_s CustomData_set_layer_active(&em->bm->pdata, CD_MTEXPOLY, layernum); } - BM_add_data_layer(em->bm, &em->bm->ldata, CD_MLOOPUV); + BM_data_layer_add(em->bm, &em->bm->ldata, CD_MLOOPUV); CustomData_set_layer_name(&em->bm->ldata, CD_MLOOPUV, layernum, name); CustomData_set_layer_active(&em->bm->ldata, CD_MLOOPUV, layernum); @@ -402,7 +402,7 @@ int ED_mesh_color_add(bContext *C, Scene *UNUSED(scene), Object *UNUSED(ob), Mes return -1; } - BM_add_data_layer(em->bm, &em->bm->pdata, CD_MLOOPCOL); + BM_data_layer_add(em->bm, &em->bm->pdata, CD_MLOOPCOL); CustomData_set_layer_active(&em->bm->ldata, CD_MLOOPCOL, layernum); /* copy data from active vertex color layer */ diff --git a/source/blender/editors/mesh/mesh_navmesh.c b/source/blender/editors/mesh/mesh_navmesh.c index bb3d6a88c5d..9593e54acd7 100644 --- a/source/blender/editors/mesh/mesh_navmesh.c +++ b/source/blender/editors/mesh/mesh_navmesh.c @@ -339,7 +339,7 @@ static Object* createRepresentation(bContext *C, struct recast_polyMesh *pmesh, co[1]= bmin[1] + v[1]*ch; co[2]= bmin[2] + v[2]*cs; SWAP(float, co[1], co[2]); - BM_Make_Vert(em->bm, co, NULL); + BM_vert_create(em->bm, co, NULL); } /* create custom data layer to save polygon idx */ @@ -369,7 +369,7 @@ static Object* createRepresentation(bContext *C, struct recast_polyMesh *pmesh, for(j= nv; j<ndv; j++) { copy_v3_v3(co, &dverts[3*(vbase + j)]); SWAP(float, co[1], co[2]); - BM_Make_Vert(em->bm, co, NULL); + BM_vert_create(em->bm, co, NULL); } EDBM_init_index_arrays(em, 1, 0, 0); @@ -386,7 +386,7 @@ static Object* createRepresentation(bContext *C, struct recast_polyMesh *pmesh, else face[k] = uniquevbase+tri[k]-nv; /* unique vertex */ } - newFace= BM_Make_Face_QuadTri(em->bm, + newFace= BM_face_create_quad_tri(em->bm, EDBM_get_vert_for_index(em, face[0]), EDBM_get_vert_for_index(em, face[2]), EDBM_get_vert_for_index(em, face[1]), NULL, @@ -487,7 +487,7 @@ static int navmesh_face_copy_exec(bContext *C, wmOperator *op) BMEditMesh *em= ((Mesh *)obedit->data)->edit_btmesh; /* do work here */ - BMFace *efa_act= BM_get_actFace(em->bm, FALSE); + BMFace *efa_act= BM_active_face_get(em->bm, FALSE); if(efa_act) { if(CustomData_has_layer(&em->bm->pdata, CD_RECAST)) { @@ -499,7 +499,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) { - if(BM_TestHFlag(efa, BM_ELEM_SELECT) && efa != efa_act) { + 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; } @@ -584,7 +584,7 @@ static int navmesh_face_add_exec(bContext *C, wmOperator *UNUSED(op)) /*XXX this originally went last to first, but that isn't possible anymore*/ BM_ITER(ef, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if(BM_TestHFlag(ef, BM_ELEM_SELECT)) { + 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; } diff --git a/source/blender/editors/object/object_hook.c b/source/blender/editors/object/object_hook.c index bf018a75995..2083c51efa9 100644 --- a/source/blender/editors/object/object_hook.c +++ b/source/blender/editors/object/object_hook.c @@ -79,7 +79,7 @@ static int return_editmesh_indexar(BMEditMesh *em, int *tot, int **indexar, floa int *index, nr, totvert=0; BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if(BM_TestHFlag(eve, BM_ELEM_SELECT)) totvert++; + if(BM_elem_flag_test(eve, BM_ELEM_SELECT)) totvert++; } if(totvert==0) return 0; @@ -89,7 +89,7 @@ static int return_editmesh_indexar(BMEditMesh *em, int *tot, int **indexar, floa zero_v3(cent); BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if(BM_TestHFlag(eve, BM_ELEM_SELECT)) { + if(BM_elem_flag_test(eve, BM_ELEM_SELECT)) { *index= nr; index++; add_v3_v3(cent, eve->co); } @@ -148,7 +148,7 @@ static void select_editbmesh_hook(Object *ob, HookModifierData *hmd) BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { if(nr==hmd->indexar[index]) { - BM_Select(em->bm, eve, TRUE); + BM_elem_select_set(em->bm, eve, TRUE); if(index < hmd->totindex-1) index++; } diff --git a/source/blender/editors/object/object_modifier.c b/source/blender/editors/object/object_modifier.c index aef8aa42931..e8a09732313 100644 --- a/source/blender/editors/object/object_modifier.c +++ b/source/blender/editors/object/object_modifier.c @@ -220,7 +220,7 @@ static int object_modifier_remove(Object *ob, ModifierData *md, int *sort_depsgr /* CustomData_external_remove is used here only to mark layer as non-external for further free-ing, so zero element count looks safer than em->totface */ CustomData_external_remove(&em->bm->ldata, &me->id, CD_MDISPS, 0); - BM_free_data_layer(em->bm, &em->bm->ldata, CD_MDISPS); + BM_data_layer_free(em->bm, &em->bm->ldata, CD_MDISPS); } else { CustomData_external_remove(&me->ldata, &me->id, CD_MDISPS, me->totloop); CustomData_free_layer_active(&me->ldata, CD_MDISPS, me->totloop); diff --git a/source/blender/editors/object/object_relations.c b/source/blender/editors/object/object_relations.c index 63c15734803..f64f25391f9 100644 --- a/source/blender/editors/object/object_relations.c +++ b/source/blender/editors/object/object_relations.c @@ -138,7 +138,7 @@ static int vertex_parent_set_exec(bContext *C, wmOperator *op) makeDerivedMesh(scene, obedit, em, CD_MASK_BAREMESH, 0); BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (BM_TestHFlag(eve, BM_ELEM_SELECT)) { + if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) { if(v1==0) v1= nr; else if(v2==0) v2= nr; else if(v3==0) v3= nr; diff --git a/source/blender/editors/object/object_vgroup.c b/source/blender/editors/object/object_vgroup.c index f5c80694e54..5520cb32e85 100644 --- a/source/blender/editors/object/object_vgroup.c +++ b/source/blender/editors/object/object_vgroup.c @@ -206,7 +206,7 @@ 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) { - (*dvert_arr)[i] = BM_TestHFlag(eve, BM_ELEM_SELECT) ? + (*dvert_arr)[i] = BM_elem_flag_test(eve, BM_ELEM_SELECT) ? CustomData_em_get(&em->bm->vdata, eve->head.data, CD_MDEFORMVERT) : NULL; i++; } @@ -522,7 +522,7 @@ static float get_vert_def_nr(Object *ob, const int def_nr, const int vertnum) me= ob->data; if(me->edit_btmesh) { - eve= BM_Vert_AtIndex(me->edit_btmesh->bm, vertnum); + eve= BM_vert_at_index(me->edit_btmesh->bm, vertnum); if(!eve) { return 0.0f; } @@ -593,10 +593,10 @@ static void vgroup_select_verts(Object *ob, int select) BMVert *eve; BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (!BM_TestHFlag(eve, BM_ELEM_HIDDEN)) { + 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)) { - BM_Select(em->bm, eve, select); + BM_elem_select_set(em->bm, eve, select); } } } @@ -1303,7 +1303,7 @@ static void vgroup_blend(Object *ob) float *vg_users; int sel1, sel2; - BM_ElemIndex_Ensure(em->bm, BM_VERT); + BM_mesh_elem_index_ensure(em->bm, BM_VERT); dvert_tot= em->bm->totvert; @@ -1311,19 +1311,19 @@ static void vgroup_blend(Object *ob) vg_users= MEM_callocN(sizeof(int)*dvert_tot, "vgroup_blend_i"); BM_ITER(eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) { - sel1= BM_TestHFlag(eed->v1, BM_ELEM_SELECT); - sel2= BM_TestHFlag(eed->v2, BM_ELEM_SELECT); + sel1= BM_elem_flag_test(eed->v1, BM_ELEM_SELECT); + sel2= BM_elem_flag_test(eed->v2, BM_ELEM_SELECT); if(sel1 != sel2) { /* i1 is always the selected one */ if(sel1==TRUE && sel2==FALSE) { - i1= BM_GetIndex(eed->v1); - i2= BM_GetIndex(eed->v2); + i1= BM_elem_index_get(eed->v1); + i2= BM_elem_index_get(eed->v2); eve= eed->v2; } else { - i2= BM_GetIndex(eed->v1); - i1= BM_GetIndex(eed->v2); + i2= BM_elem_index_get(eed->v1); + i1= BM_elem_index_get(eed->v2); eve= eed->v1; } @@ -1343,7 +1343,7 @@ static void vgroup_blend(Object *ob) i= 0; BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if(BM_TestHFlag(eve, BM_ELEM_SELECT) && vg_users[i] > 0) { + if(BM_elem_flag_test(eve, BM_ELEM_SELECT) && vg_users[i] > 0) { /* TODO, we may want object mode blending */ if(em) dvert= CustomData_bmesh_get(&em->bm->vdata, eve->head.data, CD_MDEFORMVERT); else dvert= dvert_array+i; @@ -1559,8 +1559,8 @@ void ED_vgroup_mirror(Object *ob, const short mirror_weights, const short flip_v /* Go through the list of editverts and assign them */ BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { if((eve_mirr= EDBM_GetMirrorVert(em, eve))) { - sel= BM_TestHFlag(eve, BM_ELEM_SELECT); - sel_mirr= BM_TestHFlag(eve_mirr, BM_ELEM_SELECT); + sel= BM_elem_flag_test(eve, BM_ELEM_SELECT); + sel_mirr= BM_elem_flag_test(eve_mirr, BM_ELEM_SELECT); if((sel || sel_mirr) && (eve != eve_mirr)) { dvert= CustomData_bmesh_get(&em->bm->vdata, eve->head.data, CD_MDEFORMVERT); @@ -1785,7 +1785,7 @@ static void vgroup_active_remove_verts(Object *ob, const int allverts, bDeformGr BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { dv= CustomData_bmesh_get(&em->bm->vdata, eve->head.data, CD_MDEFORMVERT); - if(dv && dv->dw && (allverts || BM_TestHFlag(eve, BM_ELEM_SELECT))) { + if(dv && dv->dw && (allverts || BM_elem_flag_test(eve, BM_ELEM_SELECT))) { MDeformWeight *dw = defvert_find_index(dv, def_nr); defvert_remove_group(dv, dw); /* dw can be NULL */ } @@ -1981,11 +1981,11 @@ static void vgroup_assign_verts(Object *ob, const float weight) BMVert *eve; if(!CustomData_has_layer(&em->bm->vdata, CD_MDEFORMVERT)) - BM_add_data_layer(em->bm, &em->bm->vdata, CD_MDEFORMVERT); + 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) { - if (BM_TestHFlag(eve, BM_ELEM_SELECT)) { + 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 */ dw= defvert_verify_index(dv, def_nr); diff --git a/source/blender/editors/render/render_shading.c b/source/blender/editors/render/render_shading.c index fb844de33c3..83b4dfef6c6 100644 --- a/source/blender/editors/render/render_shading.c +++ b/source/blender/editors/render/render_shading.c @@ -171,7 +171,7 @@ static int material_slot_assign_exec(bContext *C, wmOperator *UNUSED(op)) if(em) { BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if(BM_TestHFlag(efa, BM_ELEM_SELECT)) + if(BM_elem_flag_test(efa, BM_ELEM_SELECT)) efa->mat_nr= ob->actcol-1; } } diff --git a/source/blender/editors/sculpt_paint/sculpt_uv.c b/source/blender/editors/sculpt_paint/sculpt_uv.c index e89007b2480..ce07beae674 100644 --- a/source/blender/editors/sculpt_paint/sculpt_uv.c +++ b/source/blender/editors/sculpt_paint/sculpt_uv.c @@ -215,7 +215,7 @@ void HC_relaxation_iteration_uv(BMEditMesh *em, UvSculptData *sculptdata, float if(element->separate && element != sculptdata->uv[i].element) break; - l = BMIter_AtIndex(em->bm, BM_LOOPS_OF_FACE, element->face, element->tfindex); + l = BM_iter_at_index(em->bm, BM_LOOPS_OF_FACE, element->face, element->tfindex); luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV); copy_v2_v2(luv->uv, sculptdata->uv[i].uv); } @@ -279,7 +279,7 @@ static void laplacian_relaxation_iteration_uv(BMEditMesh *em, UvSculptData *scul if(element->separate && element != sculptdata->uv[i].element) break; - l = BMIter_AtIndex(em->bm, BM_LOOPS_OF_FACE, element->face, element->tfindex); + l = BM_iter_at_index(em->bm, BM_LOOPS_OF_FACE, element->face, element->tfindex); luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV); copy_v2_v2(luv->uv, sculptdata->uv[i].uv); } @@ -355,7 +355,7 @@ static void uv_sculpt_stroke_apply(bContext *C, wmOperator *op, wmEvent *event, if(element->separate && element != sculptdata->uv[i].element) break; - l = BMIter_AtIndex(em->bm, BM_LOOPS_OF_FACE, element->face, element->tfindex); + l = BM_iter_at_index(em->bm, BM_LOOPS_OF_FACE, element->face, element->tfindex); luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV); copy_v2_v2(luv->uv, sculptdata->uv[i].uv); } @@ -397,7 +397,7 @@ static void uv_sculpt_stroke_apply(bContext *C, wmOperator *op, wmEvent *event, if(element->separate && element != sculptdata->uv[uvindex].element) break; - l = BMIter_AtIndex(em->bm, BM_LOOPS_OF_FACE, element->face, element->tfindex); + l = BM_iter_at_index(em->bm, BM_LOOPS_OF_FACE, element->face, element->tfindex); luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV); copy_v2_v2(luv->uv, sculptdata->uv[uvindex].uv); } @@ -572,7 +572,7 @@ static UvSculptData *uv_sculpt_stroke_init(bContext *C, wmOperator *op, wmEvent } efa = element->face; - l = BMIter_AtIndex(em->bm, BM_LOOPS_OF_FACE, element->face, element->tfindex); + l = BM_iter_at_index(em->bm, BM_LOOPS_OF_FACE, element->face, element->tfindex); luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV); counter++; diff --git a/source/blender/editors/space_image/space_image.c b/source/blender/editors/space_image/space_image.c index b37a5811cb4..b03ae1aecd6 100644 --- a/source/blender/editors/space_image/space_image.c +++ b/source/blender/editors/space_image/space_image.c @@ -591,7 +591,7 @@ static void image_refresh(const bContext *C, ScrArea *UNUSED(sa)) if(scene_use_new_shading_nodes(scene)) { /* new shading system, get image from material */ - BMFace *efa = BM_get_actFace(em->bm, sloppy); + BMFace *efa = BM_active_face_get(em->bm, sloppy); if(efa) { Image *node_ima; diff --git a/source/blender/editors/space_view3d/drawmesh.c b/source/blender/editors/space_view3d/drawmesh.c index 4734d54497d..09a4a9eb749 100644 --- a/source/blender/editors/space_view3d/drawmesh.c +++ b/source/blender/editors/space_view3d/drawmesh.c @@ -549,7 +549,7 @@ static int draw_em_tf_mapped__set_draw(void *userData, int index) BMEditMesh *em = data->em; BMFace *efa= EDBM_get_face_for_index(em, index); - if (efa==NULL || BM_TestHFlag(efa, BM_ELEM_HIDDEN)) { + if (efa==NULL || BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) { return 0; } else { @@ -911,7 +911,7 @@ static int tex_mat_set_face_editmesh_cb(void *userData, int index) Mesh *me = (Mesh*)data->me; BMFace *efa= EDBM_get_face_for_index(me->edit_btmesh, index); - return !BM_TestHFlag(efa, BM_ELEM_HIDDEN); + return !BM_elem_flag_test(efa, BM_ELEM_HIDDEN); } void draw_mesh_textured(Scene *scene, View3D *v3d, RegionView3D *rv3d, Object *ob, DerivedMesh *dm, int draw_flags) diff --git a/source/blender/editors/space_view3d/drawobject.c b/source/blender/editors/space_view3d/drawobject.c index 226073c2cf9..b985f441f48 100644 --- a/source/blender/editors/space_view3d/drawobject.c +++ b/source/blender/editors/space_view3d/drawobject.c @@ -2006,7 +2006,7 @@ static void mesh_foreachScreenVert__mapFunc(void *userData, int index, float *co foreachScreenVert_userData *data = userData; BMVert *eve = EDBM_get_vert_for_index(data->vc.em, index); - if (!BM_TestHFlag(eve, BM_ELEM_HIDDEN)) { + if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) { short s[2]= {IS_CLIPPED, 0}; if (data->clipVerts != V3D_CLIP_TEST_OFF) { @@ -2084,7 +2084,7 @@ static void mesh_foreachScreenEdge__mapFunc(void *userData, int index, float *v0 foreachScreenEdge_userData *data = userData; BMEdge *eed = EDBM_get_edge_for_index(data->vc.em, index); - if (!BM_TestHFlag(eed, BM_ELEM_HIDDEN)) { + if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) { short s[2][2]; if (data->clipVerts == V3D_CLIP_TEST_RV3D_CLIPPING) { @@ -2141,7 +2141,7 @@ static void mesh_foreachScreenFace__mapFunc(void *userData, int index, float *ce foreachScreenFace_userData *data = userData; BMFace *efa = EDBM_get_face_for_index(data->vc.em, index); - if (efa && !BM_TestHFlag(efa, BM_ELEM_HIDDEN)) { + if (efa && !BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) { float cent2[3]; short s[2]; @@ -2244,7 +2244,7 @@ static void draw_dm_face_normals__mapFunc(void *userData, int index, float *cent drawDMNormal_userData *data = userData; BMFace *efa = EDBM_get_face_for_index(data->em, index); - if (!BM_TestHFlag(efa, BM_ELEM_HIDDEN)) { + if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) { glVertex3fv(cent); glVertex3f(cent[0] + no[0] * data->normalsize, cent[1] + no[1] * data->normalsize, @@ -2268,7 +2268,7 @@ static void draw_dm_face_centers__mapFunc(void *userData, int index, float *cent BMFace *efa = EDBM_get_face_for_index(((void **)userData)[0], index); int sel = *(((int **)userData)[1]); - if (efa && !BM_TestHFlag(efa, BM_ELEM_HIDDEN) && BM_TestHFlag(efa, BM_ELEM_SELECT)==sel) { + if (efa && !BM_elem_flag_test(efa, BM_ELEM_HIDDEN) && BM_elem_flag_test(efa, BM_ELEM_SELECT)==sel) { bglVertex3fv(cent); } } @@ -2286,7 +2286,7 @@ static void draw_dm_vert_normals__mapFunc(void *userData, int index, float *co, drawDMNormal_userData *data = userData; BMVert *eve = EDBM_get_vert_for_index(data->em, index); - if (!BM_TestHFlag(eve, BM_ELEM_HIDDEN)) { + if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) { glVertex3fv(co); if (no_f) { @@ -2319,7 +2319,7 @@ static void draw_dm_verts__mapFunc(void *userData, int index, float *co, float * drawDMVerts_userData * data = userData; BMVert *eve = EDBM_get_vert_for_index(data->em, index); - if (!BM_TestHFlag(eve, BM_ELEM_HIDDEN) && BM_TestHFlag(eve, BM_ELEM_SELECT)==data->sel) { + if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN) && BM_elem_flag_test(eve, BM_ELEM_SELECT)==data->sel) { /* draw active larger - need to stop/start point drawing for this :/ */ if (eve==data->eve_act) { float size = UI_GetThemeValuef(TH_VERTEX_SIZE); @@ -2363,11 +2363,11 @@ static int draw_dm_edges_sel__setDrawOptions(void *userData, int index) eed = EDBM_get_edge_for_index(data->em, index); - if (!BM_TestHFlag(eed, BM_ELEM_HIDDEN)) { + if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) { if (eed==data->eed_act) { glColor4ubv(data->actCol); } else { - if (BM_TestHFlag(eed, BM_ELEM_SELECT)) { + if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) { col = data->selCol; } else { col = data->baseCol; @@ -2398,7 +2398,7 @@ static void draw_dm_edges_sel(BMEditMesh *em, DerivedMesh *dm, unsigned char *ba /* Draw edges */ static int draw_dm_edges__setDrawOptions(void *userData, int index) { - return !BM_TestHFlag(EDBM_get_edge_for_index(userData, index), BM_ELEM_HIDDEN); + return !BM_elem_flag_test(EDBM_get_edge_for_index(userData, index), BM_ELEM_HIDDEN); } static void draw_dm_edges(BMEditMesh *em, DerivedMesh *dm) { @@ -2408,14 +2408,14 @@ static void draw_dm_edges(BMEditMesh *em, DerivedMesh *dm) /* Draw edges with color interpolated based on selection */ static int draw_dm_edges_sel_interp__setDrawOptions(void *userData, int index) { - return !BM_TestHFlag(EDBM_get_edge_for_index(((void**)userData)[0], index), BM_ELEM_HIDDEN); + return !BM_elem_flag_test(EDBM_get_edge_for_index(((void**)userData)[0], index), BM_ELEM_HIDDEN); } static void draw_dm_edges_sel_interp__setDrawInterpOptions(void *userData, int index, float t) { BMEdge *eed = EDBM_get_edge_for_index(((void**)userData)[0], index); unsigned char **cols = userData; - unsigned char *col0 = cols[(BM_TestHFlag(eed->v1, BM_ELEM_SELECT))?2:1]; - unsigned char *col1 = cols[(BM_TestHFlag(eed->v2, BM_ELEM_SELECT))?2:1]; + unsigned char *col0 = cols[(BM_elem_flag_test(eed->v1, BM_ELEM_SELECT))?2:1]; + unsigned char *col1 = cols[(BM_elem_flag_test(eed->v2, BM_ELEM_SELECT))?2:1]; glColor4ub( col0[0] + (col1[0]-col0[0])*t, col0[1] + (col1[1]-col0[1])*t, @@ -2435,7 +2435,7 @@ static int draw_dm_edges_seams__setDrawOptions(void *userData, int index) { BMEdge *eed = EDBM_get_edge_for_index(userData, index); - return !BM_TestHFlag(eed, BM_ELEM_HIDDEN) && BM_TestHFlag(eed, BM_ELEM_SEAM); + return !BM_elem_flag_test(eed, BM_ELEM_HIDDEN) && BM_elem_flag_test(eed, BM_ELEM_SEAM); } static void draw_dm_edges_seams(BMEditMesh *em, DerivedMesh *dm) @@ -2448,7 +2448,7 @@ static int draw_dm_edges_sharp__setDrawOptions(void *userData, int index) { BMEdge *eed = EDBM_get_edge_for_index(userData, index); - return !BM_TestHFlag(eed, BM_ELEM_HIDDEN) && BM_TestHFlag(eed, BM_ELEM_SHARP); + return !BM_elem_flag_test(eed, BM_ELEM_HIDDEN) && BM_elem_flag_test(eed, BM_ELEM_SHARP); } static void draw_dm_edges_sharp(BMEditMesh *em, DerivedMesh *dm) { @@ -2467,12 +2467,12 @@ static int draw_dm_faces_sel__setDrawOptions(void *userData, int index, int *UNU if (!efa) return 0; - if (!BM_TestHFlag(efa, BM_ELEM_HIDDEN)) { + if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) { if (efa == data->efa_act) { glColor4ubv(data->cols[2]); return 2; /* stipple */ } else { - col = data->cols[BM_TestHFlag(efa, BM_ELEM_SELECT)?1:0]; + col = data->cols[BM_elem_flag_test(efa, BM_ELEM_SELECT)?1:0]; if (col[3]==0) return 0; glColor4ubv(col); return 1; @@ -2502,8 +2502,8 @@ static int draw_dm_faces_sel__compareDrawOptions(void *userData, int index, int if(efa == data->efa_act || next_efa == data->efa_act) return 0; - col = data->cols[BM_TestHFlag(efa, BM_ELEM_SELECT)?1:0]; - next_col = data->cols[BM_TestHFlag(next_efa, BM_ELEM_SELECT)?1:0]; + col = data->cols[BM_elem_flag_test(efa, BM_ELEM_SELECT)?1:0]; + next_col = data->cols[BM_elem_flag_test(next_efa, BM_ELEM_SELECT)?1:0]; if(col[3]==0 || next_col[3]==0) return 0; @@ -2536,7 +2536,7 @@ static int draw_dm_creases__setDrawOptions(void *userData, int index) if (!crease) return 0; - if (!BM_TestHFlag(eed, BM_ELEM_HIDDEN) && *crease!=0.0f) { + if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN) && *crease!=0.0f) { UI_ThemeColorBlend(TH_WIRE, TH_EDGE_CREASE, *crease); return 1; } else { @@ -2559,7 +2559,7 @@ static int draw_dm_bweights__setDrawOptions(void *userData, int index) if (!bweight) return 0; - if (!BM_TestHFlag(eed, BM_ELEM_HIDDEN) && *bweight!=0.0f) { + if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN) && *bweight!=0.0f) { UI_ThemeColorBlend(TH_WIRE, TH_EDGE_SELECT, *bweight); return 1; } else { @@ -2575,7 +2575,7 @@ static void draw_dm_bweights__mapFunc(void *userData, int index, float *co, floa if (!bweight) return; - if (!BM_TestHFlag(eve, BM_ELEM_HIDDEN) && *bweight!=0.0f) { + if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN) && *bweight!=0.0f) { UI_ThemeColorBlend(TH_VERTEX, TH_VERTEX_SELECT, *bweight); bglVertex3fv(co); } @@ -2753,11 +2753,11 @@ static void draw_em_measure_stats(View3D *v3d, Object *ob, BMEditMesh *em, UnitS UI_GetThemeColor3ubv(TH_DRAWEXTRA_EDGELEN, col); - eed = BMIter_New(&iter, em->bm, BM_EDGES_OF_MESH, NULL); - for(; eed; eed=BMIter_Step(&iter)) { + eed = BM_iter_new(&iter, em->bm, BM_EDGES_OF_MESH, NULL); + for(; eed; eed=BM_iter_step(&iter)) { /* draw selected edges, or edges next to selected verts while draging */ - if(BM_TestHFlag(eed, BM_ELEM_SELECT) || - (do_moving && (BM_TestHFlag(eed->v1, BM_ELEM_SELECT) || BM_TestHFlag(eed->v2, BM_ELEM_SELECT) ))) { + if(BM_elem_flag_test(eed, BM_ELEM_SELECT) || + (do_moving && (BM_elem_flag_test(eed->v1, BM_ELEM_SELECT) || BM_elem_flag_test(eed->v2, BM_ELEM_SELECT) ))) { copy_v3_v3(v1, eed->v1->co); copy_v3_v3(v2, eed->v2->co); @@ -2783,13 +2783,13 @@ static void draw_em_measure_stats(View3D *v3d, Object *ob, BMEditMesh *em, UnitS } if(me->drawflag & ME_DRAWEXTRA_FACEAREA) { - /* would be nice to use BM_Compute_Face_Area, but that is for 2d faces + /* would be nice to use BM_face_area_calc, but that is for 2d faces so instead add up tessalation triangle areas */ BMFace *f; int n; #define DRAW_EM_MEASURE_STATS_FACEAREA() \ - if (BM_TestHFlag(f, BM_ELEM_SELECT)) { \ + if (BM_elem_flag_test(f, BM_ELEM_SELECT)) { \ mul_v3_fl(vmid, 1.0/n); \ if(unit->system) \ bUnit_AsString(numstr, sizeof(numstr), area*unit->scale_length, \ @@ -2842,15 +2842,15 @@ static void draw_em_measure_stats(View3D *v3d, Object *ob, BMEditMesh *em, UnitS UI_GetThemeColor3ubv(TH_DRAWEXTRA_FACEANG, col); - for(efa = BMIter_New(&iter, em->bm, BM_FACES_OF_MESH, NULL); - efa; efa=BMIter_Step(&iter)) { + for(efa = BM_iter_new(&iter, em->bm, BM_FACES_OF_MESH, NULL); + efa; efa=BM_iter_step(&iter)) { BMIter liter; BMLoop *loop; - BM_Compute_Face_CenterBounds(em->bm, efa, vmid); + BM_face_center_bounds_calc(em->bm, efa, vmid); - for(loop = BMIter_New(&liter, em->bm, BM_LOOPS_OF_FACE, efa); - loop; loop = BMIter_Step(&liter)) { + for(loop = BM_iter_new(&liter, em->bm, BM_LOOPS_OF_FACE, efa); + loop; loop = BM_iter_step(&liter)) { float v1[3], v2[3], v3[3]; @@ -2864,8 +2864,8 @@ static void draw_em_measure_stats(View3D *v3d, Object *ob, BMEditMesh *em, UnitS mul_mat3_m4_v3(ob->obmat, v3); } - if ( (BM_TestHFlag(efa, BM_ELEM_SELECT)) || - (do_moving && BM_TestHFlag(loop->v, BM_ELEM_SELECT))) + if ( (BM_elem_flag_test(efa, BM_ELEM_SELECT)) || + (do_moving && BM_elem_flag_test(loop->v, BM_ELEM_SELECT))) { BLI_snprintf(numstr, sizeof(numstr), "%.3g", RAD2DEGF(angle_v3v3v3(v1, v2, v3))); interp_v3_v3v3(fvec, vmid, v2, 0.8f); @@ -2894,7 +2894,7 @@ static void draw_em_indices(BMEditMesh *em) if (em->selectmode & SCE_SELECT_VERTEX) { UI_GetThemeColor3ubv(TH_DRAWEXTRA_FACEANG, col); BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) { - if (BM_TestHFlag(v, BM_ELEM_SELECT)) { + if (BM_elem_flag_test(v, BM_ELEM_SELECT)) { sprintf(numstr, "%d", i); view3d_cached_text_draw_add(v->co, numstr, 0, V3D_CACHE_TEXT_ASCII, col); } @@ -2906,7 +2906,7 @@ static void draw_em_indices(BMEditMesh *em) i= 0; UI_GetThemeColor3ubv(TH_DRAWEXTRA_EDGELEN, col); BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) { - if (BM_TestHFlag(e, BM_ELEM_SELECT)) { + if (BM_elem_flag_test(e, BM_ELEM_SELECT)) { sprintf(numstr, "%d", i); mid_v3_v3v3(pos, e->v1->co, e->v2->co); view3d_cached_text_draw_add(pos, numstr, 0, V3D_CACHE_TEXT_ASCII, col); @@ -2919,8 +2919,8 @@ static void draw_em_indices(BMEditMesh *em) i= 0; UI_GetThemeColor3ubv(TH_DRAWEXTRA_FACEAREA, col); BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) { - if (BM_TestHFlag(f, BM_ELEM_SELECT)) { - BM_Compute_Face_CenterMean(bm, f, pos); + if (BM_elem_flag_test(f, BM_ELEM_SELECT)) { + BM_face_center_mean_calc(bm, f, pos); sprintf(numstr, "%d", i); view3d_cached_text_draw_add(pos, numstr, 0, V3D_CACHE_TEXT_ASCII, col); } @@ -2933,7 +2933,7 @@ static int draw_em_fancy__setFaceOpts(void *userData, int index, int *UNUSED(dra { BMFace *efa = EDBM_get_face_for_index(userData, index); - if (efa && !BM_TestHFlag(efa, BM_ELEM_HIDDEN)) { + if (efa && !BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) { GPU_enable_material(efa->mat_nr+1, NULL); return 1; } @@ -2945,7 +2945,7 @@ static int draw_em_fancy__setGLSLFaceOpts(void *userData, int index) { BMFace *efa = EDBM_get_face_for_index(userData, index); - return !BM_TestHFlag(efa, BM_ELEM_HIDDEN); + return !BM_elem_flag_test(efa, BM_ELEM_HIDDEN); } static void draw_em_fancy(Scene *scene, View3D *v3d, RegionView3D *rv3d, @@ -2953,7 +2953,7 @@ static void draw_em_fancy(Scene *scene, View3D *v3d, RegionView3D *rv3d, { Mesh *me = ob->data; - BMFace *efa_act = BM_get_actFace(em->bm, FALSE); /* annoying but active faces is stored differently */ + BMFace *efa_act = BM_active_face_get(em->bm, FALSE); /* annoying but active faces is stored differently */ BMEdge *eed_act = NULL; BMVert *eve_act = NULL; @@ -7050,7 +7050,7 @@ static void bbs_mesh_verts__mapFunc(void *userData, int index, float *co, float int offset = (intptr_t) ptrs[0]; BMVert *eve = EDBM_get_vert_for_index(ptrs[1], index); - if (!BM_TestHFlag(eve, BM_ELEM_HIDDEN)) { + if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) { WM_set_framebuffer_index_color(offset+index); bglVertex3fv(co); } @@ -7072,7 +7072,7 @@ static int bbs_mesh_wire__setDrawOptions(void *userData, int index) int offset = (intptr_t) ptrs[0]; BMEdge *eed = EDBM_get_edge_for_index(ptrs[1], index); - if (!BM_TestHFlag(eed, BM_ELEM_HIDDEN)) { + if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) { WM_set_framebuffer_index_color(offset+index); return 1; } else { @@ -7089,7 +7089,7 @@ static int bbs_mesh_solid__setSolidDrawOptions(void *userData, int index, int *U { BMFace *efa = EDBM_get_face_for_index(((void**)userData)[0], index); - if (efa && !BM_TestHFlag(efa, BM_ELEM_HIDDEN)) { + if (efa && !BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) { if (((void**)userData)[1]) { WM_set_framebuffer_index_color(index+1); } @@ -7103,7 +7103,7 @@ static void bbs_mesh_solid__drawCenter(void *userData, int index, float *cent, f { BMFace *efa = EDBM_get_face_for_index(((void**)userData)[0], index); - if (!BM_TestHFlag(efa, BM_ELEM_HIDDEN)) { + if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) { WM_set_framebuffer_index_color(index+1); bglVertex3fv(cent); diff --git a/source/blender/editors/space_view3d/view3d_buttons.c b/source/blender/editors/space_view3d/view3d_buttons.c index d2ea10de2ba..5d587bcd075 100644 --- a/source/blender/editors/space_view3d/view3d_buttons.c +++ b/source/blender/editors/space_view3d/view3d_buttons.c @@ -161,7 +161,7 @@ static void v3d_editvertex_buts(uiLayout *layout, View3D *v3d, Object *ob, float BMIter iter; BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) { - if(BM_TestHFlag(eve, BM_ELEM_SELECT)) { + if(BM_elem_flag_test(eve, BM_ELEM_SELECT)) { evedef= eve; tot++; add_v3_v3(median, eve->co); @@ -169,7 +169,7 @@ static void v3d_editvertex_buts(uiLayout *layout, View3D *v3d, Object *ob, float } BM_ITER(eed, &iter, bm, BM_EDGES_OF_MESH, NULL) { - if(BM_TestHFlag(eed, BM_ELEM_SELECT)) { + if(BM_elem_flag_test(eed, BM_ELEM_SELECT)) { float *f; totedge++; @@ -419,7 +419,7 @@ static void v3d_editvertex_buts(uiLayout *layout, View3D *v3d, Object *ob, float if(len_v3(median) > 0.000001f) { BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if(BM_TestHFlag(eve, BM_ELEM_SELECT)) { + if(BM_elem_flag_test(eve, BM_ELEM_SELECT)) { add_v3_v3(eve->co, median); } } @@ -435,7 +435,7 @@ static void v3d_editvertex_buts(uiLayout *layout, View3D *v3d, Object *ob, float /* simple case */ BM_ITER(eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) { - if(BM_TestHFlag(eed, BM_ELEM_SELECT)) { + if(BM_elem_flag_test(eed, BM_ELEM_SELECT)) { float *crease = CustomData_bmesh_get(&em->bm->edata, eed->head.data, CD_CREASE); if (!crease) break; @@ -457,7 +457,7 @@ static void v3d_editvertex_buts(uiLayout *layout, View3D *v3d, Object *ob, float const float sca= median_new / median_orig; BM_ITER(eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) { - if(BM_TestHFlag(eed, BM_ELEM_SELECT) && !BM_TestHFlag(eed, BM_ELEM_HIDDEN)) { + if(BM_elem_flag_test(eed, BM_ELEM_SELECT) && !BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) { float *crease = CustomData_bmesh_get(&em->bm->edata, eed->head.data, CD_CREASE); if (!crease) break; @@ -472,7 +472,7 @@ static void v3d_editvertex_buts(uiLayout *layout, View3D *v3d, Object *ob, float const float sca= (1.0f - median_new) / (1.0f - median_orig); BM_ITER(eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) { - if(BM_TestHFlag(eed, BM_ELEM_SELECT) && !BM_TestHFlag(eed, BM_ELEM_HIDDEN)) { + if(BM_elem_flag_test(eed, BM_ELEM_SELECT) && !BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) { float *crease = CustomData_bmesh_get(&em->bm->edata, eed->head.data, CD_CREASE); if (!crease) break; @@ -688,7 +688,7 @@ static void vgroup_copy_active_to_sel(Object *ob) int index= 0; BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if(BM_TestHFlag(eve, BM_ELEM_SELECT) && eve != eve_act) { + 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) { defvert_copy(dvert, dvert_act); @@ -731,9 +731,9 @@ static void vgroup_copy_active_to_sel_single(Object *ob, const int def_nr) weight_act= dw->weight; - eve = BMIter_New(&iter, em->bm, BM_VERTS_OF_MESH, NULL); - for (index=0; eve; eve=BMIter_Step(&iter), index++) { - if(BM_TestHFlag(eve, BM_ELEM_SELECT) && eve != eve_act) { + eve = BM_iter_new(&iter, em->bm, BM_VERTS_OF_MESH, NULL); + for (index=0; eve; eve=BM_iter_step(&iter), index++) { + if(BM_elem_flag_test(eve, BM_ELEM_SELECT) && eve != eve_act) { dv= CustomData_bmesh_get(&em->bm->vdata, eve->head.data, CD_MDEFORMVERT); dw= defvert_find_index(dv, def_nr); if (dw) { diff --git a/source/blender/editors/space_view3d/view3d_select.c b/source/blender/editors/space_view3d/view3d_select.c index d0a4ac14c20..989feaedb40 100644 --- a/source/blender/editors/space_view3d/view3d_select.c +++ b/source/blender/editors/space_view3d/view3d_select.c @@ -171,11 +171,11 @@ static void EDBM_backbuf_checkAndSelectVerts(BMEditMesh *em, int select) BMIter iter; int index= bm_wireoffs; - eve = BMIter_New(&iter, em->bm, BM_VERTS_OF_MESH, NULL); - for ( ; eve; eve=BMIter_Step(&iter), index++) { - if(!BM_TestHFlag(eve, BM_ELEM_HIDDEN)) { + eve = BM_iter_new(&iter, em->bm, BM_VERTS_OF_MESH, NULL); + for ( ; eve; eve=BM_iter_step(&iter), index++) { + if(!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) { if(EDBM_check_backbuf(index)) { - BM_Select_Vert(em->bm, eve, select); + BM_vert_select(em->bm, eve, select); } } } @@ -187,11 +187,11 @@ static void EDBM_backbuf_checkAndSelectEdges(BMEditMesh *em, int select) BMIter iter; int index= bm_solidoffs; - eed = BMIter_New(&iter, em->bm, BM_EDGES_OF_MESH, NULL); - for ( ; eed; eed=BMIter_Step(&iter), index++) { - if(!BM_TestHFlag(eed, BM_ELEM_HIDDEN)) { + eed = BM_iter_new(&iter, em->bm, BM_EDGES_OF_MESH, NULL); + for ( ; eed; eed=BM_iter_step(&iter), index++) { + if(!BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) { if(EDBM_check_backbuf(index)) { - BM_Select_Edge(em->bm, eed, select); + BM_edge_select(em->bm, eed, select); } } } @@ -203,11 +203,11 @@ static void EDBM_backbuf_checkAndSelectFaces(BMEditMesh *em, int select) BMIter iter; int index= 1; - efa = BMIter_New(&iter, em->bm, BM_FACES_OF_MESH, NULL); - for ( ; efa; efa=BMIter_Step(&iter), index++) { - if(!BM_TestHFlag(efa, BM_ELEM_HIDDEN)) { + efa = BM_iter_new(&iter, em->bm, BM_FACES_OF_MESH, NULL); + for ( ; efa; efa=BM_iter_step(&iter), index++) { + if(!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) { if(EDBM_check_backbuf(index)) { - BM_Select_Face(em->bm, efa, select); + BM_face_select(em->bm, efa, select); } } } @@ -473,7 +473,7 @@ static void do_lasso_select_mesh__doSelectVert(void *userData, BMVert *eve, int LassoSelectUserData *data = userData; if (BLI_in_rcti(data->rect, x, y) && lasso_inside(data->mcords, data->moves, x, y)) { - BM_Select(data->vc->em->bm, eve, data->select); + BM_elem_select_set(data->vc->em->bm, eve, data->select); } } static void do_lasso_select_mesh__doSelectEdge(void *userData, BMEdge *eed, int x0, int y0, int x1, int y1, int index) @@ -485,12 +485,12 @@ static void do_lasso_select_mesh__doSelectEdge(void *userData, BMEdge *eed, int if ( edge_fully_inside_rect(data->rect, x0, y0, x1, y1) && lasso_inside(data->mcords, data->moves, x0, y0) && lasso_inside(data->mcords, data->moves, x1, y1)) { - BM_Select(data->vc->em->bm, eed, data->select); + BM_elem_select_set(data->vc->em->bm, eed, data->select); data->done = 1; } } else { if (lasso_inside_edge(data->mcords, data->moves, x0, y0, x1, y1)) { - BM_Select(data->vc->em->bm, eed, data->select); + BM_elem_select_set(data->vc->em->bm, eed, data->select); } } } @@ -500,7 +500,7 @@ static void do_lasso_select_mesh__doSelectFace(void *userData, BMFace *efa, int LassoSelectUserData *data = userData; if (BLI_in_rcti(data->rect, x, y) && lasso_inside(data->mcords, data->moves, x, y)) { - BM_Select(data->vc->em->bm, efa, data->select); + BM_elem_select_set(data->vc->em->bm, efa, data->select); } } @@ -1741,7 +1741,7 @@ static void do_mesh_box_select__doSelectVert(void *userData, BMVert *eve, int x, BoxSelectUserData *data = userData; if (BLI_in_rcti(data->rect, x, y)) { - BM_Select(data->vc->em->bm, eve, data->select); + BM_elem_select_set(data->vc->em->bm, eve, data->select); } } static void do_mesh_box_select__doSelectEdge(void *userData, BMEdge *eed, int x0, int y0, int x1, int y1, int index) @@ -1751,12 +1751,12 @@ static void do_mesh_box_select__doSelectEdge(void *userData, BMEdge *eed, int x0 if(EDBM_check_backbuf(bm_solidoffs+index)) { if (data->pass==0) { if (edge_fully_inside_rect(data->rect, x0, y0, x1, y1)) { - BM_Select(data->vc->em->bm, eed, data->select); + BM_elem_select_set(data->vc->em->bm, eed, data->select); data->done = 1; } } else { if (edge_inside_rect(data->rect, x0, y0, x1, y1)) { - BM_Select(data->vc->em->bm, eed, data->select); + BM_elem_select_set(data->vc->em->bm, eed, data->select); } } } @@ -1766,7 +1766,7 @@ static void do_mesh_box_select__doSelectFace(void *userData, BMFace *efa, int x, BoxSelectUserData *data = userData; if (BLI_in_rcti(data->rect, x, y)) { - BM_Select(data->vc->em->bm, efa, data->select); + BM_elem_select_set(data->vc->em->bm, efa, data->select); } } static int do_mesh_box_select(ViewContext *vc, rcti *rect, int select, int extend) @@ -2284,7 +2284,7 @@ static void mesh_circle_doSelectVert(void *userData, BMVert *eve, int x, int y, float r = sqrt(mx*mx + my*my); if (r<=data->radius) { - BM_Select(data->vc->em->bm, eve, data->select); + BM_elem_select_set(data->vc->em->bm, eve, data->select); } } static void mesh_circle_doSelectEdge(void *userData, BMEdge *eed, int x0, int y0, int x1, int y1, int UNUSED(index)) @@ -2292,7 +2292,7 @@ static void mesh_circle_doSelectEdge(void *userData, BMEdge *eed, int x0, int y0 CircleSelectUserData *data = userData; if (edge_inside_circle(data->mval[0], data->mval[1], (short) data->radius, x0, y0, x1, y1)) { - BM_Select(data->vc->em->bm, eed, data->select); + BM_elem_select_set(data->vc->em->bm, eed, data->select); } } static void mesh_circle_doSelectFace(void *userData, BMFace *efa, int x, int y, int UNUSED(index)) @@ -2302,7 +2302,7 @@ static void mesh_circle_doSelectFace(void *userData, BMFace *efa, int x, int y, float r = sqrt(mx*mx + my*my); if (r<=data->radius) { - BM_Select(data->vc->em->bm, efa, data->select); + BM_elem_select_set(data->vc->em->bm, efa, data->select); } } diff --git a/source/blender/editors/space_view3d/view3d_snap.c b/source/blender/editors/space_view3d/view3d_snap.c index de15ea99256..087ed8380d6 100644 --- a/source/blender/editors/space_view3d/view3d_snap.c +++ b/source/blender/editors/space_view3d/view3d_snap.c @@ -102,7 +102,7 @@ static void special_transvert_update(Object *obedit) if(obedit->type==OB_MESH) { Mesh *me= obedit->data; - BM_Compute_Normals(me->edit_btmesh->bm); // does face centers too + BM_mesh_normals_update(me->edit_btmesh->bm); // does face centers too } else if (ELEM(obedit->type, OB_CURVE, OB_SURF)) { Curve *cu= obedit->data; @@ -200,9 +200,9 @@ static void set_mapped_co(void *vuserdata, int index, float *co, float *UNUSED(n TransVert *tv = userdata[1]; BMVert *eve = EDBM_get_vert_for_index(em, index); - if (BM_GetIndex(eve) != -1 && !(tv[BM_GetIndex(eve)].flag & TX_VERT_USE_MAPLOC)) { - copy_v3_v3(tv[BM_GetIndex(eve)].maploc, co); - tv[BM_GetIndex(eve)].flag |= TX_VERT_USE_MAPLOC; + if (BM_elem_index_get(eve) != -1 && !(tv[BM_elem_index_get(eve)].flag & TX_VERT_USE_MAPLOC)) { + copy_v3_v3(tv[BM_elem_index_get(eve)].maploc, co); + tv[BM_elem_index_get(eve)].flag |= TX_VERT_USE_MAPLOC; } } @@ -242,48 +242,48 @@ static void make_trans_verts(Object *obedit, float *min, float *max, int mode) tottrans= 0; if(em->selectmode & SCE_SELECT_VERTEX) { BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) { - if(!BM_TestHFlag(eve, BM_ELEM_HIDDEN) && BM_TestHFlag(eve, BM_ELEM_SELECT)) { - BM_SetIndex(eve, 1); /* set_dirty! */ + 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++; } - else BM_SetIndex(eve, 0); /* set_dirty! */ + else BM_elem_index_set(eve, 0); /* set_dirty! */ } } else if(em->selectmode & SCE_SELECT_EDGE) { BMEdge *eed; BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) - BM_SetIndex(eve, 0); /* set_dirty! */ + BM_elem_index_set(eve, 0); /* set_dirty! */ BM_ITER(eed, &iter, bm, BM_EDGES_OF_MESH, NULL) { - if(!BM_TestHFlag(eed, BM_ELEM_HIDDEN) && BM_TestHFlag(eed, BM_ELEM_SELECT)) { - BM_SetIndex(eed->v1, 1); /* set_dirty! */ - BM_SetIndex(eed->v2, 1); /* set_dirty! */ + 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) - if(BM_GetIndex(eve)) tottrans++; + if(BM_elem_index_get(eve)) tottrans++; } else { BMFace *efa; BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) - BM_SetIndex(eve, 0); /* set_dirty! */ + BM_elem_index_set(eve, 0); /* set_dirty! */ BM_ITER(efa, &iter, bm, BM_FACES_OF_MESH, NULL) { - if(!BM_TestHFlag(efa, BM_ELEM_HIDDEN) && BM_TestHFlag(efa, BM_ELEM_SELECT)) { + 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_SetIndex(l->v, 1); /* set_dirty! */ + BM_elem_index_set(l->v, 1); /* set_dirty! */ } } } BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) - if(BM_GetIndex(eve)) tottrans++; + if(BM_elem_index_get(eve)) tottrans++; } /* for any of the 3 loops above which all dirty the indicies */ bm->elem_index_dirty |= BM_VERT; @@ -294,16 +294,16 @@ static void make_trans_verts(Object *obedit, float *min, float *max, int mode) a = 0; BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) { - if(BM_GetIndex(eve)) { - BM_SetIndex(eve, a); /* set_dirty! */ + if(BM_elem_index_get(eve)) { + BM_elem_index_set(eve, a); /* set_dirty! */ copy_v3_v3(tv->oldloc, eve->co); tv->loc= eve->co; if(eve->no[0] != 0.0f || eve->no[1] != 0.0f ||eve->no[2] != 0.0f) tv->nor= eve->no; // note this is a hackish signal (ton) - tv->flag= BM_GetIndex(eve) & SELECT; + tv->flag= BM_elem_index_get(eve) & SELECT; tv++; a++; - } else BM_SetIndex(eve, -1); /* set_dirty! */ + } else BM_elem_index_set(eve, -1); /* set_dirty! */ } /* set dirty already, above */ diff --git a/source/blender/editors/transform/transform.c b/source/blender/editors/transform/transform.c index b15085efd75..82d6672e54d 100644 --- a/source/blender/editors/transform/transform.c +++ b/source/blender/editors/transform/transform.c @@ -4294,7 +4294,7 @@ static BMEdge *get_other_edge(BMesh *bm, BMVert *v, BMEdge *e) BMEdge *e2; BM_ITER(e2, &iter, bm, BM_EDGES_OF_VERT, v) { - if (BM_TestHFlag(e2, BM_ELEM_SELECT) && e2 != e) + if (BM_elem_flag_test(e2, BM_ELEM_SELECT) && e2 != e) return e2; } @@ -4310,7 +4310,7 @@ static BMLoop *get_next_loop(BMesh *UNUSED(bm), BMVert *v, BMLoop *l, firstl = l; do { - l = BM_OtherFaceLoop(l->e, l->f, v); + l = BM_face_other_loop(l->e, l->f, v); if (l->radial_next == l) return NULL; @@ -4320,8 +4320,8 @@ static BMLoop *get_next_loop(BMesh *UNUSED(bm), BMVert *v, BMLoop *l, } else { float f1[3], f2[3], f3[3]; - sub_v3_v3v3(f1, BM_OtherEdgeVert(olde, v)->co, v->co); - sub_v3_v3v3(f2, BM_OtherEdgeVert(nexte, v)->co, v->co); + sub_v3_v3v3(f1, BM_edge_other_vert(olde, v)->co, v->co); + sub_v3_v3v3(f2, BM_edge_other_vert(nexte, v)->co, v->co); cross_v3_v3v3(f3, f1, l->f->no); cross_v3_v3v3(a, f2, l->f->no); @@ -4334,17 +4334,17 @@ static BMLoop *get_next_loop(BMesh *UNUSED(bm), BMVert *v, BMLoop *l, copy_v3_v3(vec, a); return l; } else { - sub_v3_v3v3(n, BM_OtherEdgeVert(l->e, v)->co, v->co); + sub_v3_v3v3(n, BM_edge_other_vert(l->e, v)->co, v->co); add_v3_v3v3(a, a, n); i += 1; } - if (BM_OtherFaceLoop(l->e, l->f, v)->e == nexte) { + if (BM_face_other_loop(l->e, l->f, v)->e == nexte) { if (i) mul_v3_fl(a, 1.0f / (float)i); copy_v3_v3(vec, a); - return BM_OtherFaceLoop(l->e, l->f, v); + return BM_face_other_loop(l->e, l->f, v); } l = l->radial_next; @@ -4392,10 +4392,10 @@ static int createSlideVerts(TransInfo *t) /*ensure valid selection*/ BM_ITER(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (BM_TestHFlag(v, BM_ELEM_SELECT)) { + if (BM_elem_flag_test(v, BM_ELEM_SELECT)) { numsel = 0; BM_ITER(e, &iter2, em->bm, BM_EDGES_OF_VERT, v) { - if (BM_TestHFlag(e, BM_ELEM_SELECT)) { + if (BM_elem_flag_test(e, BM_ELEM_SELECT)) { /*BMESH_TODO: this is probably very evil, set v->e to a selected edge*/ v->e = e; @@ -4411,21 +4411,21 @@ static int createSlideVerts(TransInfo *t) } BM_ITER(e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) { - if (BM_TestHFlag(e, BM_ELEM_SELECT)) { - if (BM_Edge_FaceCount(e) != 2) + if (BM_elem_flag_test(e, BM_ELEM_SELECT)) { + if (BM_edge_face_count(e) != 2) return 0; //can only handle exactly 2 faces around each edge } } j = 0; BM_ITER(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (BM_TestHFlag(v, BM_ELEM_SELECT)) { - BM_SetHFlag(v, BM_ELEM_TAG); + if (BM_elem_flag_test(v, BM_ELEM_SELECT)) { + BM_elem_flag_set(v, BM_ELEM_TAG); BLI_smallhash_insert(&table, (uintptr_t)v, SET_INT_IN_POINTER(j)); j += 1; } else { - BM_ClearHFlag(v, BM_ELEM_TAG); + BM_elem_flag_clear(v, BM_ELEM_TAG); } } @@ -4438,7 +4438,7 @@ static int createSlideVerts(TransInfo *t) while (1) { v = NULL; BM_ITER(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (BM_TestHFlag(v, BM_ELEM_TAG)) + if (BM_elem_flag_test(v, BM_ELEM_TAG)) break; } @@ -4465,24 +4465,24 @@ static int createSlideVerts(TransInfo *t) numsel += 1; - if (!BM_TestHFlag(BM_OtherEdgeVert(e, v), BM_ELEM_TAG)) + if (!BM_elem_flag_test(BM_edge_other_vert(e, v), BM_ELEM_TAG)) break; - v = BM_OtherEdgeVert(e, v); + v = BM_edge_other_vert(e, v); } while (e != first->e); - BM_ClearHFlag(v, BM_ELEM_TAG); + BM_elem_flag_clear(v, BM_ELEM_TAG); l1 = l2 = l = NULL; l1 = e->l; l2 = e->l->radial_next; - l = BM_OtherFaceLoop(l1->e, l1->f, v); - sub_v3_v3v3(vec, BM_OtherEdgeVert(l->e, v)->co, v->co); + l = BM_face_other_loop(l1->e, l1->f, v); + sub_v3_v3v3(vec, BM_edge_other_vert(l->e, v)->co, v->co); if (l2 != l1) { - l = BM_OtherFaceLoop(l2->e, l2->f, v); - sub_v3_v3v3(vec2, BM_OtherEdgeVert(l->e, v)->co, v->co); + l = BM_face_other_loop(l2->e, l2->f, v); + sub_v3_v3v3(vec2, BM_edge_other_vert(l->e, v)->co, v->co); } else { l2 = NULL; } @@ -4498,37 +4498,37 @@ static int createSlideVerts(TransInfo *t) if (l2) copy_v3_v3(sv->downvec, vec2); - l = BM_OtherFaceLoop(l1->e, l1->f, v); - sv->up = BM_OtherEdgeVert(l->e, v); + l = BM_face_other_loop(l1->e, l1->f, v); + sv->up = BM_edge_other_vert(l->e, v); if (l2) { - l = BM_OtherFaceLoop(l2->e, l2->f, v); - sv->down = BM_OtherEdgeVert(l->e, v); + l = BM_face_other_loop(l2->e, l2->f, v); + sv->down = BM_edge_other_vert(l->e, v); } - v2=v, v = BM_OtherEdgeVert(e, v); + v2=v, v = BM_edge_other_vert(e, v); e1 = e; e = get_other_edge(bm, v, e); if (!e) { - //v2=v, v = BM_OtherEdgeVert(l1->e, v); + //v2=v, v = BM_edge_other_vert(l1->e, v); sv = tempsv + j + 1; sv->v = v; sv->origvert = *v; - l = BM_OtherFaceLoop(l1->e, l1->f, v); - sv->up = BM_OtherEdgeVert(l->e, v); - sub_v3_v3v3(sv->upvec, BM_OtherEdgeVert(l->e, v)->co, v->co); + l = BM_face_other_loop(l1->e, l1->f, v); + sv->up = BM_edge_other_vert(l->e, v); + sub_v3_v3v3(sv->upvec, BM_edge_other_vert(l->e, v)->co, v->co); if (l2) { - l = BM_OtherFaceLoop(l2->e, l2->f, v); - sv->down = BM_OtherEdgeVert(l->e, v); - sub_v3_v3v3(sv->downvec, BM_OtherEdgeVert(l->e, v)->co, v->co); + l = BM_face_other_loop(l2->e, l2->f, v); + sv->down = BM_edge_other_vert(l->e, v); + sub_v3_v3v3(sv->downvec, BM_edge_other_vert(l->e, v)->co, v->co); } - BM_ClearHFlag(v, BM_ELEM_TAG); - BM_ClearHFlag(v2, BM_ELEM_TAG); + BM_elem_flag_clear(v, BM_ELEM_TAG); + BM_elem_flag_clear(v2, BM_ELEM_TAG); j += 2; break; @@ -4539,8 +4539,8 @@ static int createSlideVerts(TransInfo *t) j += 1; - BM_ClearHFlag(v, BM_ELEM_TAG); - BM_ClearHFlag(v2, BM_ELEM_TAG); + BM_elem_flag_clear(v, BM_ELEM_TAG); + BM_elem_flag_clear(v2, BM_ELEM_TAG); } while (e != first->e && l1); } @@ -4555,7 +4555,7 @@ static int createSlideVerts(TransInfo *t) zero_v3(lastvec); zero_v3(dir); ee = le = NULL; BM_ITER(e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) { - if (BM_TestHFlag(e, BM_ELEM_SELECT)) { + if (BM_elem_flag_test(e, BM_ELEM_SELECT)) { BMIter iter2; BMEdge *e2; float vec1[3], dis2, mval[2] = {t->mval[0], t->mval[1]}, d; @@ -4566,7 +4566,7 @@ static int createSlideVerts(TransInfo *t) for (i=0; i<2; i++) { v = i?e->v1:e->v2; BM_ITER(e2, &iter2, em->bm, BM_EDGES_OF_VERT, v) { - if (BM_TestHFlag(e2, BM_ELEM_SELECT)) + if (BM_elem_flag_test(e2, BM_ELEM_SELECT)) continue; if (!BMBVH_EdgeVisible(btree, e2, ar, v3d, t->obedit)) @@ -4613,15 +4613,15 @@ static int createSlideVerts(TransInfo *t) BM_ITER(f, &fiter, em->bm, BM_FACES_OF_VERT, tempsv->v) { if (!BLI_smallhash_haskey(&sld->origfaces, (uintptr_t)f)) { - BMFace *copyf = BM_Copy_Face(em->bm, f, 1, 1); + BMFace *copyf = BM_face_copy(em->bm, f, 1, 1); - BM_Select(em->bm, copyf, FALSE); - BM_SetHFlag(copyf, BM_ELEM_HIDDEN); + BM_elem_select_set(em->bm, copyf, FALSE); + BM_elem_flag_set(copyf, BM_ELEM_HIDDEN); BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, copyf) { - BM_Select(em->bm, l->v, FALSE); - BM_SetHFlag(l->v, BM_ELEM_HIDDEN); - BM_Select(em->bm, l->e, FALSE); - BM_SetHFlag(l->e, BM_ELEM_HIDDEN); + BM_elem_select_set(em->bm, l->v, FALSE); + BM_elem_flag_set(l->v, BM_ELEM_HIDDEN); + BM_elem_select_set(em->bm, l->e, FALSE); + BM_elem_flag_set(l->e, BM_ELEM_HIDDEN); } BLI_smallhash_insert(&sld->origfaces, (uintptr_t)f, copyf); @@ -4693,8 +4693,8 @@ void projectSVData(TransInfo *t, int final) /*the face attributes of the copied face will get copied over, so its necessary to save the selection and hidden state*/ - sel = BM_TestHFlag(f, BM_ELEM_SELECT); - hide = BM_TestHFlag(f, BM_ELEM_HIDDEN); + sel = BM_elem_flag_test(f, BM_ELEM_SELECT); + hide = BM_elem_flag_test(f, BM_ELEM_HIDDEN); copyf2 = BLI_smallhash_lookup(&sld->origfaces, (uintptr_t)f); @@ -4703,17 +4703,17 @@ void projectSVData(TransInfo *t, int final) copyf = copyf2; do_vdata = l2->v==tempsv->v; - if (BM_TestHFlag(l2->e, BM_ELEM_SELECT) || BM_TestHFlag(l2->prev->e, BM_ELEM_SELECT)) { + if (BM_elem_flag_test(l2->e, BM_ELEM_SELECT) || BM_elem_flag_test(l2->prev->e, BM_ELEM_SELECT)) { BMLoop *l3 = l2; do_vdata = 1; - if (!BM_TestHFlag(l2->e, BM_ELEM_SELECT)) + if (!BM_elem_flag_test(l2->e, BM_ELEM_SELECT)) l3 = l3->prev; - if (sld->perc < 0.0 && BM_Vert_In_Face(l3->radial_next->f, tempsv->down)) { + if (sld->perc < 0.0 && BM_vert_in_face(l3->radial_next->f, tempsv->down)) { copyf = BLI_smallhash_lookup(&sld->origfaces, (uintptr_t)l3->radial_next->f); - } else if (sld->perc > 0.0 && BM_Vert_In_Face(l3->radial_next->f, tempsv->up)) { + } else if (sld->perc > 0.0 && BM_vert_in_face(l3->radial_next->f, tempsv->up)) { copyf = BLI_smallhash_lookup(&sld->origfaces, (uintptr_t)l3->radial_next->f); } if (!copyf) @@ -4731,11 +4731,11 @@ void projectSVData(TransInfo *t, int final) } /*make sure face-attributes are correct (e.g. MTexPoly)*/ - BM_Copy_Attributes(em->bm, em->bm, copyf2, f); + BM_elem_copy_attrs(em->bm, em->bm, copyf2, f); /*restore selection and hidden flags*/ - BM_Select(em->bm, f, sel); - BM_Hide(em->bm, f, hide); + BM_elem_select_set(em->bm, f, sel); + BM_elem_hide_set(em->bm, f, hide); } } @@ -4779,7 +4779,7 @@ void freeSlideVerts(TransInfo *t) copyf = BLI_smallhash_iternew(&sld->origfaces, &hiter, NULL); for (; copyf; copyf=BLI_smallhash_iternext(&hiter, NULL)) { - BM_Kill_Face_Verts(sld->em->bm, copyf); + BM_face_verts_kill(sld->em->bm, copyf); } sld->em->bm->ob = t->obedit; diff --git a/source/blender/editors/transform/transform_conversions.c b/source/blender/editors/transform/transform_conversions.c index 794e6e0cf30..c2cd1b8378b 100644 --- a/source/blender/editors/transform/transform_conversions.c +++ b/source/blender/editors/transform/transform_conversions.c @@ -311,8 +311,8 @@ static void createTransEdge(TransInfo *t) int propmode = t->flag & T_PROP_EDIT; BM_ITER(eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) { - if (!BM_TestHFlag(eed, BM_ELEM_HIDDEN)) { - if (BM_TestHFlag(eed, BM_ELEM_SELECT)) countsel++; + if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) { + if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) countsel++; if (propmode) count++; } } @@ -333,7 +333,7 @@ static void createTransEdge(TransInfo *t) invert_m3_m3(smtx, mtx); BM_ITER(eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) { - if(!BM_TestHFlag(eed, BM_ELEM_HIDDEN) && (BM_TestHFlag(eed, BM_ELEM_SELECT) || propmode)) { + 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); @@ -342,7 +342,7 @@ static void createTransEdge(TransInfo *t) mul_v3_fl(td->center, 0.5f); td->loc= NULL; - if (BM_TestHFlag(eed, BM_ELEM_SELECT)) + if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) td->flag= TD_SELECTED; else td->flag= 0; @@ -1880,19 +1880,19 @@ static void editmesh_set_connectivity_distance(BMEditMesh *em, float mtx[][3], f fill_vn_fl(dists, em->bm->totvert, FLT_MAX); - BM_ElemIndex_Ensure(em->bm, BM_VERT); + BM_mesh_elem_index_ensure(em->bm, BM_VERT); BLI_smallhash_init(visit); BM_ITER(v, &viter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (BM_TestHFlag(v, BM_ELEM_SELECT)==0 || BM_TestHFlag(v, BM_ELEM_HIDDEN)) + if (BM_elem_flag_test(v, BM_ELEM_SELECT)==0 || BM_elem_flag_test(v, BM_ELEM_HIDDEN)) continue; BLI_smallhash_insert(visit, (uintptr_t)v, NULL); BLI_array_append(queue, v); BLI_array_append(dqueue, 0.0f); - dists[BM_GetIndex(v)] = 0.0f; + dists[BM_elem_index_get(v)] = 0.0f; } start = 0; @@ -1907,9 +1907,9 @@ static void editmesh_set_connectivity_distance(BMEditMesh *em, float mtx[][3], f BM_ITER(e, &eiter, em->bm, BM_EDGES_OF_VERT, v2) { float d2; - v3 = BM_OtherEdgeVert(e, v2); + v3 = BM_edge_other_vert(e, v2); - if (BM_TestHFlag(v3, BM_ELEM_SELECT) || BM_TestHFlag(v3, BM_ELEM_HIDDEN)) + if (BM_elem_flag_test(v3, BM_ELEM_SELECT) || BM_elem_flag_test(v3, BM_ELEM_HIDDEN)) continue; sub_v3_v3v3(vec, v2->co, v3->co); @@ -1917,12 +1917,12 @@ static void editmesh_set_connectivity_distance(BMEditMesh *em, float mtx[][3], f d2 = d + len_v3(vec); - if (dists[BM_GetIndex(v3)] != FLT_MAX) - dists[BM_GetIndex(v3)] = MIN2(d2, dists[BM_GetIndex(v3)]); + if (dists[BM_elem_index_get(v3)] != FLT_MAX) + dists[BM_elem_index_get(v3)] = MIN2(d2, dists[BM_elem_index_get(v3)]); else - dists[BM_GetIndex(v3)] = d2; + dists[BM_elem_index_get(v3)] = d2; - tots[BM_GetIndex(v3)] = 1; + tots[BM_elem_index_get(v3)] = 1; if (BLI_smallhash_haskey(visit, (uintptr_t)v3)) continue; @@ -1956,8 +1956,8 @@ static void editmesh_set_connectivity_distance(BMEditMesh *em, float mtx[][3], f BMIter iter; BM_ITER(efa, &iter, bm, BM_FACES_OF_VERT, eve) { - if (BM_Selected(bm, efa)) { - BM_Compute_Face_CenterMean(bm, efa, cent_r); + if (BM_elem_select_test(bm, efa)) { + BM_face_center_mean_calc(bm, efa, cent_r); break; } } @@ -1969,7 +1969,7 @@ static void get_edge_center(float cent_r[3], BMesh *bm, BMVert *eve) BMIter iter; BM_ITER(eed, &iter, bm, BM_EDGES_OF_VERT, eve) { - if (BM_Selected(bm, eed)) { + if (BM_elem_select_test(bm, eed)) { mid_v3_v3v3(cent_r, eed->v1->co, eed->v2->co); break; } @@ -2049,42 +2049,42 @@ 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) { - if (BM_Selected(bm, eve)) { - BM_SetHFlag(eve, BM_ELEM_TAG); + if (BM_elem_select_test(bm, eve)) { + BM_elem_flag_set(eve, BM_ELEM_TAG); } else { - BM_ClearHFlag(eve, BM_ELEM_TAG); + BM_elem_flag_clear(eve, BM_ELEM_TAG); } } } else if(selectmode & SCE_SELECT_EDGE) { BMEdge *eed; - eve = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL); - for( ; eve; eve=BMIter_Step(&iter)) BM_ClearHFlag(eve, BM_ELEM_TAG); + eve = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL); + for( ; eve; eve=BM_iter_step(&iter)) BM_elem_flag_clear(eve, BM_ELEM_TAG); - eed = BMIter_New(&iter, bm, BM_EDGES_OF_MESH, NULL); - for( ; eed; eed=BMIter_Step(&iter)) { - if (BM_Selected(bm, eed)) { - BM_SetHFlag(eed->v1, BM_ELEM_TAG); - BM_SetHFlag(eed->v2, BM_ELEM_TAG); + eed = BM_iter_new(&iter, bm, BM_EDGES_OF_MESH, NULL); + for( ; eed; eed=BM_iter_step(&iter)) { + if (BM_elem_select_test(bm, eed)) { + BM_elem_flag_set(eed->v1, BM_ELEM_TAG); + BM_elem_flag_set(eed->v2, BM_ELEM_TAG); } } } else { BMFace *efa; - eve = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL); - for( ; eve; eve=BMIter_Step(&iter)) BM_ClearHFlag(eve, BM_ELEM_TAG); + eve = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL); + for( ; eve; eve=BM_iter_step(&iter)) BM_elem_flag_clear(eve, BM_ELEM_TAG); - efa = BMIter_New(&iter, bm, BM_FACES_OF_MESH, NULL); - for( ; efa; efa=BMIter_Step(&iter)) { - if (BM_Selected(bm, efa)) { + efa = BM_iter_new(&iter, bm, BM_FACES_OF_MESH, NULL); + for( ; efa; efa=BM_iter_step(&iter)) { + if (BM_elem_select_test(bm, efa)) { BMIter liter; BMLoop *l; - l = BMIter_New(&liter, bm, BM_LOOPS_OF_FACE, efa); - for (; l; l=BMIter_Step(&liter)) { - BM_SetHFlag(l->v, BM_ELEM_TAG); + l = BM_iter_new(&liter, bm, BM_LOOPS_OF_FACE, efa); + for (; l; l=BM_iter_step(&liter)) { + BM_elem_flag_set(l->v, BM_ELEM_TAG); } } } @@ -2094,10 +2094,10 @@ static void createTransEditVerts(bContext *C, TransInfo *t) * get_crazy_mapped_editverts messes up the index state of the * verts*/ selstate = MEM_callocN(sizeof(*selstate) * bm->totvert, __func__); - eve = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL); - for(a=0; eve; eve=BMIter_Step(&iter), a++) { - if (!BM_TestHFlag(eve, BM_ELEM_HIDDEN)) { - if (BM_TestHFlag(eve, BM_ELEM_TAG)) { + eve = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL); + for(a=0; eve; eve=BM_iter_step(&iter), a++) { + if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) { + if (BM_elem_flag_test(eve, BM_ELEM_TAG)) { selstate[a] = 1; countsel++; } @@ -2162,9 +2162,9 @@ static void createTransEditVerts(bContext *C, TransInfo *t) /* find out which half we do */ if(mirror) { - eve = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL); - for(a=0; eve; eve=BMIter_Step(&iter), a++) { - if(!BM_TestHFlag(eve, BM_ELEM_HIDDEN) && selstate[a] && eve->co[0]!=0.0f) { + eve = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL); + for(a=0; eve; eve=BM_iter_step(&iter), a++) { + if(!BM_elem_flag_test(eve, BM_ELEM_HIDDEN) && selstate[a] && eve->co[0]!=0.0f) { if(eve->co[0]<0.0f) { t->mirror = -1; @@ -2175,9 +2175,9 @@ static void createTransEditVerts(bContext *C, TransInfo *t) } } - eve = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL); - for(a=0; eve; eve=BMIter_Step(&iter), a++) { - if(!BM_TestHFlag(eve, BM_ELEM_HIDDEN)) { + eve = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL); + for(a=0; eve; eve=BM_iter_step(&iter), a++) { + if(!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) { if(propmode || selstate[a]) { float *bweight = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_BWEIGHT); @@ -2199,12 +2199,12 @@ static void createTransEditVerts(bContext *C, TransInfo *t) } /* CrazySpace */ - if(defmats || (quats && BM_GetIndex(eve) != -1)) { + if(defmats || (quats && BM_elem_index_get(eve) != -1)) { float mat[3][3], qmat[3][3], imat[3][3]; /* use both or either quat and defmat correction */ - if(quats && BM_GetIndex(eve) != -1) { - quat_to_mat3(qmat, quats + 4*BM_GetIndex(eve)); + if(quats && BM_elem_index_get(eve) != -1) { + quat_to_mat3(qmat, quats + 4*BM_elem_index_get(eve)); if(defmats) mul_serie_m3(mat, mtx, qmat, defmats[a], @@ -2457,11 +2457,11 @@ static void createTransUVs(bContext *C, TransInfo *t) tf= CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); if(!uvedit_face_visible(scene, ima, efa, tf)) { - BM_ClearHFlag(efa, BM_ELEM_TAG); + BM_elem_flag_clear(efa, BM_ELEM_TAG); continue; } - BM_SetHFlag(efa, BM_ELEM_TAG); + BM_elem_flag_set(efa, BM_ELEM_TAG); BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { if (uvedit_uv_selected(em, scene, l)) countsel++; @@ -2487,7 +2487,7 @@ static void createTransUVs(bContext *C, TransInfo *t) td2d= t->data2d; BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (!BM_TestHFlag(efa, BM_ELEM_TAG)) + if (!BM_elem_flag_test(efa, BM_ELEM_TAG)) continue; tf= CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); diff --git a/source/blender/editors/transform/transform_manipulator.c b/source/blender/editors/transform/transform_manipulator.c index 6211cff55b7..f95856b2373 100644 --- a/source/blender/editors/transform/transform_manipulator.c +++ b/source/blender/editors/transform/transform_manipulator.c @@ -320,8 +320,8 @@ int calc_manipulator_stats(const bContext *C) it is not flush down on changes */ if(ts->selectmode & SCE_SELECT_VERTEX) { BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) { - if(!BM_TestHFlag(eve, BM_ELEM_HIDDEN)) { - if(BM_TestHFlag(eve, BM_ELEM_SELECT)) { + if(!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) { + if(BM_elem_flag_test(eve, BM_ELEM_SELECT)) { totsel++; calc_tw_center(scene, eve->co); } @@ -332,10 +332,10 @@ int calc_manipulator_stats(const bContext *C) BMIter itersub; BMEdge *eed; BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) { - if(!BM_TestHFlag(eve, BM_ELEM_HIDDEN)) { + 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) { - if(BM_TestHFlag(eed, BM_ELEM_SELECT)) { + if(BM_elem_flag_test(eed, BM_ELEM_SELECT)) { totsel++; calc_tw_center(scene, eve->co); break; @@ -348,10 +348,10 @@ int calc_manipulator_stats(const bContext *C) BMIter itersub; BMFace *efa; BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) { - if(!BM_TestHFlag(eve, BM_ELEM_HIDDEN)) { + 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) { - if(BM_TestHFlag(efa, BM_ELEM_SELECT)) { + if(BM_elem_flag_test(efa, BM_ELEM_SELECT)) { totsel++; calc_tw_center(scene, eve->co); break; diff --git a/source/blender/editors/transform/transform_orientations.c b/source/blender/editors/transform/transform_orientations.c index f3bdf0b7d1a..5d92ada60e3 100644 --- a/source/blender/editors/transform/transform_orientations.c +++ b/source/blender/editors/transform/transform_orientations.c @@ -617,7 +617,7 @@ int getTransformOrientation(const bContext *C, float normal[3], float plane[3], BMIter iter; BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if(BM_TestHFlag(efa, BM_ELEM_SELECT)) { + if(BM_elem_flag_test(efa, BM_ELEM_SELECT)) { add_v3_v3(normal, efa->no); sub_v3_v3v3(vec, ((BMLoopList*)efa->loops.first)->first->v->co, @@ -635,7 +635,7 @@ int getTransformOrientation(const bContext *C, float normal[3], float plane[3], float cotangent[3]; BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (BM_TestHFlag(eve, BM_ELEM_SELECT)) { + if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) { if (v1 == NULL) { v1 = eve; } @@ -660,7 +660,7 @@ int getTransformOrientation(const bContext *C, float normal[3], float plane[3], BMIter iter; BM_ITER(eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) { - if(BM_TestHFlag(eed, BM_ELEM_SELECT)) { + if(BM_elem_flag_test(eed, BM_ELEM_SELECT)) { sub_v3_v3v3(plane, eed->v2->co, eed->v1->co); break; } @@ -675,7 +675,7 @@ int getTransformOrientation(const bContext *C, float normal[3], float plane[3], BMIter iter; BM_ITER(eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) { - if(BM_TestHFlag(eed, BM_ELEM_SELECT)) { + 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); add_v3_v3(plane, eed->v2->no); @@ -691,7 +691,7 @@ int getTransformOrientation(const bContext *C, float normal[3], float plane[3], BMIter iter; BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (BM_TestHFlag(eve, BM_ELEM_SELECT)) { + if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) { if (v1 == NULL) { v1 = eve; } @@ -712,7 +712,7 @@ int getTransformOrientation(const bContext *C, float normal[3], float plane[3], BMIter iter; BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (BM_TestHFlag(eve, BM_ELEM_SELECT)) { + if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) { copy_v3_v3(normal, eve->no); break; } @@ -725,7 +725,7 @@ int getTransformOrientation(const bContext *C, float normal[3], float plane[3], normal[0] = normal[1] = normal[2] = 0.0f; BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (BM_TestHFlag(eve, BM_ELEM_SELECT)) { + if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) { add_v3_v3(normal, eve->no); } } diff --git a/source/blender/editors/transform/transform_snap.c b/source/blender/editors/transform/transform_snap.c index 7de00e024f6..183ade56cf0 100644 --- a/source/blender/editors/transform/transform_snap.c +++ b/source/blender/editors/transform/transform_snap.c @@ -1464,16 +1464,16 @@ static int snapDerivedMesh(short snap_mode, ARegion *ar, Object *ob, DerivedMesh { efa = EDBM_get_face_for_index(em, index); - if (efa && BM_TestHFlag(efa, BM_ELEM_HIDDEN)) + if (efa && BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) { test = 0; } else if (efa) { BMIter iter; BMLoop *l; - l = BMIter_New(&iter, em->bm, BM_LOOPS_OF_FACE, efa); - for ( ; l; l=BMIter_Step(&iter)) { - if (BM_TestHFlag(l->v, BM_ELEM_SELECT)) { + l = BM_iter_new(&iter, em->bm, BM_LOOPS_OF_FACE, efa); + for ( ; l; l=BM_iter_step(&iter)) { + if (BM_elem_flag_test(l->v, BM_ELEM_SELECT)) { test = 0; break; } @@ -1548,7 +1548,7 @@ static int snapDerivedMesh(short snap_mode, ARegion *ar, Object *ob, DerivedMesh { eve = EDBM_get_vert_for_index(em, index); - if (eve && (BM_TestHFlag(eve, BM_ELEM_HIDDEN) || BM_TestHFlag(eve, BM_ELEM_SELECT))) + if (eve && (BM_elem_flag_test(eve, BM_ELEM_HIDDEN) || BM_elem_flag_test(eve, BM_ELEM_SELECT))) { test = 0; } @@ -1608,9 +1608,9 @@ static int snapDerivedMesh(short snap_mode, ARegion *ar, Object *ob, DerivedMesh { eed = EDBM_get_edge_for_index(em, index); - if (eed && (BM_TestHFlag(eed, BM_ELEM_HIDDEN) || - BM_TestHFlag(eed->v1, BM_ELEM_SELECT) || - BM_TestHFlag(eed->v2, BM_ELEM_SELECT))) + if (eed && (BM_elem_flag_test(eed, BM_ELEM_HIDDEN) || + BM_elem_flag_test(eed->v1, BM_ELEM_SELECT) || + BM_elem_flag_test(eed->v2, BM_ELEM_SELECT))) { test = 0; } diff --git a/source/blender/editors/util/crazyspace.c b/source/blender/editors/util/crazyspace.c index c88f6e0d60b..c611a14ae7f 100644 --- a/source/blender/editors/util/crazyspace.c +++ b/source/blender/editors/util/crazyspace.c @@ -146,28 +146,28 @@ void crazyspace_set_quats_editmesh(BMEditMesh *em, float *origcos, float *mapped int *vert_table = MEM_callocN(sizeof(int)*em->bm->totvert, "vert_table"); int index = 0; - BM_ElemIndex_Ensure(em->bm, BM_VERT); + BM_mesh_elem_index_ensure(em->bm, BM_VERT); BM_ITER(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - if (!BM_TestHFlag(v, BM_ELEM_SELECT) || BM_TestHFlag(v, BM_ELEM_HIDDEN)) + 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) { - BMLoop *l2 = BM_OtherFaceLoop(l->e, l->f, v); + BMLoop *l2 = BM_face_other_loop(l->e, l->f, v); /* retrieve mapped coordinates */ - v1= mappedcos + 3*BM_GetIndex(l->v); - v2= mappedcos + 3*BM_GetIndex(BM_OtherEdgeVert(l2->e, l->v)); - v3= mappedcos + 3*BM_GetIndex(BM_OtherEdgeVert(l->e, l->v)); + v1= mappedcos + 3*BM_elem_index_get(l->v); + v2= mappedcos + 3*BM_elem_index_get(BM_edge_other_vert(l2->e, l->v)); + v3= mappedcos + 3*BM_elem_index_get(BM_edge_other_vert(l->e, l->v)); - co1= (origcos)? origcos + 3*BM_GetIndex(l->v) : l->v->co; - co2= (origcos)? origcos + 3*BM_GetIndex(BM_OtherEdgeVert(l2->e, l->v)) : BM_OtherEdgeVert(l2->e, l->v)->co; - co3= (origcos)? origcos + 3*BM_GetIndex(BM_OtherEdgeVert(l->e, l->v)) : BM_OtherEdgeVert(l->e, l->v)->co; + co1= (origcos)? origcos + 3*BM_elem_index_get(l->v) : l->v->co; + co2= (origcos)? origcos + 3*BM_elem_index_get(BM_edge_other_vert(l2->e, l->v)) : BM_edge_other_vert(l2->e, l->v)->co; + co3= (origcos)? origcos + 3*BM_elem_index_get(BM_edge_other_vert(l->e, l->v)) : BM_edge_other_vert(l->e, l->v)->co; set_crazy_vertex_quat(quats, v1, v2, v3, co1, co2, co3); quats+= 4; - vert_table[BM_GetIndex(l->v)] = index+1; + vert_table[BM_elem_index_get(l->v)] = index+1; index++; break; /*just do one corner*/ @@ -177,9 +177,9 @@ void crazyspace_set_quats_editmesh(BMEditMesh *em, float *origcos, float *mapped index = 0; BM_ITER(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { if (vert_table[index] != 0) - BM_SetIndex(v, vert_table[index]-1); /* set_dirty! */ + BM_elem_index_set(v, vert_table[index]-1); /* set_dirty! */ else - BM_SetIndex(v, -1); /* set_dirty! */ + BM_elem_index_set(v, -1); /* set_dirty! */ index++; } diff --git a/source/blender/editors/uvedit/uvedit_draw.c b/source/blender/editors/uvedit/uvedit_draw.c index 8693e3e7d6d..26fbc48d2fb 100644 --- a/source/blender/editors/uvedit/uvedit_draw.c +++ b/source/blender/editors/uvedit/uvedit_draw.c @@ -201,17 +201,17 @@ static void draw_uvs_stretch(SpaceImage *sima, Scene *scene, BMEditMesh *em, MTe poly_copy_aspect(tf_uvorig, tf_uv, aspx, aspy, efa->len); - totarea += BM_Compute_Face_Area(em->bm, efa); + totarea += BM_face_area_calc(em->bm, efa); //totuvarea += tf_area(tf, efa->v4!=0); totuvarea += poly_uv_area(tf_uv, efa->len); if(uvedit_face_visible(scene, ima, efa, tf)) { - BM_SetHFlag(efa, BM_ELEM_TAG); + BM_elem_flag_set(efa, BM_ELEM_TAG); } else { if(tf == activetf) activetf= NULL; - BM_ClearHFlag(efa, BM_ELEM_TAG); + BM_elem_flag_clear(efa, BM_ELEM_TAG); } } @@ -220,7 +220,7 @@ static void draw_uvs_stretch(SpaceImage *sima, Scene *scene, BMEditMesh *em, MTe col[1] = col[2] = 0.0; glColor3fv(col); BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if(BM_TestHFlag(efa, BM_ELEM_TAG)) { + if(BM_elem_flag_test(efa, BM_ELEM_TAG)) { glBegin(GL_POLYGON); BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV); @@ -232,8 +232,8 @@ static void draw_uvs_stretch(SpaceImage *sima, Scene *scene, BMEditMesh *em, MTe } else { BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if(BM_TestHFlag(efa, BM_ELEM_TAG)) { - area = BM_Compute_Face_Area(em->bm, efa) / totarea; + if(BM_elem_flag_test(efa, BM_ELEM_TAG)) { + area = BM_face_area_calc(em->bm, efa) / totarea; BLI_array_empty(tf_uv); BLI_array_empty(tf_uvorig); @@ -518,7 +518,7 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit) em= me->edit_btmesh; activetf= EDBM_get_active_mtexpoly(em, &efa_act, FALSE); /* will be set to NULL if hidden */ - activef = BM_get_actFace(em->bm, FALSE); + activef = BM_active_face_get(em->bm, FALSE); ts= scene->toolsettings; drawfaces= draw_uvs_face_check(scene); @@ -569,7 +569,7 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit) tf= CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); if(uvedit_face_visible(scene, ima, efa, tf)) { - BM_SetHFlag(efa, BM_ELEM_TAG); + BM_elem_flag_set(efa, BM_ELEM_TAG); if(tf==activetf) continue; /* important the temp boolean is set above */ if(uvedit_face_selected(scene, em, efa)) @@ -587,7 +587,7 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit) else { if(tf == activetf) activetf= NULL; - BM_ClearHFlag(efa, BM_ELEM_TAG); + BM_elem_flag_clear(efa, BM_ELEM_TAG); } } glDisable(GL_BLEND); @@ -599,12 +599,12 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit) tf= CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); if(uvedit_face_visible(scene, ima, efa, tf)) { - BM_SetHFlag(efa, BM_ELEM_TAG); + BM_elem_flag_set(efa, BM_ELEM_TAG); } else { if(tf == activetf) activetf= NULL; - BM_ClearHFlag(efa, BM_ELEM_TAG); + BM_elem_flag_clear(efa, BM_ELEM_TAG); } } @@ -642,7 +642,7 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit) switch(sima->dt_uv) { case SI_UVDT_DASH: BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (!BM_TestHFlag(efa, BM_ELEM_TAG)) + if (!BM_elem_flag_test(efa, BM_ELEM_TAG)) continue; tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); @@ -683,7 +683,7 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit) else glColor3f(0.0f, 0.0f, 0.0f); BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (!BM_TestHFlag(efa, BM_ELEM_TAG)) + if (!BM_elem_flag_test(efa, BM_ELEM_TAG)) continue; glBegin(GL_LINE_LOOP); @@ -699,7 +699,7 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit) cpack(0x0); BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (!BM_TestHFlag(efa, BM_ELEM_TAG)) + if (!BM_elem_flag_test(efa, BM_ELEM_TAG)) continue; glBegin(GL_LINE_LOOP); @@ -722,7 +722,7 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit) glShadeModel(GL_SMOOTH); BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (!BM_TestHFlag(efa, BM_ELEM_TAG)) + if (!BM_elem_flag_test(efa, BM_ELEM_TAG)) continue; glBegin(GL_LINE_LOOP); @@ -740,7 +740,7 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit) } else { BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (!BM_TestHFlag(efa, BM_ELEM_TAG)) + if (!BM_elem_flag_test(efa, BM_ELEM_TAG)) continue; glBegin(GL_LINES); @@ -762,7 +762,7 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit) else { /* no nice edges */ BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (!BM_TestHFlag(efa, BM_ELEM_TAG)) + if (!BM_elem_flag_test(efa, BM_ELEM_TAG)) continue; glBegin(GL_LINE_LOOP); @@ -795,7 +795,7 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit) bglBegin(GL_POINTS); BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (!BM_TestHFlag(efa, BM_ELEM_TAG)) + if (!BM_elem_flag_test(efa, BM_ELEM_TAG)) continue; if(!uvedit_face_selected(scene, em, efa)) { @@ -810,7 +810,7 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit) bglBegin(GL_POINTS); BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (!BM_TestHFlag(efa, BM_ELEM_TAG)) + if (!BM_elem_flag_test(efa, BM_ELEM_TAG)) continue; if(uvedit_face_selected(scene, em, efa)) { @@ -831,7 +831,7 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit) bglBegin(GL_POINTS); BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (!BM_TestHFlag(efa, BM_ELEM_TAG)) + if (!BM_elem_flag_test(efa, BM_ELEM_TAG)) continue; BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { @@ -849,7 +849,7 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit) bglBegin(GL_POINTS); BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (!BM_TestHFlag(efa, BM_ELEM_TAG)) + if (!BM_elem_flag_test(efa, BM_ELEM_TAG)) continue; BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { @@ -867,7 +867,7 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit) bglBegin(GL_POINTS); BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (!BM_TestHFlag(efa, BM_ELEM_TAG)) + if (!BM_elem_flag_test(efa, BM_ELEM_TAG)) continue; BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { diff --git a/source/blender/editors/uvedit/uvedit_ops.c b/source/blender/editors/uvedit/uvedit_ops.c index 6d0468d34f5..42b6953a719 100644 --- a/source/blender/editors/uvedit/uvedit_ops.c +++ b/source/blender/editors/uvedit/uvedit_ops.c @@ -188,7 +188,7 @@ void ED_uvedit_assign_image(Main *bmain, Scene *scene, Object *obedit, Image *im if(scene_use_new_shading_nodes(scene)) { /* new shading system, assign image in material */ int sloppy= 1; - BMFace *efa= BM_get_actFace(em->bm, sloppy); + BMFace *efa= BM_active_face_get(em->bm, sloppy); if(efa) ED_object_assign_active_image(bmain, obedit, efa->mat_nr, ima); @@ -198,8 +198,8 @@ void ED_uvedit_assign_image(Main *bmain, Scene *scene, Object *obedit, Image *im /* ensure we have a uv map */ if(!CustomData_has_layer(&em->bm->pdata, CD_MTEXPOLY)) { - BM_add_data_layer(em->bm, &em->bm->pdata, CD_MTEXPOLY); - BM_add_data_layer(em->bm, &em->bm->ldata, CD_MLOOPUV); + BM_data_layer_add(em->bm, &em->bm->pdata, CD_MTEXPOLY); + BM_data_layer_add(em->bm, &em->bm->ldata, CD_MLOOPUV); update= 1; } @@ -254,7 +254,7 @@ static int uvedit_set_tile(Object *obedit, Image *ima, int curtile) BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); - if(!BM_TestHFlag(efa, BM_ELEM_HIDDEN) && BM_TestHFlag(efa, BM_ELEM_SELECT)) + if(!BM_elem_flag_test(efa, BM_ELEM_HIDDEN) && BM_elem_flag_test(efa, BM_ELEM_SELECT)) tf->tile= curtile; /* set tile index */ } @@ -288,9 +288,9 @@ int uvedit_face_visible_nolocal(Scene *scene, BMFace *efa) ToolSettings *ts= scene->toolsettings; if(ts->uv_flag & UV_SYNC_SELECTION) - return (BM_TestHFlag(efa, BM_ELEM_HIDDEN)==0); + return (BM_elem_flag_test(efa, BM_ELEM_HIDDEN)==0); else - return (BM_TestHFlag(efa, BM_ELEM_HIDDEN)==0 && BM_TestHFlag(efa, BM_ELEM_SELECT)); + return (BM_elem_flag_test(efa, BM_ELEM_HIDDEN)==0 && BM_elem_flag_test(efa, BM_ELEM_SELECT)); } int uvedit_face_visible(Scene *scene, Image *ima, BMFace *efa, MTexPoly *tf) { @@ -307,7 +307,7 @@ int uvedit_face_selected(Scene *scene, BMEditMesh *em, BMFace *efa) ToolSettings *ts= scene->toolsettings; if(ts->uv_flag & UV_SYNC_SELECTION) - return (BM_TestHFlag(efa, BM_ELEM_SELECT)); + return (BM_elem_flag_test(efa, BM_ELEM_SELECT)); else { BMLoop *l; MLoopUV *luv; @@ -328,7 +328,7 @@ int uvedit_face_select(Scene *scene, BMEditMesh *em, BMFace *efa) ToolSettings *ts= scene->toolsettings; if(ts->uv_flag & UV_SYNC_SELECTION) - BM_Select(em->bm, efa, TRUE); + BM_elem_select_set(em->bm, efa, TRUE); else { BMLoop *l; MLoopUV *luv; @@ -350,7 +350,7 @@ int uvedit_face_deselect(Scene *scene, BMEditMesh *em, BMFace *efa) ToolSettings *ts= scene->toolsettings; if(ts->uv_flag & UV_SYNC_SELECTION) { - BM_Select(em->bm, efa, FALSE); + BM_elem_select_set(em->bm, efa, FALSE); } else { BMLoop *l; @@ -374,12 +374,12 @@ int uvedit_edge_selected(BMEditMesh *em, Scene *scene, BMLoop *l) if(ts->uv_flag & UV_SYNC_SELECTION) { if(ts->selectmode & SCE_SELECT_FACE) - return BM_TestHFlag(l->f, BM_ELEM_SELECT); + return BM_elem_flag_test(l->f, BM_ELEM_SELECT); else if(ts->selectmode == SCE_SELECT_EDGE) { - return BM_TestHFlag(l->e, BM_ELEM_SELECT); + return BM_elem_flag_test(l->e, BM_ELEM_SELECT); } else - return BM_TestHFlag(l->v, BM_ELEM_SELECT) && - BM_TestHFlag(l->next->v, BM_ELEM_SELECT); + return BM_elem_flag_test(l->v, BM_ELEM_SELECT) && + BM_elem_flag_test(l->next->v, BM_ELEM_SELECT); } else { MLoopUV *luv1, *luv2; @@ -398,12 +398,12 @@ void uvedit_edge_select(BMEditMesh *em, Scene *scene, BMLoop *l) if(ts->uv_flag & UV_SYNC_SELECTION) { if(ts->selectmode & SCE_SELECT_FACE) - BM_Select(em->bm, l->f, TRUE); + BM_elem_select_set(em->bm, l->f, TRUE); else if(ts->selectmode & SCE_SELECT_EDGE) - BM_Select(em->bm, l->e, TRUE); + BM_elem_select_set(em->bm, l->e, TRUE); else { - BM_Select(em->bm, l->e->v1, TRUE); - BM_Select(em->bm, l->e->v2, TRUE); + BM_elem_select_set(em->bm, l->e->v1, TRUE); + BM_elem_select_set(em->bm, l->e->v2, TRUE); } } else { @@ -424,12 +424,12 @@ void uvedit_edge_deselect(BMEditMesh *em, Scene *scene, BMLoop *l) if(ts->uv_flag & UV_SYNC_SELECTION) { if(ts->selectmode & SCE_SELECT_FACE) - BM_Select(em->bm, l->f, FALSE); + BM_elem_select_set(em->bm, l->f, FALSE); else if(ts->selectmode & SCE_SELECT_EDGE) - BM_Select(em->bm, l->e, FALSE); + BM_elem_select_set(em->bm, l->e, FALSE); else { - BM_Select(em->bm, l->e->v1, FALSE); - BM_Select(em->bm, l->e->v2, FALSE); + BM_elem_select_set(em->bm, l->e->v1, FALSE); + BM_elem_select_set(em->bm, l->e->v2, FALSE); } } else { @@ -449,9 +449,9 @@ int uvedit_uv_selected(BMEditMesh *em, Scene *scene, BMLoop *l) if(ts->uv_flag & UV_SYNC_SELECTION) { if(ts->selectmode & SCE_SELECT_FACE) - return BM_TestHFlag(l->f, BM_ELEM_SELECT); + return BM_elem_flag_test(l->f, BM_ELEM_SELECT); else - return BM_TestHFlag(l->v, BM_ELEM_SELECT); + return BM_elem_flag_test(l->v, BM_ELEM_SELECT); } else { MLoopUV *luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV); @@ -466,9 +466,9 @@ void uvedit_uv_select(BMEditMesh *em, Scene *scene, BMLoop *l) if(ts->uv_flag & UV_SYNC_SELECTION) { if(ts->selectmode & SCE_SELECT_FACE) - BM_Select(em->bm, l->f, TRUE); + BM_elem_select_set(em->bm, l->f, TRUE); else - BM_Select(em->bm, l->v, TRUE); + BM_elem_select_set(em->bm, l->v, TRUE); } else { MLoopUV *luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV); @@ -483,9 +483,9 @@ void uvedit_uv_deselect(BMEditMesh *em, Scene *scene, BMLoop *l) if(ts->uv_flag & UV_SYNC_SELECTION) { if(ts->selectmode & SCE_SELECT_FACE) - BM_Select(em->bm, l->f, FALSE); + BM_elem_select_set(em->bm, l->f, FALSE); else - BM_Select(em->bm, l->v, FALSE); + BM_elem_select_set(em->bm, l->v, FALSE); } else { MLoopUV *luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV); @@ -682,7 +682,7 @@ void uv_find_nearest_edge(Scene *scene, Image *ima, BMEditMesh *em, float co[2], mindist= 1e10f; memset(hit, 0, sizeof(*hit)); - BM_ElemIndex_Ensure(em->bm, BM_VERT); + BM_mesh_elem_index_ensure(em->bm, BM_VERT); BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { tf= CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); @@ -705,8 +705,8 @@ void uv_find_nearest_edge(Scene *scene, Image *ima, BMEditMesh *em, float co[2], hit->luv = luv; hit->nextluv = nextluv; hit->lindex = i; - hit->vert1 = BM_GetIndex(hit->l->v); - hit->vert2 = BM_GetIndex(hit->l->next->v); + hit->vert1 = BM_elem_index_get(hit->l->v); + hit->vert2 = BM_elem_index_get(hit->l->next->v); mindist = dist; } @@ -822,7 +822,7 @@ void uv_find_nearest_vert(Scene *scene, Image *ima, BMEditMesh *em, mindist= 1e10f; memset(hit, 0, sizeof(*hit)); - BM_ElemIndex_Ensure(em->bm, BM_VERT); + BM_mesh_elem_index_ensure(em->bm, BM_VERT); BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { tf= CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); @@ -854,7 +854,7 @@ void uv_find_nearest_vert(Scene *scene, Image *ima, BMEditMesh *em, hit->tf= tf; hit->efa= efa; hit->lindex = i; - hit->vert1 = BM_GetIndex(hit->l->v); + hit->vert1 = BM_elem_index_get(hit->l->v); } i++; @@ -922,13 +922,13 @@ static UvMapVert *uv_vertex_map_get(UvVertMap *vmap, BMFace *efa, int a) UvMapVert *iterv, *first; BMLoop *l; - l = BMIter_AtIndex(NULL, BM_LOOPS_OF_FACE, efa, a); - first= EDBM_get_uv_map_vert(vmap, BM_GetIndex(l->v)); + l = BM_iter_at_index(NULL, BM_LOOPS_OF_FACE, efa, a); + first= EDBM_get_uv_map_vert(vmap, BM_elem_index_get(l->v)); for(iterv=first; iterv; iterv=iterv->next) { if(iterv->separate) first= iterv; - if(iterv->f == BM_GetIndex(efa)) + if(iterv->f == BM_elem_index_get(efa)) return first; } @@ -942,9 +942,9 @@ UvElement *ED_get_uv_element(UvElementMap *map, BMFace *efa, int index) BMLoop *l; UvElement *element; - l = BMIter_AtIndex(NULL, BM_LOOPS_OF_FACE, efa, index); + l = BM_iter_at_index(NULL, BM_LOOPS_OF_FACE, efa, index); - element = map->vert[BM_GetIndex(l->v)]; + element = map->vert[BM_elem_index_get(l->v)]; for(; element; element = element->next) if(element->face == efa) @@ -971,7 +971,7 @@ static int uv_edge_tag_faces(BMEditMesh *em, UvMapVert *first1, UvMapVert *first if(iterv1->f == iterv2->f) { /* if face already tagged, don't do this edge */ efa= EDBM_get_face_for_index(em, iterv1->f); - if(BMO_TestFlag(em->bm, efa, EFA_F1_FLAG)) + if(BMO_elem_flag_test(em->bm, efa, EFA_F1_FLAG)) return 0; tot++; @@ -996,7 +996,7 @@ static int uv_edge_tag_faces(BMEditMesh *em, UvMapVert *first1, UvMapVert *first if(iterv1->f == iterv2->f) { efa= EDBM_get_face_for_index(em, iterv1->f); - BMO_SetFlag(em->bm, efa, EFA_F1_FLAG); + BMO_elem_flag_set(em->bm, efa, EFA_F1_FLAG); break; } } @@ -1019,7 +1019,7 @@ static int select_edgeloop(Scene *scene, Image *ima, BMEditMesh *em, NearestHit EDBM_init_index_arrays(em, 0, 0, 1); vmap= EDBM_make_uv_vert_map(em, 0, 0, limit); - BM_ElemIndex_Ensure(em->bm, BM_VERT); + BM_mesh_elem_index_ensure(em->bm, BM_VERT); count = 0; BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { @@ -1027,9 +1027,9 @@ static int select_edgeloop(Scene *scene, Image *ima, BMEditMesh *em, NearestHit uvedit_face_deselect(scene, em, efa); } - BMO_ClearFlag(em->bm, efa, EFA_F1_FLAG); + BMO_elem_flag_clear(em->bm, efa, EFA_F1_FLAG); - BM_SetIndex(efa, count); /* set_inline */ + BM_elem_index_set(efa, count); /* set_inline */ count++; } @@ -1058,7 +1058,7 @@ static int select_edgeloop(Scene *scene, Image *ima, BMEditMesh *em, NearestHit BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { tf= CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); - if(!BMO_TestFlag(em->bm, efa, EFA_F1_FLAG) && uvedit_face_visible(scene, ima, efa, tf)) { + if(!BMO_elem_flag_test(em->bm, efa, EFA_F1_FLAG) && uvedit_face_visible(scene, ima, efa, tf)) { nverts= efa->len; for(a=0; a<nverts; a++) { /* check face not hidden and not tagged */ @@ -1072,7 +1072,7 @@ static int select_edgeloop(Scene *scene, Image *ima, BMEditMesh *em, NearestHit if(iterv1->flag || iterv2->flag) { if(uv_edge_tag_faces(em, iterv1, iterv2, &starttotf)) { looking= 1; - BMO_SetFlag(em->bm, efa, EFA_F1_FLAG); + BMO_elem_flag_set(em->bm, efa, EFA_F1_FLAG); uv_vertex_loop_flag(iterv1); uv_vertex_loop_flag(iterv2); @@ -1202,7 +1202,7 @@ static void select_linked(Scene *scene, Image *ima, BMEditMesh *em, float limit[ BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { /* make_uv_vert_map_EM sets verts tmp.l to the indices */ - vlist= EDBM_get_uv_map_vert(vmap, BM_GetIndex(l->v)); + vlist= EDBM_get_uv_map_vert(vmap, BM_elem_index_get(l->v)); startv= vlist; @@ -1418,7 +1418,7 @@ static void weld_align_uv(bContext *C, int tool) /* clear tag */ BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - BM_ClearHFlag(eve, BM_ELEM_TAG); + BM_elem_flag_clear(eve, BM_ELEM_TAG); } /* tag verts with a selected UV */ @@ -1430,7 +1430,7 @@ static void weld_align_uv(bContext *C, int tool) continue; if (uvedit_uv_selected(em, scene, l)) { - BM_SetHFlag(eve, BM_ELEM_TAG); + BM_elem_flag_set(eve, BM_ELEM_TAG); break; } } @@ -1438,11 +1438,11 @@ 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) { - if (BM_TestHFlag(eed->v1, BM_ELEM_TAG) && BM_TestHFlag(eed->v2, BM_ELEM_TAG)) { - BM_SetHFlag(eed, BM_ELEM_TAG); + if (BM_elem_flag_test(eed->v1, BM_ELEM_TAG) && BM_elem_flag_test(eed->v2, BM_ELEM_TAG)) { + BM_elem_flag_set(eed, BM_ELEM_TAG); } else { - BM_ClearHFlag(eed, BM_ELEM_TAG); + BM_elem_flag_clear(eed, BM_ELEM_TAG); } } @@ -1451,7 +1451,7 @@ static void weld_align_uv(bContext *C, int tool) BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { int tot_eed_tag = 0; BM_ITER(eed, &eiter, em->bm, BM_EDGES_OF_VERT, eve) { - if (BM_TestHFlag(eed, BM_ELEM_TAG)) { + if (BM_elem_flag_test(eed, BM_ELEM_TAG)) { tot_eed_tag++; } } @@ -1474,15 +1474,15 @@ static void weld_align_uv(bContext *C, int tool) while (eve) { BLI_array_append(eve_line, eve); /* dont touch again */ - BM_ClearHFlag(eve, BM_ELEM_TAG); + BM_elem_flag_clear(eve, BM_ELEM_TAG); eve_next = NULL; /* find next eve */ BM_ITER(eed, &eiter, em->bm, BM_EDGES_OF_VERT, eve) { - if (BM_TestHFlag(eed, BM_ELEM_TAG)) { - BMVert *eve_other = BM_OtherEdgeVert(eed, eve); - if (BM_TestHFlag(eve_other, BM_ELEM_TAG)) { + 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)) { /* this is a tagged vert we didnt walk over yet, step onto it */ eve_next = eve_other; break; @@ -1655,7 +1655,7 @@ static int stitch_exec(bContext *C, wmOperator *op) efa = EDBM_get_face_for_index(em, iterv->f); tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); - l = BMIter_AtIndex(em->bm, BM_LOOPS_OF_FACE, efa, iterv->tfindex); + l = BM_iter_at_index(em->bm, BM_LOOPS_OF_FACE, efa, iterv->tfindex); if (uvedit_uv_selected(em, scene, l)) { luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV); @@ -1675,7 +1675,7 @@ static int stitch_exec(bContext *C, wmOperator *op) efa = EDBM_get_face_for_index(em, iterv->f); tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); - l = BMIter_AtIndex(em->bm, BM_LOOPS_OF_FACE, efa, iterv->tfindex); + l = BM_iter_at_index(em->bm, BM_LOOPS_OF_FACE, efa, iterv->tfindex); if (uvedit_uv_selected(em, scene, l)) { luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV); @@ -1698,7 +1698,7 @@ static int stitch_exec(bContext *C, wmOperator *op) else { UVVertAverage *uv_average, *uvav; - BM_ElemIndex_Ensure(em->bm, BM_VERT); + BM_mesh_elem_index_ensure(em->bm, BM_VERT); uv_average= MEM_callocN(sizeof(UVVertAverage)*em->bm->totvert, "Stitch"); @@ -1711,7 +1711,7 @@ static int stitch_exec(bContext *C, wmOperator *op) BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { if(uvedit_uv_selected(em, scene, l)) { luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV); - uvav = uv_average + BM_GetIndex(l->v); + uvav = uv_average + BM_elem_index_get(l->v); uvav->count++; uvav->uv[0] += luv->uv[0]; @@ -1729,7 +1729,7 @@ static int stitch_exec(bContext *C, wmOperator *op) BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { if(uvedit_uv_selected(em, scene, l)) { luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV); - uvav = uv_average + BM_GetIndex(l->v); + uvav = uv_average + BM_elem_index_get(l->v); luv->uv[0] = uvav->uv[0]/uvav->count; luv->uv[1] = uvav->uv[1]/uvav->count; } @@ -2018,7 +2018,7 @@ static int mouse_select(bContext *C, float co[2], int extend, int loop) } /* make active */ - BM_set_actFace(em->bm, hit.efa); + BM_active_face_set(em->bm, hit.efa); /* mark all face vertices as being hit */ @@ -2028,7 +2028,7 @@ static int mouse_select(bContext *C, float co[2], int extend, int loop) BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, hit.efa) { luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV); hituv[i]= luv->uv; - hitv[i] = BM_GetIndex(l->v); + hitv[i] = BM_elem_index_get(l->v); i++; } @@ -2100,7 +2100,7 @@ static int mouse_select(bContext *C, float co[2], int extend, int loop) /* (de)select sticky uv nodes */ if(sticky != SI_STICKY_DISABLE) { - BM_ElemIndex_Ensure(em->bm, BM_VERT); + BM_mesh_elem_index_ensure(em->bm, BM_VERT); /* deselect */ if(select==0) { @@ -2111,7 +2111,7 @@ static int mouse_select(bContext *C, float co[2], int extend, int loop) BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV); - if(sticky_select(limit, hitv, BM_GetIndex(l->v), hituv, luv->uv, sticky, hitlen)) + if(sticky_select(limit, hitv, BM_elem_index_get(l->v), hituv, luv->uv, sticky, hitlen)) uvedit_uv_deselect(em, scene, l); } } @@ -2126,7 +2126,7 @@ static int mouse_select(bContext *C, float co[2], int extend, int loop) BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV); - if(sticky_select(limit, hitv, BM_GetIndex(l->v), hituv, luv->uv, sticky, hitlen)) + if(sticky_select(limit, hitv, BM_elem_index_get(l->v), hituv, luv->uv, sticky, hitlen)) uvedit_uv_select(em, scene, l); } } @@ -2167,7 +2167,7 @@ static int mouse_select(bContext *C, float co[2], int extend, int loop) if(sticky == SI_STICKY_DISABLE) continue; luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV); - if(sticky_select(limit, hitv, BM_GetIndex(l->v), hituv, luv->uv, sticky, hitlen)) + if(sticky_select(limit, hitv, BM_elem_index_get(l->v), hituv, luv->uv, sticky, hitlen)) uvedit_uv_select(em, scene, l); flush= 1; @@ -2176,7 +2176,7 @@ static int mouse_select(bContext *C, float co[2], int extend, int loop) } } -#if 0 /* BM_Select API handles all of this? */ +#if 0 /* BM_elem_select_set API handles all of this? */ if(sync) { /* flush for mesh selection */ @@ -2481,13 +2481,13 @@ static void uv_faces_do_sticky(bContext *C, SpaceImage *sima, Scene *scene, Obje BMVert *eve; BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) { - BM_ClearHFlag(eve, BM_ELEM_TAG); + BM_elem_flag_clear(eve, BM_ELEM_TAG); } BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (BM_TestHFlag(efa, BM_ELEM_TAG)) { + if (BM_elem_flag_test(efa, BM_ELEM_TAG)) { BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { - BM_SetHFlag(l->v, BM_ELEM_TAG); + BM_elem_flag_set(l->v, BM_ELEM_TAG); } } } @@ -2497,7 +2497,7 @@ static void uv_faces_do_sticky(bContext *C, SpaceImage *sima, Scene *scene, Obje /* tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); */ /* UNUSED */ BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { - if (BM_TestHFlag(l->v, BM_ELEM_TAG)) { + if (BM_elem_flag_test(l->v, BM_ELEM_TAG)) { if (select) uvedit_uv_select(em, scene, l); else @@ -2529,9 +2529,9 @@ static void uv_faces_do_sticky(bContext *C, SpaceImage *sima, Scene *scene, Obje return; } - efa = BMIter_New(&iter, em->bm, BM_FACES_OF_MESH, NULL); - for (efa_index=0; efa; efa=BMIter_Step(&iter), efa_index++) { - if (BM_TestHFlag(efa, BM_ELEM_TAG)) { + efa = BM_iter_new(&iter, em->bm, BM_FACES_OF_MESH, NULL); + for (efa_index=0; efa; efa=BM_iter_step(&iter), efa_index++) { + 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) { @@ -2540,7 +2540,7 @@ static void uv_faces_do_sticky(bContext *C, SpaceImage *sima, Scene *scene, Obje else uvedit_uv_deselect(em, scene, l); - vlist_iter= EDBM_get_uv_map_vert(vmap, BM_GetIndex(l->v)); + vlist_iter= EDBM_get_uv_map_vert(vmap, BM_elem_index_get(l->v)); while (vlist_iter) { if(vlist_iter->separate) @@ -2563,9 +2563,9 @@ static void uv_faces_do_sticky(bContext *C, SpaceImage *sima, Scene *scene, Obje /* tf_vlist = CustomData_bmesh_get(&em->bm->pdata, efa_vlist->head.data, CD_MTEXPOLY); */ /* UNUSED */ if(select) - uvedit_uv_select(em, scene, BMIter_AtIndex(em->bm, BM_LOOPS_OF_FACE, efa_vlist, vlist_iter->tfindex)); + uvedit_uv_select(em, scene, BM_iter_at_index(em->bm, BM_LOOPS_OF_FACE, efa_vlist, vlist_iter->tfindex)); else - uvedit_uv_deselect(em, scene, BMIter_AtIndex(em->bm, BM_LOOPS_OF_FACE, efa_vlist, vlist_iter->tfindex)); + uvedit_uv_deselect(em, scene, BM_iter_at_index(em->bm, BM_LOOPS_OF_FACE, efa_vlist, vlist_iter->tfindex)); } vlist_iter = vlist_iter->next; } @@ -2578,7 +2578,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) { - if (BM_TestHFlag(efa, BM_ELEM_TAG)) { + if (BM_elem_flag_test(efa, BM_ELEM_TAG)) { if(select) uvedit_face_select(scene, em, efa); else @@ -2637,13 +2637,13 @@ static int border_select_exec(bContext *C, wmOperator *op) BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { /* assume not touched */ - BM_ClearHFlag(efa, BM_ELEM_TAG); + BM_elem_flag_clear(efa, BM_ELEM_TAG); tf= CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); if(uvedit_face_visible(scene, ima, efa, tf)) { poly_uv_center(em, efa, cent); if(BLI_in_rctf(&rectf, cent[0], cent[1])) { - BM_SetHFlag(efa, BM_ELEM_TAG); + BM_elem_flag_set(efa, BM_ELEM_TAG); change = 1; } } @@ -2684,7 +2684,7 @@ static int border_select_exec(bContext *C, wmOperator *op) if(change) { /* make sure newly selected vert selection is updated*/ -#if 0 /* BM_Select API handles all of this? */ +#if 0 /* BM_elem_select_set API handles all of this? */ if(ts->uv_flag & UV_SYNC_SELECTION) { if(ts->selectmode != SCE_SELECT_FACE) { if(select) EDBM_select_flush(em); @@ -2784,7 +2784,7 @@ static int circle_select_exec(bContext *C, wmOperator *op) } } -#if 0 //I think the BM_Select api stuff handles all this as necassary? +#if 0 //I think the BM_elem_select_set api stuff handles all this as necassary? if(select) EM_select_flush(em); else EM_deselect_flush(em); #endif @@ -2934,7 +2934,7 @@ static int snap_uvs_to_adjacent_unselected(Scene *scene, Image *ima, Object *obe /* set all verts to -1 : an unused index*/ BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) - BM_SetIndex(eve, -1); /* set_dirty! */ + BM_elem_index_set(eve, -1); /* set_dirty! */ em->bm->elem_index_dirty |= BM_VERT; /* index every vert that has a selected UV using it, but only once so as to @@ -2942,16 +2942,16 @@ static int snap_uvs_to_adjacent_unselected(Scene *scene, Image *ima, Object *obe BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { tface= CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); if(!uvedit_face_visible(scene, ima, efa, tface)) { - BM_ClearHFlag(efa, BM_ELEM_TAG); + BM_elem_flag_clear(efa, BM_ELEM_TAG); continue; } else { - BM_SetHFlag(efa, BM_ELEM_TAG); + BM_elem_flag_set(efa, BM_ELEM_TAG); } change = 1; BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { - if (uvedit_uv_selected(em, scene, l) && BM_GetIndex(l->v) == -1) { - BM_SetIndex(l->v, count); /* set_dirty! */ + if (uvedit_uv_selected(em, scene, l) && BM_elem_index_get(l->v) == -1) { + BM_elem_index_set(l->v, count); /* set_dirty! */ count++; } } @@ -2963,7 +2963,7 @@ static int snap_uvs_to_adjacent_unselected(Scene *scene, Image *ima, Object *obe /* add all UV coords from visible, unselected UV coords as well as counting them to average later */ BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (!BM_TestHFlag(efa, BM_ELEM_TAG)) + if (!BM_elem_flag_test(efa, BM_ELEM_TAG)) continue; tface= CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); @@ -2971,10 +2971,10 @@ static int snap_uvs_to_adjacent_unselected(Scene *scene, Image *ima, Object *obe continue; BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { - if (BM_GetIndex(l->v) >= 0 && + if (BM_elem_index_get(l->v) >= 0 && (!uvedit_uv_selected(em, scene, l))) { luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV); - add_v2_v2(&coords[BM_GetIndex(l->v) * 2], luv->uv); + add_v2_v2(&coords[BM_elem_index_get(l->v) * 2], luv->uv); change = 1; } } @@ -2989,7 +2989,7 @@ static int snap_uvs_to_adjacent_unselected(Scene *scene, Image *ima, Object *obe /* copy the averaged unselected UVs back to the selected UVs */ BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (!BM_TestHFlag(efa, BM_ELEM_TAG)) + if (!BM_elem_flag_test(efa, BM_ELEM_TAG)) continue; tface= CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); @@ -2997,10 +2997,10 @@ static int snap_uvs_to_adjacent_unselected(Scene *scene, Image *ima, Object *obe continue; BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { - if (uvedit_uv_selected(em, scene, l) && BM_GetIndex(l->v) >= 0 - && (users = usercount[BM_GetIndex(l->v)])) { + if (uvedit_uv_selected(em, scene, l) && BM_elem_index_get(l->v) >= 0 + && (users = usercount[BM_elem_index_get(l->v)])) { luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV); - copy_v2_v2(luv->uv, &coords[BM_GetIndex(l->v) * 2]); + copy_v2_v2(luv->uv, &coords[BM_elem_index_get(l->v) * 2]); } } } @@ -3246,7 +3246,7 @@ static int hide_exec(bContext *C, wmOperator *op) } if (!luv) { - BM_Select(em->bm, efa, FALSE); + BM_elem_select_set(em->bm, efa, FALSE); uvedit_face_deselect(scene, em, efa); } } else if(em->selectmode == SCE_SELECT_FACE) { @@ -3254,7 +3254,7 @@ static int hide_exec(bContext *C, wmOperator *op) BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV); if (luv->flag & MLOOPUV_VERTSEL) { - BM_Select(em->bm, efa, FALSE); + BM_elem_select_set(em->bm, efa, FALSE); } luv->flag &= ~MLOOPUV_VERTSEL; } @@ -3262,7 +3262,7 @@ static int hide_exec(bContext *C, wmOperator *op) BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV); if (luv->flag & MLOOPUV_VERTSEL) { - BM_Select(em->bm, l->v, FALSE); + BM_elem_select_set(em->bm, l->v, FALSE); luv->flag &= ~MLOOPUV_VERTSEL; } } @@ -3319,8 +3319,8 @@ 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) { - if (!BM_TestHFlag(efa, BM_ELEM_HIDDEN) && !BM_TestHFlag(efa, BM_ELEM_SELECT)) { - BM_Select(em->bm, efa, TRUE); + if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN) && !BM_elem_flag_test(efa, BM_ELEM_SELECT)) { + BM_elem_select_set(em->bm, efa, TRUE); BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV); luv->flag |= MLOOPUV_VERTSEL; @@ -3332,10 +3332,10 @@ static int reveal_exec(bContext *C, wmOperator *UNUSED(op)) /* 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) { - if (!BM_TestHFlag(efa, BM_ELEM_HIDDEN) && !BM_TestHFlag(efa, BM_ELEM_SELECT)) { + 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) { - totsel += BM_TestHFlag(l->v, BM_ELEM_SELECT); + totsel += BM_elem_flag_test(l->v, BM_ELEM_SELECT); } if (!totsel) { @@ -3344,47 +3344,47 @@ static int reveal_exec(bContext *C, wmOperator *UNUSED(op)) luv->flag |= MLOOPUV_VERTSEL; } - BM_Select(em->bm, efa, TRUE); + BM_elem_select_set(em->bm, efa, TRUE); } } } } else { BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (!BM_TestHFlag(efa, BM_ELEM_HIDDEN) && !BM_TestHFlag(efa, BM_ELEM_SELECT)) { + 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) { - if (BM_TestHFlag(l->v, BM_ELEM_SELECT)==0) { + 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; } } - BM_Select(em->bm, efa, TRUE); + BM_elem_select_set(em->bm, efa, TRUE); } } } } } else if(em->selectmode == SCE_SELECT_FACE) { BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (!BM_TestHFlag(efa, BM_ELEM_HIDDEN) && !BM_TestHFlag(efa, BM_ELEM_SELECT)) { + 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) { luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV); luv->flag |= MLOOPUV_VERTSEL; } - BM_Select(em->bm, efa, TRUE); + BM_elem_select_set(em->bm, efa, TRUE); } } } else { BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (!BM_TestHFlag(efa, BM_ELEM_HIDDEN) && !BM_TestHFlag(efa, BM_ELEM_SELECT)) { + 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) { - if (BM_TestHFlag(l->v, BM_ELEM_SELECT)==0) { + 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; } } - BM_Select(em->bm, efa, TRUE); + BM_elem_select_set(em->bm, efa, TRUE); } } } @@ -3565,9 +3565,9 @@ static int seams_from_islands_exec(bContext *C, wmOperator *op) * mv2sep holds the last separator and is copied to mv2cache when a hit is first found */ UvMapVert *mv2cache = NULL, *mv2sep = NULL; - mvinit1 = vmap->vert[BM_GetIndex(editedge->v1)]; + mvinit1 = vmap->vert[BM_elem_index_get(editedge->v1)]; if(mark_seams) - BM_ClearHFlag(editedge, BM_ELEM_SEAM); + BM_elem_flag_clear(editedge, BM_ELEM_SEAM); for(mv1 = mvinit1; mv1 && !faces_separated; mv1 = mv1->next) { if(mv1->separate && commonFaces) @@ -3575,7 +3575,7 @@ static int seams_from_islands_exec(bContext *C, wmOperator *op) separated2 = 0; efa1 = EDBM_get_face_for_index(em, mv1->f); - mvinit2 = vmap->vert[BM_GetIndex(editedge->v2)]; + mvinit2 = vmap->vert[BM_elem_index_get(editedge->v2)]; for(mv2 = mvinit2; mv2; mv2 = mv2->next) { if(mv2->separate) @@ -3616,9 +3616,9 @@ static int seams_from_islands_exec(bContext *C, wmOperator *op) if(faces_separated) { if(mark_seams) - BM_SetHFlag(editedge, BM_ELEM_SEAM); + BM_elem_flag_set(editedge, BM_ELEM_SEAM); if(mark_sharp) - BM_SetHFlag(editedge, BM_ELEM_SHARP); + BM_elem_flag_set(editedge, BM_ELEM_SHARP); } } @@ -3667,7 +3667,7 @@ static int mark_seam_exec(bContext *C, wmOperator *UNUSED(op)) BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { BM_ITER(loop, &liter, bm, BM_LOOPS_OF_FACE, efa) { if(uvedit_edge_selected(em, scene, loop)) { - BM_SetHFlag(loop, BM_ELEM_SEAM); + BM_elem_flag_set(loop, BM_ELEM_SEAM); } } } diff --git a/source/blender/editors/uvedit/uvedit_unwrap_ops.c b/source/blender/editors/uvedit/uvedit_unwrap_ops.c index 9427eb87920..fcb7d1d323d 100644 --- a/source/blender/editors/uvedit/uvedit_unwrap_ops.c +++ b/source/blender/editors/uvedit/uvedit_unwrap_ops.c @@ -104,8 +104,8 @@ static int ED_uvedit_ensure_uvs(bContext *C, Scene *scene, Object *obedit) } if(em && em->bm->totface && !CustomData_has_layer(&em->bm->pdata, CD_MTEXPOLY)) { - BM_add_data_layer(em->bm, &em->bm->pdata, CD_MTEXPOLY); - BM_add_data_layer(em->bm, &em->bm->ldata, CD_MLOOPUV); + BM_data_layer_add(em->bm, &em->bm->pdata, CD_MTEXPOLY); + BM_data_layer_add(em->bm, &em->bm->ldata, CD_MLOOPUV); } if(!ED_uvedit_test(obedit)) { @@ -158,10 +158,10 @@ static int uvedit_have_selection(Scene *scene, BMEditMesh *em, short implicit) so we can cancel the operator early */ BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { if(scene->toolsettings->uv_flag & UV_SYNC_SELECTION) { - if(BM_TestHFlag(efa, BM_ELEM_HIDDEN)) + if(BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) continue; } - else if(BM_TestHFlag(efa, BM_ELEM_HIDDEN) || !BM_TestHFlag(efa, BM_ELEM_SELECT)) + 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) { @@ -196,7 +196,7 @@ static ParamHandle *construct_param_handle(Scene *scene, BMEditMesh *em, handle = param_construct_begin(); if(correct_aspect) { - efa = BM_get_actFace(em->bm, TRUE); + efa = BM_active_face_get(em->bm, TRUE); if(efa) { float aspx, aspy; @@ -210,7 +210,7 @@ static ParamHandle *construct_param_handle(Scene *scene, BMEditMesh *em, } /* we need the vert indices */ - BM_ElemIndex_Ensure(em->bm, BM_VERT); + BM_mesh_elem_index_ensure(em->bm, BM_VERT); BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { EditVert *v, *lastv, *firstv; @@ -223,7 +223,7 @@ static ParamHandle *construct_param_handle(Scene *scene, BMEditMesh *em, float *uv[4]; int lsel; - if((BM_TestHFlag(efa, BM_ELEM_HIDDEN)) || (sel && BM_TestHFlag(efa, BM_ELEM_SELECT)==0)) + if((BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) || (sel && BM_elem_flag_test(efa, BM_ELEM_SELECT)==0)) continue; /* tf= (MTexPoly *)CustomData_em_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); */ /* UNUSED */ @@ -279,9 +279,9 @@ static ParamHandle *construct_param_handle(Scene *scene, BMEditMesh *em, luvs[1] = CustomData_bmesh_get(&em->bm->ldata, ls[1]->head.data, CD_MLOOPUV); luvs[2] = CustomData_bmesh_get(&em->bm->ldata, ls[2]->head.data, CD_MLOOPUV); - vkeys[0] = (ParamKey)BM_GetIndex(ls[0]->v); - vkeys[1] = (ParamKey)BM_GetIndex(ls[1]->v); - vkeys[2] = (ParamKey)BM_GetIndex(ls[2]->v); + vkeys[0] = (ParamKey)BM_elem_index_get(ls[0]->v); + vkeys[1] = (ParamKey)BM_elem_index_get(ls[1]->v); + vkeys[2] = (ParamKey)BM_elem_index_get(ls[2]->v); co[0] = ls[0]->v->co; co[1] = ls[1]->v->co; @@ -308,10 +308,10 @@ static ParamHandle *construct_param_handle(Scene *scene, BMEditMesh *em, if(!implicit) { BM_ITER(eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) { - if(BM_TestHFlag(eed, BM_ELEM_SEAM)) { + if(BM_elem_flag_test(eed, BM_ELEM_SEAM)) { ParamKey vkeys[2]; - vkeys[0] = (ParamKey)BM_GetIndex(eed->v1); - vkeys[1] = (ParamKey)BM_GetIndex(eed->v2); + vkeys[0] = (ParamKey)BM_elem_index_get(eed->v1); + vkeys[1] = (ParamKey)BM_elem_index_get(eed->v2); param_edge_set_seam(handle, vkeys); } } @@ -890,7 +890,7 @@ static void uv_map_transform_center(Scene *scene, View3D *v3d, float *result, max[0]= max[1]= max[2]= -1e20f; BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if(BM_TestHFlag(efa, BM_ELEM_SELECT)) { + if(BM_elem_flag_test(efa, BM_ELEM_SELECT)) { BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { DO_MINMAX(l->v->co, min, max); } @@ -1022,7 +1022,7 @@ static void uv_transform_properties(wmOperatorType *ot, int radius) static void correct_uv_aspect(BMEditMesh *em) { - BMFace *efa= BM_get_actFace(em->bm, TRUE); + BMFace *efa= BM_active_face_get(em->bm, TRUE); BMLoop *l; BMIter iter, liter; MTexPoly *tf; @@ -1042,7 +1042,7 @@ static void correct_uv_aspect(BMEditMesh *em) BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); - if (!BM_TestHFlag(efa, BM_ELEM_SELECT) || BM_TestHFlag(efa, BM_ELEM_HIDDEN)) + 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) { @@ -1056,7 +1056,7 @@ static void correct_uv_aspect(BMEditMesh *em) BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); - if (!BM_TestHFlag(efa, BM_ELEM_SELECT)||BM_TestHFlag(efa, BM_ELEM_HIDDEN)) + 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) { @@ -1098,7 +1098,7 @@ static void uv_map_clip_correct(BMEditMesh *em, wmOperator *op) INIT_MINMAX2(min, max); BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (!BM_TestHFlag(efa, BM_ELEM_SELECT)) + if (!BM_elem_flag_test(efa, BM_ELEM_SELECT)) continue; BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { @@ -1117,7 +1117,7 @@ static void uv_map_clip_correct(BMEditMesh *em, wmOperator *op) dy= 1.0f/dy; BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (!BM_TestHFlag(efa, BM_ELEM_SELECT)) + if (!BM_elem_flag_test(efa, BM_ELEM_SELECT)) continue; BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { @@ -1131,7 +1131,7 @@ 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) { - if (!BM_TestHFlag(efa, BM_ELEM_SELECT)) + if (!BM_elem_flag_test(efa, BM_ELEM_SELECT)) continue; BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { @@ -1280,7 +1280,7 @@ static int uv_from_view_exec(bContext *C, wmOperator *op) uv_map_rotation_matrix(rotmat, rv3d, obedit, 90.0f, 0.0f, 1.0f); BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (!BM_TestHFlag(efa, BM_ELEM_SELECT)) + if (!BM_elem_flag_test(efa, BM_ELEM_SELECT)) continue; BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { @@ -1294,7 +1294,7 @@ static int uv_from_view_exec(bContext *C, wmOperator *op) if(uci) { BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (!BM_TestHFlag(efa, BM_ELEM_SELECT)) + if (!BM_elem_flag_test(efa, BM_ELEM_SELECT)) continue; BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { @@ -1310,7 +1310,7 @@ static int uv_from_view_exec(bContext *C, wmOperator *op) copy_m4_m4(rotmat, obedit->obmat); BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { - if (!BM_TestHFlag(efa, BM_ELEM_SELECT)) + if (!BM_elem_flag_test(efa, BM_ELEM_SELECT)) continue; BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { @@ -1457,7 +1457,7 @@ 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) { - if (!BM_TestHFlag(efa, BM_ELEM_SELECT)) + if (!BM_elem_flag_test(efa, BM_ELEM_SELECT)) continue; BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { @@ -1531,7 +1531,7 @@ static int cylinder_project_exec(bContext *C, wmOperator *op) BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) { tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); - if (!BM_TestHFlag(efa, BM_ELEM_SELECT)) + if (!BM_elem_flag_test(efa, BM_ELEM_SELECT)) continue; BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) { @@ -1597,7 +1597,7 @@ static int cube_project_exec(bContext *C, wmOperator *op) int first=1; /* tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); */ /* UNUSED */ - if (!BM_TestHFlag(efa, BM_ELEM_SELECT)) + if (!BM_elem_flag_test(efa, BM_ELEM_SELECT)) continue; axis_dominant_v3(&cox, &coy, efa->no); diff --git a/source/blender/modifiers/intern/MOD_array.c b/source/blender/modifiers/intern/MOD_array.c index 5c020f69cd5..cbf7d0d125c 100644 --- a/source/blender/modifiers/intern/MOD_array.c +++ b/source/blender/modifiers/intern/MOD_array.c @@ -299,21 +299,21 @@ static DerivedMesh *arrayModifier_doArray(ArrayModifierData *amd, BMO_push(em->bm, NULL); bmesh_begin_edit(em->bm, 0); - BMO_Init_Op(em->bm, &weldop, "weldverts"); - BMO_InitOpf(em->bm, &op, "dupe geom=%avef"); + BMO_op_init(em->bm, &weldop, "weldverts"); + BMO_op_initf(em->bm, &op, "dupe geom=%avef"); oldop = op; for (j=0; j < count - 1; j++) { BMVert *v, *v2; BMOpSlot *s1; BMOpSlot *s2; - BMO_InitOpf(em->bm, &op, "dupe geom=%s", &oldop, j==0 ? "geom" : "newout"); - BMO_Exec_Op(em->bm, &op); + BMO_op_initf(em->bm, &op, "dupe geom=%s", &oldop, j==0 ? "geom" : "newout"); + BMO_op_exec(em->bm, &op); - s1 = BMO_GetSlot(&op, "geom"); - s2 = BMO_GetSlot(&op, "newout"); + s1 = BMO_slot_get(&op, "geom"); + s2 = BMO_slot_get(&op, "newout"); - BMO_CallOpf(em->bm, "transform mat=%m4 verts=%s", offset, &op, "newout"); + BMO_op_callf(em->bm, "transform mat=%m4 verts=%s", offset, &op, "newout"); #define _E(s, i) ((BMVert**)(s)->data.buf)[i] @@ -324,18 +324,18 @@ static DerivedMesh *arrayModifier_doArray(ArrayModifierData *amd, BMVert *v, *v2; BMHeader *h; - BMO_InitOpf(em->bm, &findop, + BMO_op_initf(em->bm, &findop, "finddoubles verts=%av dist=%f keepverts=%s", amd->merge_dist, &op, "geom"); i = 0; BMO_ITER(h, &oiter, em->bm, &op, "geom", BM_ALL) { - BM_SetIndex(h, i); /* set_dirty */ + BM_elem_index_set(h, i); /* set_dirty */ i++; } BMO_ITER(h, &oiter, em->bm, &op, "newout", BM_ALL) { - BM_SetIndex(h, i); /* set_dirty */ + BM_elem_index_set(h, i); /* set_dirty */ i++; } /* above loops over all, so set all to dirty, if this is somehow @@ -343,19 +343,19 @@ static DerivedMesh *arrayModifier_doArray(ArrayModifierData *amd, em->bm->elem_index_dirty |= BM_VERT | BM_EDGE | BM_FACE; - BMO_Exec_Op(em->bm, &findop); + BMO_op_exec(em->bm, &findop); indexLen = i; indexMap = MEM_callocN(sizeof(int)*indexLen, "indexMap"); /*element type argument doesn't do anything here*/ BMO_ITER(v, &oiter, em->bm, &findop, "targetmapout", 0) { - v2 = BMO_IterMapValp(&oiter); + v2 = BMO_iter_map_value_p(&oiter); - indexMap[BM_GetIndex(v)] = BM_GetIndex(v2)+1; + indexMap[BM_elem_index_get(v)] = BM_elem_index_get(v2)+1; } - BMO_Finish_Op(em->bm, &findop); + BMO_op_finish(em->bm, &findop); } /*generate merge mappping using index map. we do this by using the @@ -368,22 +368,22 @@ static DerivedMesh *arrayModifier_doArray(ArrayModifierData *amd, v = E(i); v2 = E(indexMap[i]-1); - BMO_Insert_MapPointer(em->bm, &weldop, "targetmap", v, v2); + BMO_slot_map_ptr_insert(em->bm, &weldop, "targetmap", v, v2); } #undef E #undef _E - BMO_Finish_Op(em->bm, &oldop); + BMO_op_finish(em->bm, &oldop); oldop = op; } - if (j > 0) BMO_Finish_Op(em->bm, &op); + if (j > 0) BMO_op_finish(em->bm, &op); if (amd->flags & MOD_ARR_MERGE) - BMO_Exec_Op(em->bm, &weldop); + BMO_op_exec(em->bm, &weldop); - BMO_Finish_Op(em->bm, &weldop); + BMO_op_finish(em->bm, &weldop); /* Bump the stack level back down to match the adjustment up above */ BMO_pop(em->bm); diff --git a/source/blender/modifiers/intern/MOD_bevel.c b/source/blender/modifiers/intern/MOD_bevel.c index 363f0f4079d..c0cd28ae27a 100644 --- a/source/blender/modifiers/intern/MOD_bevel.c +++ b/source/blender/modifiers/intern/MOD_bevel.c @@ -126,7 +126,7 @@ static DerivedMesh *applyModifier(ModifierData *md, struct Object *ob, em = CDDM_To_BMesh(ob, dm, NULL, FALSE); bm = em->bm; - BM_Compute_Normals(bm); + BM_mesh_normals_update(bm); BMO_push(bm, NULL); if (bmd->lim_flags & BME_BEVEL_ANGLE) { @@ -137,7 +137,7 @@ static DerivedMesh *applyModifier(ModifierData *md, struct Object *ob, (l2= e->l->radial_next) != l1) { if (dot_v3v3(l1->f->no, l2->f->no) < threshold) { - BMO_SetFlag(bm, e, EDGE_MARK); + BMO_elem_flag_set(bm, e, EDGE_MARK); } } } @@ -145,11 +145,11 @@ static DerivedMesh *applyModifier(ModifierData *md, struct Object *ob, else { /* crummy, is there a way just to operator on all? - campbell */ BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) { - BMO_SetFlag(bm, e, EDGE_MARK); + BMO_elem_flag_set(bm, e, EDGE_MARK); } } - BMO_CallOpf(bm, "bevel geom=%fe percent=%f use_even=%i use_dist=%i", + BMO_op_callf(bm, "bevel geom=%fe percent=%f use_even=%i use_dist=%i", EDGE_MARK, bmd->value, (bmd->flags & BME_BEVEL_EVEN)!=0, (bmd->flags & BME_BEVEL_DIST)!=0); BMO_pop(bm); diff --git a/source/blender/modifiers/intern/MOD_edgesplit.c b/source/blender/modifiers/intern/MOD_edgesplit.c index e3f4e50e243..db39be12bca 100644 --- a/source/blender/modifiers/intern/MOD_edgesplit.c +++ b/source/blender/modifiers/intern/MOD_edgesplit.c @@ -74,7 +74,7 @@ static DerivedMesh *doEdgeSplit(DerivedMesh *dm, EdgeSplitModifierData *emd, Obj em = CDDM_To_BMesh(ob, dm, NULL, FALSE); bm = em->bm; - BM_Compute_Normals(bm); + BM_mesh_normals_update(bm); BMO_push(bm, NULL); if (emd->flags & MOD_EDGESPLIT_FROMANGLE) { @@ -85,7 +85,7 @@ static DerivedMesh *doEdgeSplit(DerivedMesh *dm, EdgeSplitModifierData *emd, Obj (l2= e->l->radial_next) != l1) { if (dot_v3v3(l1->f->no, l2->f->no) < threshold) { - BMO_SetFlag(bm, e, EDGE_MARK); + BMO_elem_flag_set(bm, e, EDGE_MARK); } } } @@ -93,12 +93,12 @@ static DerivedMesh *doEdgeSplit(DerivedMesh *dm, EdgeSplitModifierData *emd, Obj if (emd->flags & MOD_EDGESPLIT_FROMFLAG) { BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) { - if (BM_TestHFlag(e, BM_ELEM_SHARP)) - BMO_SetFlag(bm, e, EDGE_MARK); + if (BM_elem_flag_test(e, BM_ELEM_SHARP)) + BMO_elem_flag_set(bm, e, EDGE_MARK); } } - BMO_CallOpf(bm, "edgesplit edges=%fe", EDGE_MARK); + BMO_op_callf(bm, "edgesplit edges=%fe", EDGE_MARK); BMO_pop(bm); |