since enough bmesh operations can also take advantage of direct index lookups on verts/edges/faces.
developers note:
- EDBM_index_arrays_init/ensure/free -> BM_mesh_elem_table_ensure/init/free
- EDBM_vert/edge/face_at_index -> BM_vert/edge/face_at_index
- EDBM_uv_element_map_create/free -> BM_uv_element_map_create/free
- ED_uv_element_get -> BM_uv_element_get
unsigned char (*derivedFaceColor)[4];
int derivedFaceColorLen;
- /* index tables, to map indices to elements via
- * EDBM_index_arrays_init and associated functions. don't
- * touch this or read it directly.*/
- struct BMVert **vert_index;
- struct BMEdge **edge_index;
- struct BMFace **face_index;
-
/*selection mode*/
short selectmode;
short mat_nr;
return;
}
- ev = bmdm->em->vert_index[index]; /* should be EDBM_vert_at_index() */
+ BLI_assert((bm->elem_table_dirty & BM_VERT) == 0);
+ ev = bm->vtable[index]; /* should be BM_vert_at_index() */
// ev = BM_vert_at_index(bm, index); /* warning, does list loop, _not_ ideal */
bmvert_to_mvert(bm, ev, r_vert);
copy_v3_v3(r_co, bmdm->vertexCos[index]);
}
else {
- BMVert *ev = bmdm->em->vert_index[index]; /* should be EDBM_vert_at_index() */
+ BMVert *ev;
+
+ BLI_assert((bm->elem_table_dirty & BM_VERT) == 0);
+ ev = bm->vtable[index]; /* should be BM_vert_at_index() */
// ev = BM_vert_at_index(bm, index); /* warning, does list loop, _not_ ideal */
copy_v3_v3(r_co, ev->co);
}
copy_v3_v3(r_no, bmdm->vertexNos[index]);
}
else {
- BMVert *ev = bmdm->em->vert_index[index]; /* should be EDBM_vert_at_index() */
+ BMVert *ev;
+
+ BLI_assert((bm->elem_table_dirty & BM_VERT) == 0);
+ ev = bm->vtable[index]; /* should be BM_vert_at_index() */
// ev = BM_vert_at_index(bm, index); /* warning, does list loop, _not_ ideal */
copy_v3_v3(r_no, ev->no);
}
copy_v3_v3(r_no, bmdm->polyNos[index]);
}
else {
- BMFace *efa = bmdm->em->face_index[index]; /* should be EDBM_vert_at_index() */
+ BMFace *efa;
+
+ BLI_assert((bm->elem_table_dirty & BM_FACE) == 0);
+ efa = bm->ftable[index]; /* should be BM_vert_at_index() */
// efa = BM_face_at_index(bm, index); /* warning, does list loop, _not_ ideal */
copy_v3_v3(r_no, efa->no);
}
return;
}
- e = bmdm->em->edge_index[index]; /* should be EDBM_edge_at_index() */
+ BLI_assert((bm->elem_table_dirty & BM_EDGE) == 0);
+ e = bm->etable[index]; /* should be BM_edge_at_index() */
// e = BM_edge_at_index(bm, index); /* warning, does list loop, _not_ ideal */
r_edge->flag = BM_edge_flag_to_mflag(e);
* used.*/
em_copy->looptris = NULL;
- em_copy->vert_index = NULL;
- em_copy->edge_index = NULL;
- em_copy->face_index = NULL;
-
return em_copy;
}
if (em->looptris) MEM_freeN(em->looptris);
- if (em->vert_index) MEM_freeN(em->vert_index);
- if (em->edge_index) MEM_freeN(em->edge_index);
- if (em->face_index) MEM_freeN(em->face_index);
-
if (em->bm)
BM_mesh_free(em->bm);
}
* \{ */
-/* ngon version wip, based on EDBM_uv_vert_map_create */
+/* ngon version wip, based on BM_uv_vert_map_create */
/* this replaces the non bmesh function (in trunk) which takes MTFace's, if we ever need it back we could
* but for now this replaces it because its unused. */
* BM_LOOP isn't handled so far. */
char elem_index_dirty;
+ /* flag array table as being dirty so we know when its safe to use it,
+ * or when it needs to be re-created */
+ char elem_table_dirty;
+
+
/* element pools */
struct BLI_mempool *vpool, *epool, *lpool, *fpool;
+ /* mempool lookup tables (optional)
+ * index tables, to map indices to elements via
+ * BM_mesh_elem_table_ensure and associated functions. don't
+ * touch this or read it directly.\
+ * Use BM_mesh_elem_table_ensure(), BM_vert/edge/face_at_index() */
+ BMVert **vtable;
+ BMEdge **etable;
+ BMFace **ftable;
+
+ /* size of allocated tables */
+ int vtable_tot;
+ int etable_tot;
+ int ftable_tot;
+
/* operator api stuff (must be all NULL or all alloc'd) */
struct BLI_mempool *vtoolflagpool, *etoolflagpool, *ftoolflagpool;
/* disallow this flag for verts - its meaningless */
BLI_assert((create_flag & BM_CREATE_NO_DOUBLE) == 0);
- bm->elem_index_dirty |= BM_VERT; /* may add to middle of the pool */
+ /* may add to middle of the pool */
+ bm->elem_index_dirty |= BM_VERT;
+ bm->elem_table_dirty |= BM_VERT;
bm->totvert++;
BM_elem_index_set(e, -1); /* set_ok_invalid */
#endif
- bm->elem_index_dirty |= BM_EDGE; /* may add to middle of the pool */
+ /* may add to middle of the pool */
+ bm->elem_index_dirty |= BM_EDGE;
+ bm->elem_table_dirty |= BM_EDGE;
bm->totedge++;
BM_elem_index_set(f, -1); /* set_ok_invalid */
#endif
- bm->elem_index_dirty |= BM_FACE; /* may add to middle of the pool */
+ /* may add to middle of the pool */
+ bm->elem_index_dirty |= BM_FACE;
+ bm->elem_table_dirty |= BM_FACE;
bm->totface++;
{
bm->totvert--;
bm->elem_index_dirty |= BM_VERT;
+ bm->elem_table_dirty |= BM_VERT;
BM_select_history_remove(bm, v);
{
bm->totedge--;
bm->elem_index_dirty |= BM_EDGE;
+ bm->elem_table_dirty |= BM_EDGE;
BM_select_history_remove(bm, (BMElem *)e);
bm->totface--;
bm->elem_index_dirty |= BM_FACE;
+ bm->elem_table_dirty |= BM_FACE;
BM_select_history_remove(bm, (BMElem *)f);
BLI_mempool_destroy(bm->lpool);
BLI_mempool_destroy(bm->fpool);
+ if (bm->vtable) MEM_freeN(bm->vtable);
+ if (bm->etable) MEM_freeN(bm->etable);
+ if (bm->ftable) MEM_freeN(bm->ftable);
+
/* destroy flag pool */
BM_mesh_elem_toolflags_clear(bm);
}
+/* debug check only - no need to optimize */
+#ifndef NDEBUG
+bool BM_mesh_elem_table_check(BMesh *bm)
+{
+ BMIter iter;
+ BMElem *ele;
+ int i;
+
+ if (bm->vtable && ((bm->elem_table_dirty & BM_VERT) == 0)) {
+ BM_ITER_MESH_INDEX (ele, &iter, bm, BM_VERTS_OF_MESH, i) {
+ if (ele != (BMElem *)bm->vtable[i]) {
+ return false;
+ }
+ }
+ }
+
+ if (bm->etable && ((bm->elem_table_dirty & BM_EDGE) == 0)) {
+ BM_ITER_MESH_INDEX (ele, &iter, bm, BM_EDGES_OF_MESH, i) {
+ if (ele != (BMElem *)bm->etable[i]) {
+ return false;
+ }
+ }
+ }
+
+ if (bm->ftable && ((bm->elem_table_dirty & BM_FACE) == 0)) {
+ BM_ITER_MESH_INDEX (ele, &iter, bm, BM_FACES_OF_MESH, i) {
+ if (ele != (BMElem *)bm->ftable[i]) {
+ return false;
+ }
+ }
+ }
+
+ return true;
+}
+#endif
+
+
+
+void BM_mesh_elem_table_ensure(BMesh *bm, const char htype)
+{
+ /* assume if the array is non-null then its valid and no need to recalc */
+ const char htype_needed = (((bm->vtable && ((bm->elem_table_dirty & BM_VERT) == 0)) ? 0 : BM_VERT) |
+ ((bm->etable && ((bm->elem_table_dirty & BM_EDGE) == 0)) ? 0 : BM_EDGE) |
+ ((bm->ftable && ((bm->elem_table_dirty & BM_FACE) == 0)) ? 0 : BM_FACE)) & htype;
+
+ BLI_assert((htype & ~BM_ALL_NOLOOP) == 0);
+
+ /* in debug mode double check we didn't need to recalculate */
+ BLI_assert(BM_mesh_elem_table_check(bm) == true);
+
+ if (htype_needed & BM_VERT) {
+ if (bm->vtable && bm->totvert <= bm->vtable_tot && bm->totvert * 2 >= bm->vtable_tot) {
+ /* pass (re-use the array) */
+ }
+ else {
+ if (bm->vtable)
+ MEM_freeN(bm->vtable);
+ bm->vtable = MEM_mallocN(sizeof(void **) * bm->totvert, "bm->vtable");
+ bm->vtable_tot = bm->totvert;
+ }
+ bm->elem_table_dirty &= ~BM_VERT;
+ }
+ if (htype_needed & BM_EDGE) {
+ if (bm->etable && bm->totedge <= bm->etable_tot && bm->totedge * 2 >= bm->etable_tot) {
+ /* pass (re-use the array) */
+ }
+ else {
+ if (bm->etable)
+ MEM_freeN(bm->etable);
+ bm->etable = MEM_mallocN(sizeof(void **) * bm->totedge, "bm->etable");
+ bm->etable_tot = bm->totedge;
+ }
+ bm->elem_table_dirty &= ~BM_EDGE;
+ }
+ if (htype_needed & BM_FACE) {
+ if (bm->ftable && bm->totface <= bm->ftable_tot && bm->totface * 2 >= bm->ftable_tot) {
+ /* pass (re-use the array) */
+ }
+ else {
+ if (bm->ftable)
+ MEM_freeN(bm->ftable);
+ bm->ftable = MEM_mallocN(sizeof(void **) * bm->totface, "bm->ftable");
+ bm->ftable_tot = bm->totface;
+ }
+ bm->elem_table_dirty &= ~BM_FACE;
+ }
+
+#pragma omp parallel sections if (bm->totvert + bm->totedge + bm->totface >= BM_OMP_LIMIT)
+ {
+#pragma omp section
+ {
+ if (htype_needed & BM_VERT) {
+ BM_iter_as_array(bm, BM_VERTS_OF_MESH, NULL, (void **)bm->vtable, bm->totvert);
+ }
+ }
+#pragma omp section
+ {
+ if (htype_needed & BM_EDGE) {
+ BM_iter_as_array(bm, BM_EDGES_OF_MESH, NULL, (void **)bm->etable, bm->totedge);
+ }
+ }
+#pragma omp section
+ {
+ if (htype_needed & BM_FACE) {
+ BM_iter_as_array(bm, BM_FACES_OF_MESH, NULL, (void **)bm->ftable, bm->totface);
+ }
+ }
+ }
+}
+
+/* use BM_mesh_elem_table_ensure where possible to avoid full rebuild */
+void BM_mesh_elem_table_init(BMesh *bm, const char htype)
+{
+ BLI_assert((htype & ~BM_ALL_NOLOOP) == 0);
+
+ /* force recalc */
+ BM_mesh_elem_table_free(bm, BM_ALL_NOLOOP);
+ BM_mesh_elem_table_ensure(bm, htype);
+}
+
+void BM_mesh_elem_table_free(BMesh *bm, const char htype)
+{
+ if (htype & BM_VERT) {
+ MEM_SAFE_FREE(bm->vtable);
+ }
+
+ if (htype & BM_EDGE) {
+ MEM_SAFE_FREE(bm->etable);
+ }
+
+ if (htype & BM_FACE) {
+ MEM_SAFE_FREE(bm->ftable);
+ }
+}
+
+BMVert *BM_vert_at_index(BMesh *bm, int index)
+{
+ BLI_assert((index >= 0) && (index < bm->totvert));
+ BLI_assert((bm->elem_table_dirty & BM_VERT) == 0);
+ return bm->vtable[index];
+}
+
+BMEdge *BM_edge_at_index(BMesh *bm, int index)
+{
+ BLI_assert((index >= 0) && (index < bm->totedge));
+ BLI_assert((bm->elem_table_dirty & BM_EDGE) == 0);
+ return bm->etable[index];
+}
+
+BMFace *BM_face_at_index(BMesh *bm, int index)
+{
+ BLI_assert((index >= 0) && (index < bm->totface));
+ BLI_assert((bm->elem_table_dirty & BM_FACE) == 0);
+ return bm->ftable[index];
+}
+
+
+BMVert *BM_vert_at_index_find(BMesh *bm, const int index)
+{
+ return BLI_mempool_findelem(bm->vpool, index);
+}
+
+BMEdge *BM_edge_at_index_find(BMesh *bm, const int index)
+{
+ return BLI_mempool_findelem(bm->epool, index);
+}
+
+BMFace *BM_face_at_index_find(BMesh *bm, const int index)
+{
+ return BLI_mempool_findelem(bm->fpool, index);
+}
+
+
/**
* Return the amount of element of type 'type' in a given bmesh.
*/
if (fptr_map)
BLI_ghash_free(fptr_map, NULL, NULL);
}
-
-BMVert *BM_vert_at_index_find(BMesh *bm, const int index)
-{
- return BLI_mempool_findelem(bm->vpool, index);
-}
-
-BMEdge *BM_edge_at_index_find(BMesh *bm, const int index)
-{
- return BLI_mempool_findelem(bm->epool, index);
-}
-
-BMFace *BM_face_at_index_find(BMesh *bm, const int index)
-{
- return BLI_mempool_findelem(bm->fpool, index);
-}
void BM_mesh_elem_index_ensure(BMesh *bm, const char hflag);
void BM_mesh_elem_index_validate(BMesh *bm, const char *location, const char *func,
const char *msg_a, const char *msg_b);
-int BM_mesh_elem_count(BMesh *bm, const char htype);
-void BM_mesh_remap(BMesh *bm, int *vert_idx, int *edge_idx, int *face_idx);
+#ifndef NDEBUG
+bool BM_mesh_elem_table_check(BMesh *em);
+#endif
+
+void BM_mesh_elem_table_ensure(BMesh *bm, const char htype);
+void BM_mesh_elem_table_init(BMesh *bm, const char htype);
+void BM_mesh_elem_table_free(BMesh *bm, const char htype);
+
+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);
BMVert *BM_vert_at_index_find(BMesh *bm, const int index);
BMEdge *BM_edge_at_index_find(BMesh *bm, const int index);
BMFace *BM_face_at_index_find(BMesh *bm, const int index);
+// XXX
+
+int BM_mesh_elem_count(BMesh *bm, const char htype);
+
+void BM_mesh_remap(BMesh *bm, int *vert_idx, int *edge_idx, int *face_idx);
+
typedef struct BMAllocTemplate {
int totvert, totedge, totloop, totface;
} BMAllocTemplate;
void EDBM_mesh_load(struct Object *ob);
struct DerivedMesh *EDBM_mesh_deform_dm_get(struct BMEditMesh *em);
-void EDBM_index_arrays_ensure(struct BMEditMesh *em, const char htype);
-void EDBM_index_arrays_init(struct BMEditMesh *em, const char htype);
-void EDBM_index_arrays_free(struct BMEditMesh *em);
-#ifndef NDEBUG
-bool EDBM_index_arrays_check(struct BMEditMesh *em);
-#endif
-struct BMVert *EDBM_vert_at_index(struct BMEditMesh *em, int index);
-struct BMEdge *EDBM_edge_at_index(struct BMEditMesh *em, int index);
-struct BMFace *EDBM_face_at_index(struct BMEditMesh *em, int index);
-
/* flushes based on the current select mode. if in vertex select mode,
* verts select/deselect edges and faces, if in edge select mode,
* edges select/deselect faces and vertices, and in face select mode faces select/deselect
void EDBM_update_generic(struct BMEditMesh *em, const bool do_tessface, const bool is_destructive);
-struct UvElementMap *EDBM_uv_element_map_create(struct BMEditMesh *em, const bool selected, const bool do_islands);
-void EDBM_uv_element_map_free(struct UvElementMap *vmap);
-struct UvElement *ED_uv_element_get(struct UvElementMap *map, struct BMFace *efa, struct BMLoop *l);
+struct UvElementMap *BM_uv_element_map_create(struct BMesh *em, const bool selected, const bool do_islands);
+void BM_uv_element_map_free(struct UvElementMap *vmap);
+struct UvElement *BM_uv_element_get(struct UvElementMap *map, struct BMFace *efa, struct BMLoop *l);
bool EDBM_mtexpoly_check(struct BMEditMesh *em);
struct MTexPoly *EDBM_mtexpoly_active_get(struct BMEditMesh *em, struct BMFace **r_act_efa, const bool sloppy, const bool selected);
-void EDBM_uv_vert_map_free(struct UvVertMap *vmap);
-struct UvMapVert *EDBM_uv_vert_map_at_index(struct UvVertMap *vmap, unsigned int v);
-struct UvVertMap *EDBM_uv_vert_map_create(struct BMEditMesh *em, bool use_select, const float limit[2]);
+void BM_uv_vert_map_free(struct UvVertMap *vmap);
+struct UvMapVert *BM_uv_vert_map_at_index(struct UvVertMap *vmap, unsigned int v);
+struct UvVertMap *BM_uv_vert_map_create(struct BMesh *bm, bool use_select, const float limit[2]);
void EDBM_flag_enable_all(struct BMEditMesh *em, const char hflag);
void EDBM_flag_disable_all(struct BMEditMesh *em, const char hflag);
if (em) {
if (skip_em_vert_array_init == false) {
- EDBM_index_arrays_ensure(em, BM_VERT);
+ BM_mesh_elem_table_ensure(em->bm, BM_VERT);
}
}
if ((a == totvert) || (topo_pairs[a - 1].hash != topo_pairs[a].hash)) {
if (a - last == 2) {
if (em) {
- index_lookup[topo_pairs[a - 1].v_index] = (intptr_t)EDBM_vert_at_index(em, topo_pairs[a - 2].v_index);
- index_lookup[topo_pairs[a - 2].v_index] = (intptr_t)EDBM_vert_at_index(em, topo_pairs[a - 1].v_index);
+ index_lookup[topo_pairs[a - 1].v_index] = (intptr_t)BM_vert_at_index(em->bm, topo_pairs[a - 2].v_index);
+ index_lookup[topo_pairs[a - 2].v_index] = (intptr_t)BM_vert_at_index(em->bm, topo_pairs[a - 1].v_index);
}
else {
index_lookup[topo_pairs[a - 1].v_index] = topo_pairs[a - 2].v_index;
}
if (dm) {
- EDBM_index_arrays_ensure(lcd->em, BM_VERT);
+ BM_mesh_elem_table_ensure(lcd->em->bm, BM_VERT);
}
BMW_init(&walker, em->bm, BMW_EDGERING,
else {
const int e_index = RNA_int_get(op->ptr, "edge_index");
BMEdge *e;
- EDBM_index_arrays_ensure(lcd->em, BM_EDGE);
- e = EDBM_edge_at_index(lcd->em, e_index);
+ BM_mesh_elem_table_ensure(lcd->em->bm, BM_EDGE);
+ e = BM_edge_at_index(lcd->em->bm, e_index);
loopcut_update_edge(lcd, e, 0);
}
EDBM_verts_mirror_cache_begin_ex(em, axis, true, true, use_topology, thresh, index);
- EDBM_index_arrays_ensure(em, BM_VERT);
+ BM_mesh_elem_table_ensure(bm, BM_VERT);
BM_mesh_elem_hflag_disable_all(bm, BM_VERT, BM_ELEM_TAG, false);
int i_mirr = index[i];
if (i_mirr != -1) {
- BMVert *v_mirr = EDBM_vert_at_index(em, index[i]);
+ BMVert *v_mirr = BM_vert_at_index(bm, index[i]);
if (v != v_mirr) {
float co[3], co_mirr[3];
BKE_editmesh_free(em);
}
-
-void EDBM_index_arrays_ensure(BMEditMesh *em, const char htype)
-{
- /* assume if the array is non-null then its valid and no need to recalc */
- const char htype_needed = ((em->vert_index ? 0 : BM_VERT) |
- (em->edge_index ? 0 : BM_EDGE) |
- (em->face_index ? 0 : BM_FACE)) & htype;
-
- BLI_assert((htype & ~BM_ALL_NOLOOP) == 0);
-
- /* in debug mode double check we didn't need to recalculate */
- BLI_assert(EDBM_index_arrays_check(em) == true);
-
- if (htype_needed & BM_VERT) {
- em->vert_index = MEM_mallocN(sizeof(void **) * em->bm->totvert, "em->vert_index");
- }
- if (htype_needed & BM_EDGE) {
- em->edge_index = MEM_mallocN(sizeof(void **) * em->bm->totedge, "em->edge_index");
- }
- if (htype_needed & BM_FACE) {
- em->face_index = MEM_mallocN(sizeof(void **) * em->bm->totface, "em->face_index");
- }
-
-#pragma omp parallel sections if (em->bm->totvert + em->bm->totedge + em->bm->totface >= BM_OMP_LIMIT)
- {
-#pragma omp section
- {
- if (htype_needed & BM_VERT) {
- BM_iter_as_array(em->bm, BM_VERTS_OF_MESH, NULL, (void **)em->vert_index, em->bm->totvert);
- }
- }
-#pragma omp section
- {
- if (htype_needed & BM_EDGE) {
- BM_iter_as_array(em->bm, BM_EDGES_OF_MESH, NULL, (void **)em->edge_index, em->bm->totedge);
- }
- }
-#pragma omp section
- {
- if (htype_needed & BM_FACE) {
- BM_iter_as_array(em->bm, BM_FACES_OF_MESH, NULL, (void **)em->face_index, em->bm->totface);
- }
- }
- }
-}
-
-/* use EDBM_index_arrays_ensure where possible to avoid full rebuild */
-void EDBM_index_arrays_init(BMEditMesh *em, const char htype)
-{
- BLI_assert((htype & ~BM_ALL_NOLOOP) == 0);
-
- /* force recalc */
- EDBM_index_arrays_free(em);
- EDBM_index_arrays_ensure(em, htype);
-}
-
-void EDBM_index_arrays_free(BMEditMesh *em)
-{
- if (em->vert_index) {
- MEM_freeN(em->vert_index);
- em->vert_index = NULL;
- }
-
- if (em->edge_index) {
- MEM_freeN(em->edge_index);
- em->edge_index = NULL;
- }
-
- if (em->face_index) {
- MEM_freeN(em->face_index);
- em->face_index = NULL;
- }
-}
-
-/* debug check only - no need to optimize */
-#ifndef NDEBUG
-bool EDBM_index_arrays_check(BMEditMesh *em)
-{
- BMIter iter;
- BMElem *ele;
- int i;
-
- if (em->vert_index) {
- BM_ITER_MESH_INDEX (ele, &iter, em->bm, BM_VERTS_OF_MESH, i) {
- if (ele != (BMElem *)em->vert_index[i]) {
- return false;
- }
- }
- }
-
- if (em->edge_index) {
- BM_ITER_MESH_INDEX (ele, &iter, em->bm, BM_EDGES_OF_MESH, i) {
- if (ele != (BMElem *)em->edge_index[i]) {
- return false;
- }
- }
- }
-
- if (em->face_index) {
- BM_ITER_MESH_INDEX (ele, &iter, em->bm, BM_FACES_OF_MESH, i) {
- if (ele != (BMElem *)em->face_index[i]) {
- return false;
- }
- }
- }
-
- return true;
-}
-#endif
-
-BMVert *EDBM_vert_at_index(BMEditMesh *em, int index)
-{
- BLI_assert((index >= 0) && (index < em->bm->totvert));
- return em->vert_index[index];
-}
-
-BMEdge *EDBM_edge_at_index(BMEditMesh *em, int index)
-{
- BLI_assert((index >= 0) && (index < em->bm->totedge));
- return em->edge_index[index];
-}
-
-BMFace *EDBM_face_at_index(BMEditMesh *em, int index)
-{
- BLI_assert((index >= 0) && (index < em->bm->totface));
- return em->face_index[index];
-}
-
void EDBM_selectmode_flush_ex(BMEditMesh *em, const short selectmode)
{
BM_mesh_select_mode_flush_ex(em->bm, selectmode);
/**
* Return a new UVVertMap from the editmesh
*/
-UvVertMap *EDBM_uv_vert_map_create(BMEditMesh *em, bool use_select, const float limit[2])
+UvVertMap *BM_uv_vert_map_create(BMesh *bm, bool use_select, const float limit[2])
{
BMVert *ev;
BMFace *efa;
MLoopUV *luv;
unsigned int a;
int totverts, i, totuv;
- const int cd_loop_uv_offset = CustomData_get_offset(&em->bm->ldata, CD_MLOOPUV);
+ const int cd_loop_uv_offset = CustomData_get_offset(&bm->ldata, CD_MLOOPUV);
- BM_mesh_elem_index_ensure(em->bm, BM_VERT | BM_FACE);
+ BM_mesh_elem_index_ensure(bm, BM_VERT | BM_FACE);
- totverts = em->bm->totvert;
+ totverts = bm->totvert;
totuv = 0;
/* generate UvMapVert array */
- BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
+ BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
if ((use_select == false) || BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
totuv += efa->len;
}
}
a = 0;
- BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
+ BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
if ((use_select == false) || BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
i = 0;
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
/* sort individual uvs for each vert */
a = 0;
- BM_ITER_MESH (ev, &iter, em->bm, BM_VERTS_OF_MESH) {
+ BM_ITER_MESH (ev, &iter, bm, BM_VERTS_OF_MESH) {
UvMapVert *newvlist = NULL, *vlist = vmap->vert[a];
UvMapVert *iterv, *v, *lastv, *next;
float *uv, *uv2, uvdiff[2];
v->next = newvlist;
newvlist = v;
- efa = EDBM_face_at_index(em, v->f);
- /* tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); */ /* UNUSED */
+ efa = BM_face_at_index(bm, v->f);
+ /* tf = CustomData_bmesh_get(&bm->pdata, efa->head.data, CD_MTEXPOLY); */ /* UNUSED */
- l = BM_iter_at_index(em->bm, BM_LOOPS_OF_FACE, efa, v->tfindex);
+ l = BM_iter_at_index(bm, BM_LOOPS_OF_FACE, efa, v->tfindex);
luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
uv = luv->uv;
while (iterv) {
next = iterv->next;
- efa = EDBM_face_at_index(em, iterv->f);
- /* tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); */ /* UNUSED */
+ efa = BM_face_at_index(bm, iterv->f);
+ /* tf = CustomData_bmesh_get(&bm->pdata, efa->head.data, CD_MTEXPOLY); */ /* UNUSED */
- l = BM_iter_at_index(em->bm, BM_LOOPS_OF_FACE, efa, iterv->tfindex);
+ l = BM_iter_at_index(bm, BM_LOOPS_OF_FACE, efa, iterv->tfindex);
luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
uv2 = luv->uv;
}
-UvMapVert *EDBM_uv_vert_map_at_index(UvVertMap *vmap, unsigned int v)
+UvMapVert *BM_uv_vert_map_at_index(UvVertMap *vmap, unsigned int v)
{
return vmap->vert[v];
}
/* A specialized vert map used by stitch operator */
-UvElementMap *EDBM_uv_element_map_create(BMEditMesh *em, const bool selected, const bool do_islands)
+UvElementMap *BM_uv_element_map_create(BMesh *bm, const bool selected, const bool do_islands)
{
BMVert *ev;
BMFace *efa;
BMFace **stack;
int stacksize = 0;
- const int cd_loop_uv_offset = CustomData_get_offset(&em->bm->ldata, CD_MLOOPUV);
+ const int cd_loop_uv_offset = CustomData_get_offset(&bm->ldata, CD_MLOOPUV);
- BM_mesh_elem_index_ensure(em->bm, BM_VERT | BM_FACE);
+ BM_mesh_elem_index_ensure(bm, BM_VERT | BM_FACE);
- totverts = em->bm->totvert;
+ totverts = bm->totvert;
totuv = 0;
- island_number = MEM_mallocN(sizeof(*stack) * em->bm->totface, "uv_island_number_face");
+ island_number = MEM_mallocN(sizeof(*stack) * bm->totface, "uv_island_number_face");
if (!island_number) {
return NULL;
}
/* generate UvElement array */
- BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
+ BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
if (!selected || BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
totuv += efa->len;
}
buf = element_map->buf = (UvElement *)MEM_callocN(sizeof(*element_map->buf) * totuv, "UvElement");
if (!element_map->vert || !element_map->buf) {
- EDBM_uv_element_map_free(element_map);
+ BM_uv_element_map_free(element_map);
MEM_freeN(island_number);
return NULL;
}
j = 0;
- BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
+ BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
island_number[j++] = INVALID_ISLAND;
if (!selected || BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
BM_ITER_ELEM_INDEX (l, &liter, efa, BM_LOOPS_OF_FACE, i) {
/* sort individual uvs for each vert */
i = 0;
- BM_ITER_MESH (ev, &iter, em->bm, BM_VERTS_OF_MESH) {
+ BM_ITER_MESH (ev, &iter, bm, BM_VERTS_OF_MESH) {
UvElement *newvlist = NULL, *vlist = element_map->vert[i];
UvElement *iterv, *v, *lastv, *next;
float *uv, *uv2, uvdiff[2];
if (do_islands) {
/* map holds the map from current vmap->buf to the new, sorted map */
map = MEM_mallocN(sizeof(*map) * totuv, "uvelement_remap");
- stack = MEM_mallocN(sizeof(*stack) * em->bm->totface, "uv_island_face_stack");
+ stack = MEM_mallocN(sizeof(*stack) * bm->totface, "uv_island_face_stack");
islandbuf = MEM_callocN(sizeof(*islandbuf) * totuv, "uvelement_island_buffer");
/* at this point, every UvElement in vert points to a UvElement sharing the same vertex. Now we should sort uv's in islands. */
}
/* remap */
- for (i = 0; i < em->bm->totvert; i++) {
+ for (i = 0; i < bm->totvert; i++) {
/* important since we may do selection only. Some of these may be NULL */
if (element_map->vert[i])
element_map->vert[i] = &islandbuf[map[element_map->vert[i] - element_map->buf]];
MEM_freeN(islandbuf);
MEM_freeN(stack);
MEM_freeN(map);
- EDBM_uv_element_map_free(element_map);
+ BM_uv_element_map_free(element_map);
MEM_freeN(island_number);
}
return element_map;
}
-void EDBM_uv_vert_map_free(UvVertMap *vmap)
+void BM_uv_vert_map_free(UvVertMap *vmap)
{
if (vmap) {
if (vmap->vert) MEM_freeN(vmap->vert);
}
}
-void EDBM_uv_element_map_free(UvElementMap *element_map)
+void BM_uv_element_map_free(UvElementMap *element_map)
{
if (element_map) {
if (element_map->vert) MEM_freeN(element_map->vert);
}
}
-UvElement *ED_uv_element_get(UvElementMap *map, BMFace *efa, BMLoop *l)
+UvElement *BM_uv_element_get(UvElementMap *map, BMFace *efa, BMLoop *l)
{
UvElement *element;
struct BMBVHTree *tree = NULL;
MirrTopoStore_t mesh_topo_store = {NULL, -1, -1, -1};
- EDBM_index_arrays_ensure(em, BM_VERT);
+ BM_mesh_elem_table_ensure(bm, BM_VERT);
if (r_index == NULL) {
const char *layer_id = BM_CD_LAYER_ID;
BLI_assert(em->mirror_cdlayer != -1); /* invalid use */
if (mirr && *mirr >= 0 && *mirr < em->bm->totvert) {
- if (!em->vert_index) {
+ if (!em->bm->vtable) {
printf("err: should only be called between "
"EDBM_verts_mirror_cache_begin and EDBM_verts_mirror_cache_end");
return NULL;
}
- return em->vert_index[*mirr];
+ return em->bm->vtable[*mirr];
}
return NULL;
BMIter iter;
BMVert *v;
- BLI_assert(em->vert_index != NULL);
+ BLI_assert((em->bm->vtable != NULL) && ((em->bm->elem_table_dirty & BM_VERT) == 0));
BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(v, BM_ELEM_SELECT) == sel_from) {
}
if (is_destructive) {
- EDBM_index_arrays_free(em);
+ /* TODO. we may be able to remove this now! - Campbell */
+ // BM_mesh_elem_table_free(em->bm, BM_ALL_NOLOOP);
}
else {
/* in debug mode double check we didn't need to recalculate */
- BLI_assert(EDBM_index_arrays_check(em) == true);
+ BLI_assert(BM_mesh_elem_table_check(em->bm) == true);
}
}
}
/* need to rebuild entirely because array size changes */
- EDBM_index_arrays_init(em, BM_VERT);
+ BM_mesh_elem_table_init(em->bm, BM_VERT);
/* create faces */
for (j = 0; j < trinum; j++) {
face[k] = uniquevbase + tri[k] - nv; /* unique vertex */
}
newFace = BM_face_create_quad_tri(em->bm,
- EDBM_vert_at_index(em, face[0]),
- EDBM_vert_at_index(em, face[2]),
- EDBM_vert_at_index(em, face[1]), NULL,
+ BM_vert_at_index(em->bm, face[0]),
+ BM_vert_at_index(em->bm, face[2]),
+ BM_vert_at_index(em->bm, face[1]), NULL,
NULL, false);
/* set navigation polygon idx to the custom layer */
/**
* Wrapper for objectmode/editmode.
*
- * call #EDBM_index_arrays_ensure first for editmesh.
+ * call #BM_mesh_elem_table_ensure first for editmesh.
*/
int ED_mesh_mirror_get_vert(Object *ob, int index)
{
if (em) {
BMVert *eve, *eve_mirr;
- eve = EDBM_vert_at_index(em, index);
+ eve = BM_vert_at_index(em->bm, index);
eve_mirr = editbmesh_get_x_mirror_vert(ob, em, eve, eve->co, index, use_topology);
index_mirr = eve_mirr ? BM_elem_index_get(eve_mirr) : -1;
}
return;
}
if (em) {
- EDBM_index_arrays_ensure(em, BM_VERT);
+ BM_mesh_elem_table_ensure(em->bm, BM_VERT);
}
for (i = 0; i < dvert_tot; i++) {
}
BLI_assert(dvert_tot == dvert_tot_all);
if (em) {
- EDBM_index_arrays_ensure(em, BM_VERT);
+ BM_mesh_elem_table_ensure(em->bm, BM_VERT);
}
for (i = 0; i < dvert_tot; i++) {
if (cd_dvert_offset != -1) {
BMVert *eve;
- EDBM_index_arrays_ensure(em, BM_VERT);
- eve = EDBM_vert_at_index(em, vertnum);
+ BM_mesh_elem_table_ensure(em->bm, BM_VERT);
+ eve = BM_vert_at_index(em->bm, vertnum);
dv = BM_ELEM_CD_GET_VOID_P(eve, cd_dvert_offset);
}
else {
memset(vgroup_subset_weights, 0, sizeof(*vgroup_subset_weights) * subset_count);
if (bm) {
- EDBM_index_arrays_ensure(em, BM_VERT);
+ BM_mesh_elem_table_ensure(bm, BM_VERT);
emap = NULL;
emap_mem = NULL;
/* in case its not selected */
if (bm) {
- BMVert *v = EDBM_vert_at_index(em, i);
+ BMVert *v = BM_vert_at_index(bm, i);
if (BM_elem_flag_test(v, BM_ELEM_SELECT)) {
BMIter eiter;
BMEdge *e;
WM_event_remove_timer(CTX_wm_manager(C), CTX_wm_window(C), data->timer);
}
if (data->elementMap) {
- EDBM_uv_element_map_free(data->elementMap);
+ BM_uv_element_map_free(data->elementMap);
}
if (data->uv) {
MEM_freeN(data->uv);
static int uv_element_offset_from_face_get(UvElementMap *map, BMFace *efa, BMLoop *l, int island_index, int doIslands)
{
- UvElement *element = ED_uv_element_get(map, efa, l);
+ UvElement *element = BM_uv_element_get(map, efa, l);
if (!element || (doIslands && element->island != island_index)) {
return -1;
}
if (do_island_optimization) {
/* We will need island information */
if (ts->uv_flag & UV_SYNC_SELECTION) {
- data->elementMap = EDBM_uv_element_map_create(em, 0, 1);
+ data->elementMap = BM_uv_element_map_create(bm, false, true);
}
else {
- data->elementMap = EDBM_uv_element_map_create(em, 1, 1);
+ data->elementMap = BM_uv_element_map_create(bm, true, true);
}
}
else {
if (ts->uv_flag & UV_SYNC_SELECTION) {
- data->elementMap = EDBM_uv_element_map_create(em, 0, 0);
+ data->elementMap = BM_uv_element_map_create(bm, false, false);
}
else {
- data->elementMap = EDBM_uv_element_map_create(em, 1, 0);
+ data->elementMap = BM_uv_element_map_create(bm, true, false);
}
}
Image *ima = CTX_data_edit_image(C);
uv_find_nearest_vert(scene, ima, em, co, NULL, &hit);
- element = ED_uv_element_get(data->elementMap, hit.efa, hit.l);
+ element = BM_uv_element_get(data->elementMap, hit.efa, hit.l);
island_index = element->island;
}
if (UNLIKELY(index >= em->bm->totface))
return DM_DRAW_OPTION_NORMAL;
- efa = EDBM_face_at_index(em, index);
+ efa = BM_face_at_index(em->bm, index);
if (BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
return DM_DRAW_OPTION_SKIP;
if (UNLIKELY(index >= em->bm->totface))
return DM_DRAW_OPTION_NORMAL;
- efa = EDBM_face_at_index(em, index);
+ efa = BM_face_at_index(em->bm, index);
return !BM_elem_flag_test(efa, BM_ELEM_HIDDEN);
}
} eWireDrawMode;
typedef struct drawDMVerts_userData {
- BMEditMesh *em;
+ BMesh *bm;
BMVert *eve_act;
char sel;
} drawDMVerts_userData;
typedef struct drawDMEdgesSel_userData {
- BMEditMesh *em;
+ BMesh *bm;
unsigned char *baseCol, *selCol, *actCol;
BMEdge *eed_act;
#endif
DerivedMesh *dm;
- BMEditMesh *em;
+ BMesh *bm;
BMFace *efa_act;
int *orig_index_mf_to_mpoly;
} drawDMFacesSel_userData;
typedef struct drawDMNormal_userData {
- BMEditMesh *em;
+ BMesh *bm;
int uniform_scale;
float normalsize;
float tmat[3][3];
} bbsObmodeMeshVerts_userData;
typedef struct drawDMLayer_userData {
- BMEditMesh *em;
+ BMesh *bm;
int cd_layer_offset;
} drawDMLayer_userData;
static void draw_dm_face_normals__mapFunc(void *userData, int index, const float cent[3], const float no[3])
{
drawDMNormal_userData *data = userData;
- BMFace *efa = EDBM_face_at_index(data->em, index);
+ BMFace *efa = BM_face_at_index(data->bm, index);
float n[3];
if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
{
drawDMNormal_userData data;
- data.em = em;
+ data.bm = em->bm;
data.normalsize = scene->toolsettings->normalsize;
calcDrawDMNormalScale(ob, &data);
static void draw_dm_face_centers__mapFunc(void *userData, int index, const float cent[3], const float UNUSED(no[3]))
{
- BMFace *efa = EDBM_face_at_index(((void **)userData)[0], index);
+ BMFace *efa = BM_face_at_index(((void **)userData)[0], index);
const char sel = *(((char **)userData)[1]);
if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN) &&
}
static void draw_dm_face_centers(BMEditMesh *em, DerivedMesh *dm, char sel)
{
- void *ptrs[2] = {em, &sel};
+ void *ptrs[2] = {em->bm, &sel};
bglBegin(GL_POINTS);
dm->foreachMappedFaceCenter(dm, draw_dm_face_centers__mapFunc, ptrs, DM_FOREACH_NOP);
static void draw_dm_vert_normals__mapFunc(void *userData, int index, const float co[3], const float no_f[3], const short no_s[3])
{
drawDMNormal_userData *data = userData;
- BMVert *eve = EDBM_vert_at_index(data->em, index);
+ BMVert *eve = BM_vert_at_index(data->bm, index);
if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) {
float no[3], n[3];
{
drawDMNormal_userData data;
- data.em = em;
+ data.bm = em->bm;
data.normalsize = scene->toolsettings->normalsize;
calcDrawDMNormalScale(ob, &data);
const float UNUSED(no_f[3]), const short UNUSED(no_s[3]))
{
drawDMVerts_userData *data = userData;
- BMVert *eve = EDBM_vert_at_index(data->em, index);
+ BMVert *eve = BM_vert_at_index(data->bm, index);
if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN) && BM_elem_flag_test(eve, BM_ELEM_SELECT) == data->sel) {
/* skin nodes: draw a red circle around the root
drawDMVerts_userData data;
data.sel = sel;
data.eve_act = eve_act;
- data.em = em;
+ data.bm = em->bm;
/* Cache theme values */
UI_GetThemeColor4ubv(TH_EDITMESH_ACTIVE, data.th_editmesh_active);
drawDMEdgesSel_userData *data = userData;
unsigned char *col;
- eed = EDBM_edge_at_index(data->em, index);
+ eed = BM_edge_at_index(data->bm, index);
if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
if (eed == data->eed_act) {
data.baseCol = baseCol;
data.selCol = selCol;
data.actCol = actCol;
- data.em = em;
+ data.bm = em->bm;
data.eed_act = eed_act;
dm->drawMappedEdges(dm, draw_dm_edges_sel__setDrawOptions, &data);
}
/* Draw edges */
static DMDrawOption draw_dm_edges__setDrawOptions(void *userData, int index)
{
- if (BM_elem_flag_test(EDBM_edge_at_index(userData, index), BM_ELEM_HIDDEN))
+ if (BM_elem_flag_test(BM_edge_at_index(userData, index), BM_ELEM_HIDDEN))
return DM_DRAW_OPTION_SKIP;
else
return DM_DRAW_OPTION_NORMAL;
static void draw_dm_edges(BMEditMesh *em, DerivedMesh *dm)
{
- dm->drawMappedEdges(dm, draw_dm_edges__setDrawOptions, em);
+ dm->drawMappedEdges(dm, draw_dm_edges__setDrawOptions, em->bm);
}
/* Draw edges with color interpolated based on selection */
static DMDrawOption draw_dm_edges_sel_interp__setDrawOptions(void *userData, int index)
{
- if (BM_elem_flag_test(EDBM_edge_at_index(((void **)userData)[0], index), BM_ELEM_HIDDEN))
+ if (BM_elem_flag_test(BM_edge_at_index(((void **)userData)[0], index), BM_ELEM_HIDDEN))
return DM_DRAW_OPTION_SKIP;
else
return DM_DRAW_OPTION_NORMAL;
}
static void draw_dm_edges_sel_interp__setDrawInterpOptions(void *userData, int index, float t)
{
- BMEdge *eed = EDBM_edge_at_index(((void **)userData)[0], index);
+ BMEdge *eed = BM_edge_at_index(((void **)userData)[0], index);
unsigned char **cols = userData;
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];
static void draw_dm_edges_sel_interp(BMEditMesh *em, DerivedMesh *dm, unsigned char *baseCol, unsigned char *selCol)
{
- void *cols[3] = {em, baseCol, selCol};
+ void *cols[3] = {em->bm, baseCol, selCol};
dm->drawMappedEdgesInterp(dm, draw_dm_edges_sel_interp__setDrawOptions, draw_dm_edges_sel_interp__setDrawInterpOptions, cols);
}
/* Draw only seam edges */
static DMDrawOption draw_dm_edges_seams__setDrawOptions(void *userData, int index)
{
- BMEdge *eed = EDBM_edge_at_index(userData, index);
+ BMEdge *eed = BM_edge_at_index(userData, index);
if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN) && BM_elem_flag_test(eed, BM_ELEM_SEAM))
return DM_DRAW_OPTION_NORMAL;
/* Draw only sharp edges */
static DMDrawOption draw_dm_edges_sharp__setDrawOptions(void *userData, int index)
{
- BMEdge *eed = EDBM_edge_at_index(userData, index);
+ BMEdge *eed = BM_edge_at_index(userData, index);
if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN) && !BM_elem_flag_test(eed, BM_ELEM_SMOOTH))
return DM_DRAW_OPTION_NORMAL;
#ifdef WITH_FREESTYLE
-static int draw_dm_test_freestyle_edge_mark(BMEditMesh *em, BMEdge *eed)
+static int draw_dm_test_freestyle_edge_mark(BMesh *bm, BMEdge *eed)
{
- FreestyleEdge *fed = CustomData_bmesh_get(&em->bm->edata, eed->head.data, CD_FREESTYLE_EDGE);
+ FreestyleEdge *fed = CustomData_bmesh_get(&bm->edata, eed->head.data, CD_FREESTYLE_EDGE);
if (!fed)
return 0;
return (fed->flag & FREESTYLE_EDGE_MARK) != 0;
/* Draw only Freestyle feature edges */
static DMDrawOption draw_dm_edges_freestyle__setDrawOptions(void *userData, int index)
{
- BMEdge *eed = EDBM_edge_at_index(userData, index);
+ BMEdge *eed = BM_edge_at_index(userData, index);
if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN) && draw_dm_test_freestyle_edge_mark(userData, eed))
return DM_DRAW_OPTION_NORMAL;
static void draw_dm_edges_freestyle(BMEditMesh *em, DerivedMesh *dm)
{
- dm->drawMappedEdges(dm, draw_dm_edges_freestyle__setDrawOptions, em);
+ dm->drawMappedEdges(dm, draw_dm_edges_freestyle__setDrawOptions, em->bm);
}
-static int draw_dm_test_freestyle_face_mark(BMEditMesh *em, BMFace *efa)
+static int draw_dm_test_freestyle_face_mark(BMesh *bm, BMFace *efa)
{
- FreestyleFace *ffa = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_FREESTYLE_FACE);
+ FreestyleFace *ffa = CustomData_bmesh_get(&bm->pdata, efa->head.data, CD_FREESTYLE_FACE);
if (!ffa)
return 0;
return (ffa->flag & FREESTYLE_FACE_MARK) != 0;
static DMDrawOption draw_dm_faces_sel__setDrawOptions(void *userData, int index)
{
drawDMFacesSel_userData *data = userData;
- BMFace *efa = EDBM_face_at_index(data->em, index);
+ BMFace *efa = BM_face_at_index(data->bm, index);
unsigned char *col;
if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
}
else {
#ifdef WITH_FREESTYLE
- col = data->cols[BM_elem_flag_test(efa, BM_ELEM_SELECT) ? 1 : draw_dm_test_freestyle_face_mark(data->em, efa) ? 3 : 0];
+ col = data->cols[BM_elem_flag_test(efa, BM_ELEM_SELECT) ? 1 : draw_dm_test_freestyle_face_mark(data->bm, efa) ? 3 : 0];
#else
col = data->cols[BM_elem_flag_test(efa, BM_ELEM_SELECT) ? 1 : 0];
#endif
return 0;
i = DM_origindex_mface_mpoly(data->orig_index_mf_to_mpoly, data->orig_index_mp_to_orig, index);
- efa = (i != ORIGINDEX_NONE) ? EDBM_face_at_index(data->em, i) : NULL;
+ efa = (i != ORIGINDEX_NONE) ? BM_face_at_index(data->bm, i) : NULL;
i = DM_origindex_mface_mpoly(data->orig_index_mf_to_mpoly, data->orig_index_mp_to_orig, next_index);
- next_efa = (i != ORIGINDEX_NONE) ? EDBM_face_at_index(data->em, i) : NULL;
+ next_efa = (i != ORIGINDEX_NONE) ? BM_face_at_index(data->bm, i) : NULL;
if (ELEM(NULL, efa, next_efa))
return 0;
return 0;
#ifdef WITH_FREESTYLE
- col = data->cols[BM_elem_flag_test(efa, BM_ELEM_SELECT) ? 1 : draw_dm_test_freestyle_face_mark(data->em, efa) ? 3 : 0];
- next_col = data->cols[BM_elem_flag_test(next_efa, BM_ELEM_SELECT) ? 1 : draw_dm_test_freestyle_face_mark(data->em, efa) ? 3 : 0];
+ col = data->cols[BM_elem_flag_test(efa, BM_ELEM_SELECT) ? 1 : draw_dm_test_freestyle_face_mark(data->bm, efa) ? 3 : 0];
+ next_col = data->cols[BM_elem_flag_test(next_efa, BM_ELEM_SELECT) ? 1 : draw_dm_test_freestyle_face_mark(data->bm, efa) ? 3 : 0];
#else
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];
drawDMFacesSel_userData data;
data.dm = dm;
data.cols[0] = baseCol;
- data.em = em;
+ data.bm = em->bm;
data.cols[1] = selCol;
data.cols[2] = actCol;
#ifdef WITH_FREESTYLE
static DMDrawOption draw_dm_creases__setDrawOptions(void *userData, int index)
{
drawDMLayer_userData *data = userData;
- BMEditMesh *em = data->em;
- BMEdge *eed = EDBM_edge_at_index(em, index);
+ BMesh *bm = data->bm;
+ BMEdge *eed = BM_edge_at_index(bm, index);
if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
const float crease = BM_ELEM_CD_GET_FLOAT(eed, data->cd_layer_offset);
{
drawDMLayer_userData data;
- data.em = em;
+ data.bm = em->bm;
data.cd_layer_offset = CustomData_get_offset(&em->bm->edata, CD_CREASE);
if (data.cd_layer_offset != -1) {
static DMDrawOption draw_dm_bweights__setDrawOptions(void *userData, int index)
{
drawDMLayer_userData *data = userData;
- BMEditMesh *em = data->em;
- BMEdge *eed = EDBM_edge_at_index(em, index);
+ BMesh *bm = data->bm;
+ BMEdge *eed = BM_edge_at_index(bm, index);
if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
const float bweight = BM_ELEM_CD_GET_FLOAT(eed, data->cd_layer_offset);
const float UNUSED(no_f[3]), const short UNUSED(no_s[3]))
{
drawDMLayer_userData *data = userData;
- BMEditMesh *em = data->em;
- BMVert *eve = EDBM_vert_at_index(em, index);
+ BMesh *bm = data->bm;
+ BMVert *eve = BM_vert_at_index(bm, index);
if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) {
const float bweight = BM_ELEM_CD_GET_FLOAT(eve, data->cd_layer_offset);
if (ts->selectmode & SCE_SELECT_VERTEX) {
drawDMLayer_userData data;
- data.em = em;
+ data.bm = em->bm;
data.cd_layer_offset = CustomData_get_offset(&em->bm->vdata, CD_BWEIGHT);
if (data.cd_layer_offset != -1) {
else {
drawDMLayer_userData data;
- data.em = em;
+ data.bm = em->bm;
data.cd_layer_offset = CustomData_get_offset(&em->bm->edata, CD_BWEIGHT);
if (data.cd_layer_offset != -1) {
if (UNLIKELY(index >= em->bm->totface))
return DM_DRAW_OPTION_NORMAL;
- efa = EDBM_face_at_index(em, index);
+ efa = BM_face_at_index(em->bm, index);
if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
GPU_enable_material(efa->mat_nr + 1, NULL);
return DM_DRAW_OPTION_NORMAL;
if (UNLIKELY(index >= em->bm->totface))
return DM_DRAW_OPTION_NORMAL;
- efa = EDBM_face_at_index(em, index);
+ efa = BM_face_at_index(em->bm, index);
if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
return DM_DRAW_OPTION_NORMAL;
}
}
- EDBM_index_arrays_ensure(em, BM_VERT | BM_EDGE | BM_FACE);
+ BM_mesh_elem_table_ensure(em->bm, BM_VERT | BM_EDGE | BM_FACE);
if (check_object_draw_editweight(me, finalDM)) {
if (dt > OB_WIRE) {
else {
glEnable(GL_DEPTH_TEST);
draw_mesh_paint_weight_faces(finalDM, false, draw_em_fancy__setFaceOpts, me->edit_btmesh);
- draw_mesh_paint_weight_edges(rv3d, finalDM, true, draw_dm_edges__setDrawOptions, me->edit_btmesh);
+ draw_mesh_paint_weight_edges(rv3d, finalDM, true, draw_dm_edges__setDrawOptions, me->edit_btmesh->bm);
glDisable(GL_DEPTH_TEST);
}
}
{
void **ptrs = userData;
int offset = (intptr_t) ptrs[0];
- BMVert *eve = EDBM_vert_at_index(ptrs[1], index);
+ BMVert *eve = BM_vert_at_index(ptrs[1], index);
if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) {
WM_framebuffer_index_set(offset + index);
}
static void bbs_mesh_verts(BMEditMesh *em, DerivedMesh *dm, int offset)
{
- void *ptrs[2] = {(void *)(intptr_t) offset, em};
+ void *ptrs[2] = {(void *)(intptr_t) offset, em->bm};
glPointSize(UI_GetThemeValuef(TH_VERTEX_SIZE));
bglBegin(GL_POINTS);
{
void **ptrs = userData;
int offset = (intptr_t) ptrs[0];
- BMEdge *eed = EDBM_edge_at_index(ptrs[1], index);
+ BMEdge *eed = BM_edge_at_index(ptrs[1], index);
if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
WM_framebuffer_index_set(offset + index);
}
static void bbs_mesh_wire(BMEditMesh *em, DerivedMesh *dm, int offset)
{
- void *ptrs[2] = {(void *)(intptr_t) offset, em};
+ void *ptrs[2] = {(void *)(intptr_t) offset, em->bm};
dm->drawMappedEdges(dm, bbs_mesh_wire__setDrawOptions, ptrs);
}
static DMDrawOption bbs_mesh_solid__setSolidDrawOptions(void *userData, int index)
{
- BMFace *efa = EDBM_face_at_index(((void **)userData)[0], index);
+ BMFace *efa = BM_face_at_index(((void **)userData)[0], index);
if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
if (((void **)userData)[1]) {
static void bbs_mesh_solid__drawCenter(void *userData, int index, const float cent[3], const float UNUSED(no[3]))
{
- BMFace *efa = EDBM_face_at_index(((void **)userData)[0], index);
+ BMFace *efa = BM_face_at_index(((void **)userData)[0], index);
if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
WM_framebuffer_index_set(index + 1);
static void bbs_mesh_solid_EM(BMEditMesh *em, Scene *scene, View3D *v3d,
Object *ob, DerivedMesh *dm, int facecol)
{
- void *ptrs[2] = {em, NULL}; //second one being null means to draw black
+ void *ptrs[2] = {em->bm, NULL}; //second one being null means to draw black
cpack(0);
if (facecol) {
DerivedMesh *dm = editbmesh_get_derived_cage(scene, ob, em, CD_MASK_BAREMESH);
- EDBM_index_arrays_ensure(em, BM_VERT | BM_EDGE | BM_FACE);
+ BM_mesh_elem_table_ensure(em->bm, BM_VERT | BM_EDGE | BM_FACE);
bbs_mesh_solid_EM(em, scene, v3d, ob, dm, ts->selectmode & SCE_SELECT_FACE);
if (ts->selectmode & SCE_SELECT_FACE)
#include "BKE_curve.h"
#include "BKE_DerivedMesh.h"
#include "BKE_displist.h"
+#include "BKE_editmesh.h"
#include "bmesh.h"
const float UNUSED(no_f[3]), const short UNUSED(no_s[3]))
{
foreachScreenVert_userData *data = userData;
- BMVert *eve = EDBM_vert_at_index(data->vc.em, index);
+ BMVert *eve = BM_vert_at_index(data->vc.em->bm, index);
if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) {
float screen_co[2];
ED_view3d_clipping_local(vc->rv3d, vc->obedit->obmat); /* for local clipping lookups */
}
- EDBM_index_arrays_ensure(vc->em, BM_VERT);
+ BM_mesh_elem_table_ensure(vc->em->bm, BM_VERT);
dm->foreachMappedVert(dm, mesh_foreachScreenVert__mapFunc, &data, DM_FOREACH_NOP);
dm->release(dm);
static void mesh_foreachScreenEdge__mapFunc(void *userData, int index, const float v0co[3], const float v1co[3])
{
foreachScreenEdge_userData *data = userData;
- BMEdge *eed = EDBM_edge_at_index(data->vc.em, index);
+ BMEdge *eed = BM_edge_at_index(data->vc.em->bm, index);
if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
float screen_co_a[2];
ED_view3d_clipping_local(vc->rv3d, vc->obedit->obmat); /* for local clipping lookups */
}
- EDBM_index_arrays_ensure(vc->em, BM_EDGE);
+ BM_mesh_elem_table_ensure(vc->em->bm, BM_EDGE);
dm->foreachMappedEdge(dm, mesh_foreachScreenEdge__mapFunc, &data);
dm->release(dm);
static void mesh_foreachScreenFace__mapFunc(void *userData, int index, const float cent[3], const float UNUSED(no[3]))
{
foreachScreenFace_userData *data = userData;
- BMFace *efa = EDBM_face_at_index(data->vc.em, index);
+ BMFace *efa = BM_face_at_index(data->vc.em->bm, index);
if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
float screen_co[2];
data.userData = userData;
data.clip_flag = clip_flag;
- EDBM_index_arrays_ensure(vc->em, BM_FACE);
+ BM_mesh_elem_table_ensure(vc->em->bm, BM_FACE);
dm->foreachMappedFaceCenter(dm, mesh_foreachScreenFace__mapFunc, &data, DM_FOREACH_NOP);
dm->release(dm);
void **userdata = vuserdata;
BMEditMesh *em = userdata[0];
TransVert *tv = userdata[1];
- BMVert *eve = EDBM_vert_at_index(em, index);
+ BMVert *eve = BM_vert_at_index(em->bm, index);
if (BM_elem_index_get(eve) != TM_INDEX_SKIP) {
tv = &tv[BM_elem_index_get(eve)];
}
if (transvmain && em->derivedCage) {
- EDBM_index_arrays_ensure(em, BM_VERT);
+ BM_mesh_elem_table_ensure(bm, BM_VERT);
em->derivedCage->foreachMappedVert(em->derivedCage, set_mapped_co, userdata, DM_FOREACH_NOP);
}
}
* its possible we have a selected vertex thats not in a face, for now best not crash in that case. */
fill_vn_i(vert_map, bm->totvert, -1);
- EDBM_index_arrays_ensure(em, htype);
- ele_array = (htype == BM_FACE) ? (void **)em->face_index : (void **)em->edge_index;
+ BM_mesh_elem_table_ensure(bm, htype);
+ ele_array = (htype == BM_FACE) ? (void **)bm->ftable : (void **)bm->etable;
BM_mesh_elem_index_ensure(bm, BM_VERT);
if (propconnected) {
/* create element map with island information */
if (ts->uv_flag & UV_SYNC_SELECTION) {
- elementmap = EDBM_uv_element_map_create(em, false, true);
+ elementmap = BM_uv_element_map_create(em->bm, false, true);
}
else {
- elementmap = EDBM_uv_element_map_create(em, true, true);
+ elementmap = BM_uv_element_map_create(em->bm, true, true);
}
island_enabled = MEM_callocN(sizeof(*island_enabled) * elementmap->totalIslands, "TransIslandData(UV Editing)");
}
countsel++;
if (propconnected) {
- UvElement *element = ED_uv_element_get(elementmap, efa, l);
+ UvElement *element = BM_uv_element_get(elementmap, efa, l);
island_enabled[element->island] = TRUE;
}
continue;
if (propconnected) {
- UvElement *element = ED_uv_element_get(elementmap, efa, l);
+ UvElement *element = BM_uv_element_get(elementmap, efa, l);
if (!island_enabled[element->island]) {
count_rejected++;
continue;
if (propconnected) {
t->total -= count_rejected;
- EDBM_uv_element_map_free(elementmap);
+ BM_uv_element_map_free(elementmap);
MEM_freeN(island_enabled);
}
if (em != NULL) {
index_array = dm->getVertDataArray(dm, CD_ORIGINDEX);
- EDBM_index_arrays_ensure(em, BM_VERT);
+ BM_mesh_elem_table_ensure(em->bm, BM_VERT);
}
for (i = 0; i < totvert; i++) {
test = 0;
}
else {
- eve = EDBM_vert_at_index(em, index);
+ eve = BM_vert_at_index(em->bm, index);
if ((BM_elem_flag_test(eve, BM_ELEM_HIDDEN) ||
BM_elem_flag_test(eve, BM_ELEM_SELECT)))
if (em != NULL) {
index_array = dm->getEdgeDataArray(dm, CD_ORIGINDEX);
- EDBM_index_arrays_ensure(em, BM_EDGE);
+ BM_mesh_elem_table_ensure(em->bm, BM_EDGE);
}
for (i = 0; i < totedge; i++) {
test = 0;
}
else {
- BMEdge *eed = EDBM_edge_at_index(em, index);
+ BMEdge *eed = BM_edge_at_index(em->bm, index);
if ((BM_elem_flag_test(eed, BM_ELEM_HIDDEN) ||
BM_elem_flag_test(eed->v1, BM_ELEM_SELECT) ||
static UvMapVert *uv_select_edgeloop_vertex_map_get(UvVertMap *vmap, BMFace *efa, BMLoop *l)
{
UvMapVert *iterv, *first;
- first = EDBM_uv_vert_map_at_index(vmap, BM_elem_index_get(l->v));
+ first = BM_uv_vert_map_at_index(vmap, BM_elem_index_get(l->v));
for (iterv = first; iterv; iterv = iterv->next) {
if (iterv->separate)
if (iterv1->f == iterv2->f) {
/* if face already tagged, don't do this edge */
- efa = EDBM_face_at_index(em, iterv1->f);
+ efa = BM_face_at_index(em->bm, iterv1->f);
if (BM_elem_flag_test(efa, BM_ELEM_TAG))
return false;
break;
if (iterv1->f == iterv2->f) {
- efa = EDBM_face_at_index(em, iterv1->f);
+ efa = BM_face_at_index(em->bm, iterv1->f);
BM_elem_flag_enable(efa, BM_ELEM_TAG);
break;
}
const int cd_poly_tex_offset = CustomData_get_offset(&em->bm->pdata, CD_MTEXPOLY);
/* setup */
- EDBM_index_arrays_ensure(em, BM_FACE);
- vmap = EDBM_uv_vert_map_create(em, 0, limit);
+ BM_mesh_elem_table_ensure(em->bm, BM_FACE);
+ vmap = BM_uv_vert_map_create(em->bm, 0, limit);
BM_mesh_elem_index_ensure(em->bm, BM_VERT | BM_FACE);
}
/* cleanup */
- EDBM_uv_vert_map_free(vmap);
+ BM_uv_vert_map_free(vmap);
return (select) ? 1 : -1;
}
const int cd_loop_uv_offset = CustomData_get_offset(&em->bm->ldata, CD_MLOOPUV);
const int cd_poly_tex_offset = CustomData_get_offset(&em->bm->pdata, CD_MTEXPOLY);
- EDBM_index_arrays_ensure(em, BM_FACE); /* we can use this too */
- vmap = EDBM_uv_vert_map_create(em, 1, limit);
+ BM_mesh_elem_table_ensure(em->bm, BM_FACE); /* we can use this too */
+ vmap = BM_uv_vert_map_create(em->bm, 1, limit);
if (vmap == NULL)
return;
stacksize--;
a = stack[stacksize];
- efa = EDBM_face_at_index(em, a);
+ efa = BM_face_at_index(em->bm, a);
BM_ITER_ELEM_INDEX (l, &liter, efa, BM_LOOPS_OF_FACE, i) {
/* make_uv_vert_map_EM sets verts tmp.l to the indices */
- vlist = EDBM_uv_vert_map_at_index(vmap, BM_elem_index_get(l->v));
+ vlist = BM_uv_vert_map_at_index(vmap, BM_elem_index_get(l->v));
startv = vlist;
MEM_freeN(stack);
MEM_freeN(flag);
- EDBM_uv_vert_map_free(vmap);
+ BM_uv_vert_map_free(vmap);
}
/* WATCH IT: this returns first selected UV,
uvedit_uv_select_set(em, scene, l, select, false, cd_loop_uv_offset);
- vlist_iter = EDBM_uv_vert_map_at_index(vmap, BM_elem_index_get(l->v));
+ vlist_iter = BM_uv_vert_map_at_index(vmap, BM_elem_index_get(l->v));
while (vlist_iter) {
if (vlist_iter->separate)
if (efa_index != vlist_iter->f) {
BMLoop *l_other;
- efa_vlist = EDBM_face_at_index(em, vlist_iter->f);
+ efa_vlist = BM_face_at_index(em->bm, vlist_iter->f);
/* tf_vlist = BM_ELEM_CD_GET_VOID_P(efa_vlist, cd_poly_tex_offset); */ /* UNUSED */
l_other = BM_iter_at_index(em->bm, BM_LOOPS_OF_FACE, efa_vlist, vlist_iter->tfindex);
uvedit_pixel_to_float(sima, limit, 0.05);
- EDBM_index_arrays_ensure(em, BM_FACE);
- vmap = EDBM_uv_vert_map_create(em, 0, limit);
+ BM_mesh_elem_table_ensure(em->bm, BM_FACE);
+ vmap = BM_uv_vert_map_create(em->bm, 0, limit);
if (vmap == NULL) {
return;
}
}
}
}
- EDBM_uv_vert_map_free(vmap);
+ BM_uv_vert_map_free(vmap);
}
else { /* SI_STICKY_DISABLE or ts->uv_flag & UV_SYNC_SELECTION */
uvedit_pixel_to_float(sima, limit, 0.05);
- EDBM_index_arrays_ensure(em, BM_FACE);
- vmap = EDBM_uv_vert_map_create(em, 0, limit);
+ BM_mesh_elem_table_ensure(em->bm, BM_FACE);
+ vmap = BM_uv_vert_map_create(em->bm, 0, limit);
if (vmap == NULL) {
return;
}
}
}
}
- EDBM_uv_vert_map_free(vmap);
+ BM_uv_vert_map_free(vmap);
}
else { /* SI_STICKY_DISABLE or ts->uv_flag & UV_SYNC_SELECTION */
}
/* This code sets editvert->tmp.l to the index. This will be useful later on. */
- EDBM_index_arrays_ensure(em, BM_FACE);
- vmap = EDBM_uv_vert_map_create(em, 0, limit);
+ BM_mesh_elem_table_ensure(bm, BM_FACE);
+ vmap = BM_uv_vert_map_create(bm, 0, limit);
BM_ITER_MESH (editedge, &iter, bm, BM_EDGES_OF_MESH) {
/* flags to determine if we uv is separated from first editface match */
v1coincident = 0;
separated2 = 0;
- efa1 = EDBM_face_at_index(em, mv1->f);
+ efa1 = BM_face_at_index(bm, mv1->f);
mvinit2 = vmap->vert[BM_elem_index_get(editedge->v2)];
for (mv2 = mvinit2; mv2; mv2 = mv2->next) {
if (mv2->separate)
mv2sep = mv2;
- efa2 = EDBM_face_at_index(em, mv2->f);
+ efa2 = BM_face_at_index(bm, mv2->f);
if (efa1 == efa2) {
/* if v1 is not coincident no point in comparing */
if (v1coincident) {
me->drawflag |= ME_DRAWSEAMS;
- EDBM_uv_vert_map_free(vmap);
+ BM_uv_vert_map_free(vmap);
DAG_id_tag_update(&me->id, 0);
WM_event_add_notifier(C, NC_GEOM | ND_DATA, me);
{
if (state) {
if (state->element_map) {
- EDBM_uv_element_map_free(state->element_map);
+ BM_uv_element_map_free(state->element_map);
}
if (state->uvs) {
MEM_freeN(state->uvs);
/* check to see if other vertex of edge belongs to same vertex as */
if (BM_elem_index_get(iter1->l->next->v) == elemindex2)
- iter2 = ED_uv_element_get(element_map, iter1->l->f, iter1->l->next);
+ iter2 = BM_uv_element_get(element_map, iter1->l->f, iter1->l->next);
else if (BM_elem_index_get(iter1->l->prev->v) == elemindex2)
- iter2 = ED_uv_element_get(element_map, iter1->l->f, iter1->l->prev);
+ iter2 = BM_uv_element_get(element_map, iter1->l->f, iter1->l->prev);
if (iter2) {
int index1 = map[iter1 - first_element];
/* copy data from MLoopUVs to the preview display buffers */
BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
/* just to test if face was added for processing. uvs of inselected vertices will return NULL */
- UvElement *element = ED_uv_element_get(state->element_map, efa, BM_FACE_FIRST_LOOP(efa));
+ UvElement *element = BM_uv_element_get(state->element_map, efa, BM_FACE_FIRST_LOOP(efa));
if (element) {
int numoftris = efa->len - 2;
{
UvEdge tmp_edge;
- UvElement *element1 = ED_uv_element_get(state->element_map, l->f, l);
- UvElement *element2 = ED_uv_element_get(state->element_map, l->f, l->next);
+ UvElement *element1 = BM_uv_element_get(state->element_map, l->f, l);
+ UvElement *element2 = BM_uv_element_get(state->element_map, l->f, l->next);
int uv1 = state->map[element1 - state->element_map->buf];
int uv2 = state->map[element2 - state->element_map->buf];
state->draw_handle = ED_region_draw_cb_activate(ar->type, stitch_draw, state, REGION_DRAW_POST_VIEW);
/* in uv synch selection, all uv's are visible */
if (ts->uv_flag & UV_SYNC_SELECTION) {
- state->element_map = EDBM_uv_element_map_create(state->em, FALSE, TRUE);
+ state->element_map = BM_uv_element_map_create(state->em->bm, false, true);
}
else {
- state->element_map = EDBM_uv_element_map_create(state->em, TRUE, TRUE);
+ state->element_map = BM_uv_element_map_create(state->em->bm, true, true);
}
if (!state->element_map) {
state_delete(state);
continue;
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
- UvElement *element = ED_uv_element_get(state->element_map, efa, l);
+ UvElement *element = BM_uv_element_get(state->element_map, efa, l);
int offset1, itmp1 = element - state->element_map->buf;
- int offset2, itmp2 = ED_uv_element_get(state->element_map, efa, l->next) - state->element_map->buf;
+ int offset2, itmp2 = BM_uv_element_get(state->element_map, efa, l->next) - state->element_map->buf;
UvEdge *edge;
offset1 = map[itmp1];
UvElement *element;
enum StitchModes stored_mode = RNA_enum_get(op->ptr, "stored_mode");
- EDBM_index_arrays_ensure(em, BM_FACE);
+ BM_mesh_elem_table_ensure(em->bm, BM_FACE);
if (stored_mode == STITCH_VERT) {
state->selection_stack = MEM_mallocN(sizeof(*state->selection_stack) * state->total_separate_uvs, "uv_stitch_selection_stack");
{
faceIndex = RNA_int_get(&itemptr, "face_index");
elementIndex = RNA_int_get(&itemptr, "element_index");
- efa = EDBM_face_at_index(em, faceIndex);
- element = ED_uv_element_get(state->element_map, efa, BM_iter_at_index(NULL, BM_LOOPS_OF_FACE, efa, elementIndex));
+ efa = BM_face_at_index(em->bm, faceIndex);
+ element = BM_uv_element_get(state->element_map, efa, BM_iter_at_index(NULL, BM_LOOPS_OF_FACE, efa, elementIndex));
stitch_select_uv(element, state, 1);
}
RNA_END;
int uv1, uv2;
faceIndex = RNA_int_get(&itemptr, "face_index");
elementIndex = RNA_int_get(&itemptr, "element_index");
- efa = EDBM_face_at_index(em, faceIndex);
- element = ED_uv_element_get(state->element_map, efa, BM_iter_at_index(NULL, BM_LOOPS_OF_FACE, efa, elementIndex));
+ efa = BM_face_at_index(em->bm, faceIndex);
+ element = BM_uv_element_get(state->element_map, efa, BM_iter_at_index(NULL, BM_LOOPS_OF_FACE, efa, elementIndex));
uv1 = map[element - state->element_map->buf];
- element = ED_uv_element_get(state->element_map, efa, BM_iter_at_index(NULL, BM_LOOPS_OF_FACE, efa, (elementIndex + 1) % efa->len));
+ element = BM_uv_element_get(state->element_map, efa, BM_iter_at_index(NULL, BM_LOOPS_OF_FACE, efa, (elementIndex + 1) % efa->len));
uv2 = map[element - state->element_map->buf];
if (uv1 < uv2) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
BM_ITER_ELEM_INDEX (l, &liter, efa, BM_LOOPS_OF_FACE, i) {
if (uvedit_uv_select_test(scene, l, cd_loop_uv_offset)) {
- UvElement *element = ED_uv_element_get(state->element_map, efa, l);
+ UvElement *element = BM_uv_element_get(state->element_map, efa, l);
if (element) {
stitch_select_uv(element, state, 1);
}
}
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
- UvElement *element = ED_uv_element_get(state->element_map, efa, BM_FACE_FIRST_LOOP(efa));
+ UvElement *element = BM_uv_element_get(state->element_map, efa, BM_FACE_FIRST_LOOP(efa));
if (element) {
state->tris_per_island[element->island] += (efa->len > 2) ? efa->len - 2 : 0;
* you can do stuff like deselect the opposite stitchable vertex and the initial still gets deselected */
/* This works due to setting of tmp in find nearest uv vert */
- UvElement *element = ED_uv_element_get(state->element_map, hit.efa, hit.l);
+ UvElement *element = BM_uv_element_get(state->element_map, hit.efa, hit.l);
stitch_select_uv(element, state, FALSE);
}
faceMap = MEM_mallocN(numOfFaces * sizeof(BMFace *), "unwrap_edit_face_map");
BM_mesh_elem_index_ensure(em->bm, BM_VERT);
- EDBM_index_arrays_ensure(em, BM_EDGE | BM_FACE);
+ BM_mesh_elem_table_ensure(em->bm, BM_EDGE | BM_FACE);
/* map subsurfed faces to original editFaces */
for (i = 0; i < numOfFaces; i++)
- faceMap[i] = EDBM_face_at_index(em, DM_origindex_mface_mpoly(origFaceIndices, origPolyIndices, i));
+ faceMap[i] = BM_face_at_index(em->bm, DM_origindex_mface_mpoly(origFaceIndices, origPolyIndices, i));
edgeMap = MEM_mallocN(numOfEdges * sizeof(BMEdge *), "unwrap_edit_edge_map");
for (i = 0; i < numOfEdges; i++) {
/* not all edges correspond to an old edge */
edgeMap[i] = (origEdgeIndices[i] != ORIGINDEX_NONE) ?
- EDBM_edge_at_index(em, origEdgeIndices[i]) : NULL;
+ BM_edge_at_index(em->bm, origEdgeIndices[i]) : NULL;
}
/* Prepare and feed faces to the solver */
/* update for display only */
dmd->face_count = bm->totface;
result = CDDM_from_bmesh(bm, FALSE);
- BLI_assert(bm->vtoolflagpool == NULL); /* make sure we never alloc'd this */
- BLI_assert(bm->etoolflagpool == NULL);
- BLI_assert(bm->ftoolflagpool == NULL);
+ BLI_assert(bm->vtoolflagpool == NULL &&
+ bm->etoolflagpool == NULL &&
+ bm->ftoolflagpool == NULL); /* make sure we never alloc'd these */
+ BLI_assert(bm->vtable == NULL &&
+ bm->etable == NULL &&
+ bm->ftable == NULL);
+
BM_mesh_free(bm);
#ifdef USE_TIMEIT
/* -------------------------------------------------------------------- */
/* keep at bottom */
-/* BAD INCLUDES */
-
-#include "BKE_global.h"
-#include "BKE_main.h"
-#include "BKE_editmesh.h"
-#include "DNA_scene_types.h"
-#include "DNA_object_types.h"
-#include "DNA_mesh_types.h"
-#include "MEM_guardedalloc.h"
-
-/* there are cases where this warning isnt needed, otherwise it could be made into an error */
-static void bm_dealloc_warn(const char *mesh_name)
-{
- PySys_WriteStdout("Modified BMesh '%.200s' from a wrapped editmesh is freed without a call "
- "to bmesh.update_edit_mesh(mesh, destructive=True), this is will likely cause a crash\n",
- mesh_name);
-}
/* this function is called on free, it should stay quite fast */
static void bm_dealloc_editmode_warn(BPy_BMesh *self)
{
if (self->flag & BPY_BMFLAG_IS_WRAPPED) {
- /* likely editmesh */
- BMesh *bm = self->bm;
- Scene *scene;
- for (scene = G.main->scene.first; scene; scene = scene->id.next) {
- Base *base = scene->basact;
- if (base && base->object->type == OB_MESH) {
- Mesh *me = base->object->data;
- BMEditMesh *em = me->edit_btmesh;
- if (em && em->bm == bm) {
- /* not foolproof, scripter may have added/removed verts */
- if (((em->vert_index && (MEM_allocN_len(em->vert_index) / sizeof(*em->vert_index)) != bm->totvert)) ||
- ((em->edge_index && (MEM_allocN_len(em->edge_index) / sizeof(*em->edge_index)) != bm->totedge)) ||
- ((em->face_index && (MEM_allocN_len(em->face_index) / sizeof(*em->face_index)) != bm->totface)))
- {
- bm_dealloc_warn(me->id.name + 2);
- break;
- }
- }
- }
- }
+ /* currently nop - this works without warnings now */
}
}
projects / blender.git / commitdiff