bmesh: optimize iterator size using a union for iterator specific data.

on 64bit system reduces the struct to 64bytes, was 120, also avoids initializing unused values.

3 files changed, 254 insertions, 219 deletions

diff --git a/source/blender/bmesh/intern/bmesh_iterators.c b/source/blender/bmesh/intern/bmesh_iterators.c
index cd66617bbf9..4555de7b13d 100644
--- a/source/blender/bmesh/intern/bmesh_iterators.c
+++ b/source/blender/bmesh/intern/bmesh_iterators.c
@@ -286,21 +286,6 @@ int BM_iter_mesh_count_flag(const char itype, BMesh *bm, const char hflag, const
 	return count;
 }
 
-
-/**
- * \brief Init Iterator
- *
- * Clears the internal state of an iterator for begin() callbacks.
- */
-static void init_iterator(BMIter *iter)
-{
-//	iter->v_first = iter->v_next = NULL; // UNUSED
-	iter->e_first = iter->e_next = NULL;
-	iter->l_first = iter->l_next = NULL;
-//	iter->f_first = iter->f_next = NULL; // UNUSED
-	iter->ldata = NULL;
-}
-
 /**
  * Notes on iterator implementation:
  *
@@ -319,88 +304,90 @@ static void init_iterator(BMIter *iter)
  * VERT OF MESH CALLBACKS
  */
 
-void bmiter__vert_of_mesh_begin(BMIter *iter)
+void bmiter__vert_of_mesh_begin(struct BMIter__vert_of_mesh *iter)
 {
 	BLI_mempool_iternew(iter->bm->vpool, &iter->pooliter);
 }
 
-void  *bmiter__vert_of_mesh_step(BMIter *iter)
+void *bmiter__vert_of_mesh_step(struct BMIter__vert_of_mesh *iter)
 {
 	return BLI_mempool_iterstep(&iter->pooliter);
-
 }
 
-void  bmiter__edge_of_mesh_begin(BMIter *iter)
+void bmiter__edge_of_mesh_begin(struct BMIter__edge_of_mesh *iter)
 {
 	BLI_mempool_iternew(iter->bm->epool, &iter->pooliter);
-	iter->count = iter->bm->totedge;  /* */
 }
 
-void  *bmiter__edge_of_mesh_step(BMIter *iter)
+void  *bmiter__edge_of_mesh_step(struct BMIter__edge_of_mesh *iter)
 {
 	return BLI_mempool_iterstep(&iter->pooliter);
-
 }
 
-void  bmiter__face_of_mesh_begin(BMIter *iter)
+void  bmiter__face_of_mesh_begin(struct BMIter__face_of_mesh *iter)
 {
 	BLI_mempool_iternew(iter->bm->fpool, &iter->pooliter);
 }
 
-void  *bmiter__face_of_mesh_step(BMIter *iter)
+void  *bmiter__face_of_mesh_step(struct BMIter__face_of_mesh *iter)
 {
 	return BLI_mempool_iterstep(&iter->pooliter);
-
 }
 
 /*
  * EDGE OF VERT CALLBACKS
  */
 
-void  bmiter__edge_of_vert_begin(BMIter *iter)
+void  bmiter__edge_of_vert_begin(struct BMIter__edge_of_vert *iter)
 {
-	init_iterator(iter);
 	if (iter->vdata->e) {
 		iter->e_first = iter->vdata->e;
 		iter->e_next = iter->vdata->e;
 	}
+	else {
+		iter->e_first = NULL;
+		iter->e_next = NULL;
+	}
 }
 
-void  *bmiter__edge_of_vert_step(BMIter *iter)
+void  *bmiter__edge_of_vert_step(struct BMIter__edge_of_vert *iter)
 {
-	BMEdge *current = iter->e_next;
+	BMEdge *e_curr = iter->e_next;
 
-	if (iter->e_next)
+	if (iter->e_next) {
 		iter->e_next = bmesh_disk_edge_next(iter->e_next, iter->vdata);
-	
-	if (iter->e_next == iter->e_first) iter->e_next = NULL;
+		if (iter->e_next == iter->e_first) {
+			iter->e_next = NULL;
+		}
+	}
 
-	return current;
+	return e_curr;
 }
 
 /*
  * FACE OF VERT CALLBACKS
  */
 
-void  bmiter__face_of_vert_begin(BMIter *iter)
+void  bmiter__face_of_vert_begin(struct BMIter__face_of_vert *iter)
 {
-	init_iterator(iter);
-	iter->count = 0;
-	if (iter->vdata->e)
-		iter->count = bmesh_disk_facevert_count(iter->vdata);
-	if (iter->count) {
+	((BMIter *)iter)->count = bmesh_disk_facevert_count(iter->vdata);
+	if (((BMIter *)iter)->count) {
 		iter->e_first = bmesh_disk_faceedge_find_first(iter->vdata->e, iter->vdata);
 		iter->e_next = iter->e_first;
 		iter->l_first = bmesh_radial_faceloop_find_first(iter->e_first->l, iter->vdata);
 		iter->l_next = iter->l_first;
 	}
+	else {
+		iter->l_first = iter->l_next = NULL;
+		iter->e_first = iter->e_next = NULL;
+	}
 }
-void  *bmiter__face_of_vert_step(BMIter *iter)
+void  *bmiter__face_of_vert_step(struct BMIter__face_of_vert *iter)
 {
-	BMLoop *current = iter->l_next;
+	BMLoop *l_curr = iter->l_next;
 
-	if (iter->count && iter->l_next) {
-		iter->count--;
+	if (((BMIter *)iter)->count && iter->l_next) {
+		((BMIter *)iter)->count--;
 		iter->l_next = bmesh_radial_faceloop_find_next(iter->l_next, iter->vdata);
 		if (iter->l_next == iter->l_first) {
 			iter->e_next = bmesh_disk_faceedge_find_next(iter->e_next, iter->vdata);
@@ -409,9 +396,11 @@ void  *bmiter__face_of_vert_step(BMIter *iter)
 		}
 	}
 	
-	if (!iter->count) iter->l_next = NULL;
+	if (!((BMIter *)iter)->count) {
+		iter->l_next = NULL;
+	}
 
-	return current ? current->f : NULL;
+	return l_curr ? l_curr->f : NULL;
 }
 
 
@@ -420,25 +409,26 @@ void  *bmiter__face_of_vert_step(BMIter *iter)
  *
  */
 
-void  bmiter__loop_of_vert_begin(BMIter *iter)
+void  bmiter__loop_of_vert_begin(struct BMIter__loop_of_vert *iter)
 {
-	init_iterator(iter);
-	iter->count = 0;
-	if (iter->vdata->e)
-		iter->count = bmesh_disk_facevert_count(iter->vdata);
-	if (iter->count) {
+	((BMIter *)iter)->count = bmesh_disk_facevert_count(iter->vdata);
+	if (((BMIter *)iter)->count) {
 		iter->e_first = bmesh_disk_faceedge_find_first(iter->vdata->e, iter->vdata);
 		iter->e_next = iter->e_first;
 		iter->l_first = bmesh_radial_faceloop_find_first(iter->e_first->l, iter->vdata);
 		iter->l_next = iter->l_first;
 	}
+	else {
+		iter->l_first = iter->l_next = NULL;
+		iter->e_first = iter->e_next = NULL;
+	}
 }
-void  *bmiter__loop_of_vert_step(BMIter *iter)
+void  *bmiter__loop_of_vert_step(struct BMIter__loop_of_vert *iter)
 {
-	BMLoop *current = iter->l_next;
+	BMLoop *l_curr = iter->l_next;
 
-	if (iter->count) {
-		iter->count--;
+	if (((BMIter *)iter)->count) {
+		((BMIter *)iter)->count--;
 		iter->l_next = bmesh_radial_faceloop_find_next(iter->l_next, iter->vdata);
 		if (iter->l_next == iter->l_first) {
 			iter->e_next = bmesh_disk_faceedge_find_next(iter->e_next, iter->vdata);
@@ -447,107 +437,86 @@ void  *bmiter__loop_of_vert_step(BMIter *iter)
 		}
 	}
 	
-	if (!iter->count) iter->l_next = NULL;
-
-	
-	if (current) {
-		return current;
+	if (!((BMIter *)iter)->count) {
+		iter->l_next = NULL;
 	}
 
-	return NULL;
+	/* NULL on finish */
+	return l_curr;
 }
 
+/*
+ * LOOP OF EDGE CALLBACKS
+ */
 
-void  bmiter__loops_of_edge_begin(BMIter *iter)
+void  bmiter__loop_of_edge_begin(struct BMIter__loop_of_edge *iter)
 {
-	BMLoop *l;
-
-	l = iter->edata->l;
-
-	/* note sure why this sets ldata ... */
-	init_iterator(iter);
-	
-	iter->l_first = iter->l_next = l;
+	iter->l_first = iter->l_next = iter->edata->l;
 }
 
-void  *bmiter__loops_of_edge_step(BMIter *iter)
+void  *bmiter__loop_of_edge_step(struct BMIter__loop_of_edge *iter)
 {
-	BMLoop *current = iter->l_next;
+	BMLoop *l_curr = iter->l_next;
 
 	if (iter->l_next) {
 		iter->l_next = iter->l_next->radial_next;
+		if (iter->l_next == iter->l_first) {
+			iter->l_next = NULL;
+		}
 	}
 
-	if (iter->l_next == iter->l_first) {
-		iter->l_next = NULL;
-	}
-
-	if (current) {
-		return current;
-	}
-
-	return NULL;
+	/* NULL on finish */
+	return l_curr;
 }
 
-void  bmiter__loops_of_loop_begin(BMIter *iter)
-{
-	BMLoop *l;
-
-	l = iter->ldata;
-
-	/* note sure why this sets ldata ... */
-	init_iterator(iter);
+/*
+ * LOOP OF LOOP CALLBACKS
+ */
 
-	iter->l_first = l;
+void  bmiter__loop_of_loop_begin(struct BMIter__loop_of_loop *iter)
+{
+	iter->l_first = iter->ldata;
 	iter->l_next = iter->l_first->radial_next;
 	
 	if (iter->l_next == iter->l_first)
 		iter->l_next = NULL;
 }
 
-void  *bmiter__loops_of_loop_step(BMIter *iter)
+void  *bmiter__loop_of_loop_step(struct BMIter__loop_of_loop *iter)
 {
-	BMLoop *current = iter->l_next;
+	BMLoop *l_curr = iter->l_next;
 	
 	if (iter->l_next) {
 		iter->l_next = iter->l_next->radial_next;
+		if (iter->l_next == iter->l_first) {
+			iter->l_next = NULL;
+		}
 	}
 
-	if (iter->l_next == iter->l_first) {
-		iter->l_next = NULL;
-	}
-
-	if (current) {
-		return current;
-	}
-
-	return NULL;
+	/* NULL on finish */
+	return l_curr;
 }
 
 /*
  * FACE OF EDGE CALLBACKS
  */
 
-void  bmiter__face_of_edge_begin(BMIter *iter)
+void  bmiter__face_of_edge_begin(struct BMIter__face_of_edge *iter)
 {
-	init_iterator(iter);
-	
-	if (iter->edata->l) {
-		iter->l_first = iter->edata->l;
-		iter->l_next = iter->edata->l;
-	}
+	iter->l_first = iter->l_next = iter->edata->l;
 }
 
-void  *bmiter__face_of_edge_step(BMIter *iter)
+void  *bmiter__face_of_edge_step(struct BMIter__face_of_edge *iter)
 {
 	BMLoop *current = iter->l_next;
 
 	if (iter->l_next) {
 		iter->l_next = iter->l_next->radial_next;
+		if (iter->l_next == iter->l_first) {
+			iter->l_next = NULL;
+		}
 	}
 
-	if (iter->l_next == iter->l_first) iter->l_next = NULL;
-
 	return current ? current->f : NULL;
 }
 
@@ -555,19 +524,17 @@ void  *bmiter__face_of_edge_step(BMIter *iter)
  * VERTS OF EDGE CALLBACKS
  */
 
-void  bmiter__vert_of_edge_begin(BMIter *iter)
+void  bmiter__vert_of_edge_begin(struct BMIter__vert_of_edge *iter)
 {
-	init_iterator(iter);
-	iter->count = 0;
+	((BMIter *)iter)->count = 0;
 }
 
-void  *bmiter__vert_of_edge_step(BMIter *iter)
+void  *bmiter__vert_of_edge_step(struct BMIter__vert_of_edge *iter)
 {
-	iter->count++;
-	switch (iter->count) {
-		case 1:
+	switch (((BMIter *)iter)->count++) {
+		case 0:
 			return iter->edata->v1;
-		case 2:
+		case 1:
 			return iter->edata->v2;
 		default:
 			return NULL;
@@ -578,58 +545,67 @@ void  *bmiter__vert_of_edge_step(BMIter *iter)
  * VERT OF FACE CALLBACKS
  */
 
-void  bmiter__vert_of_face_begin(BMIter *iter)
+void  bmiter__vert_of_face_begin(struct BMIter__vert_of_face *iter)
 {
-	init_iterator(iter);
 	iter->l_first = iter->l_next = BM_FACE_FIRST_LOOP(iter->pdata);
 }
 
-void  *bmiter__vert_of_face_step(BMIter *iter)
+void  *bmiter__vert_of_face_step(struct BMIter__vert_of_face *iter)
 {
-	BMLoop *current = iter->l_next;
+	BMLoop *l_curr = iter->l_next;
 
-	if (iter->l_next) iter->l_next = iter->l_next->next;
-	if (iter->l_next == iter->l_first) iter->l_next = NULL;
+	if (iter->l_next) {
+		iter->l_next = iter->l_next->next;
+		if (iter->l_next == iter->l_first) {
+			iter->l_next = NULL;
+		}
+	}
 
-	return current ? current->v : NULL;
+	return l_curr ? l_curr->v : NULL;
 }
 
 /*
  * EDGE OF FACE CALLBACKS
  */
 
-void  bmiter__edge_of_face_begin(BMIter *iter)
+void  bmiter__edge_of_face_begin(struct BMIter__edge_of_face *iter)
 {
-	init_iterator(iter);
 	iter->l_first = iter->l_next = BM_FACE_FIRST_LOOP(iter->pdata);
 }
 
-void  *bmiter__edge_of_face_step(BMIter *iter)
+void  *bmiter__edge_of_face_step(struct BMIter__edge_of_face *iter)
 {
-	BMLoop *current = iter->l_next;
+	BMLoop *l_curr = iter->l_next;
 
-	if (iter->l_next) iter->l_next = iter->l_next->next;
-	if (iter->l_next == iter->l_first) iter->l_next = NULL;
+	if (iter->l_next) {
+		iter->l_next = iter->l_next->next;
+		if (iter->l_next == iter->l_first) {
+			iter->l_next = NULL;
+		}
+	}
 	
-	return current ? current->e : NULL;
+	return l_curr ? l_curr->e : NULL;
 }
 
 /*
  * LOOP OF FACE CALLBACKS
  */
 
-void  bmiter__loop_of_face_begin(BMIter *iter)
+void  bmiter__loop_of_face_begin(struct BMIter__loop_of_face *iter)
 {
-	init_iterator(iter);
 	iter->l_first = iter->l_next = BM_FACE_FIRST_LOOP(iter->pdata);
 }
 
-void  *bmiter__loop_of_face_step(BMIter *iter)
+void  *bmiter__loop_of_face_step(struct BMIter__loop_of_face *iter)
 {
-	BMLoop *current = iter->l_next;
+	BMLoop *l_curr = iter->l_next;
 
-	if (iter->l_next) iter->l_next = iter->l_next->next;
-	if (iter->l_next == iter->l_first) iter->l_next = NULL;
+	if (iter->l_next) {
+		iter->l_next = iter->l_next->next;
+		if (iter->l_next == iter->l_first) {
+			iter->l_next = NULL;
+		}
+	}
 
-	return current;
+	return l_curr;
 }
diff --git a/source/blender/bmesh/intern/bmesh_iterators.h b/source/blender/bmesh/intern/bmesh_iterators.h
index b32b191e5c4..e4d7a88dc83 100644
--- a/source/blender/bmesh/intern/bmesh_iterators.h
+++ b/source/blender/bmesh/intern/bmesh_iterators.h
@@ -94,27 +94,89 @@ extern const char bm_iter_itype_htype_map[BM_ITYPE_MAX];
 #define BM_ITER_ELEM_INDEX(ele, iter, data, itype, indexvar) \
 	for (ele = BM_iter_new(iter, NULL, itype, data), indexvar = 0; ele; ele = BM_iter_step(iter), (indexvar)++)
 
+/* iterator type structs */
+struct BMIter__vert_of_mesh {
+	BMesh *bm;
+	BLI_mempool_iter pooliter;
+};
+struct BMIter__edge_of_mesh {
+	BMesh *bm;
+	BLI_mempool_iter pooliter;
+};
+struct BMIter__face_of_mesh {
+	BMesh *bm;
+	BLI_mempool_iter pooliter;
+};
+struct BMIter__edge_of_vert {
+	BMVert *vdata;
+	BMEdge *e_first, *e_next;
+};
+struct BMIter__face_of_vert {
+	BMVert *vdata;
+	BMLoop *l_first, *l_next;
+	BMEdge *e_first, *e_next;
+};
+struct BMIter__loop_of_vert {
+	BMVert *vdata;
+	BMLoop *l_first, *l_next;
+	BMEdge *e_first, *e_next;
+};
+struct BMIter__loop_of_edge {
+	BMEdge *edata;
+	BMLoop *l_first, *l_next;
+};
+struct BMIter__loop_of_loop {
+	BMLoop *ldata;
+	BMLoop *l_first, *l_next;
+};
+struct BMIter__face_of_edge {
+	BMEdge *edata;
+	BMLoop *l_first, *l_next;
+};
+struct BMIter__vert_of_edge {
+	BMEdge *edata;
+};
+struct BMIter__vert_of_face {
+	BMFace *pdata;
+	BMLoop *l_first, *l_next;
+};
+struct BMIter__edge_of_face {
+	BMFace *pdata;
+	BMLoop *l_first, *l_next;
+};
+struct BMIter__loop_of_face {
+	BMFace *pdata;
+	BMLoop *l_first, *l_next;
+};
+
+typedef void  (*BMIter__begin_cb) (void *);
+typedef void *(*BMIter__step_cb) (void *);
+
 /* Iterator Structure */
 /* note: some of these vars are not used,
  * so they have beem commented to save stack space since this struct is used all over */
 typedef struct BMIter {
-	BLI_mempool_iter pooliter;
-
-	BMVert /* *v_first, *v_next, */ *vdata;
-	BMEdge *e_first, *e_next, *edata;
-	BMLoop *l_first, *l_next, *ldata;
-	BMFace /* *f_first, *f_next, */ *pdata;
-	BMesh *bm;
-	void (*begin)(struct BMIter *iter);
-	void *(*step)(struct BMIter *iter);
-#if 0
+	/* keep union first */
 	union {
-		void       *p;
-		int         i;
-		long        l;
-		float       f;
-	} filter;
-#endif
+		struct BMIter__vert_of_mesh vert_of_mesh;
+		struct BMIter__edge_of_mesh edge_of_mesh;
+		struct BMIter__face_of_mesh face_of_mesh;
+
+		struct BMIter__edge_of_vert edge_of_vert;
+		struct BMIter__face_of_vert face_of_vert;
+		struct BMIter__loop_of_vert loop_of_vert;
+		struct BMIter__loop_of_edge loop_of_edge;
+		struct BMIter__loop_of_loop loop_of_loop;
+		struct BMIter__face_of_edge face_of_edge;
+		struct BMIter__vert_of_edge vert_of_edge;
+		struct BMIter__vert_of_face vert_of_face;
+		struct BMIter__edge_of_face edge_of_face;
+		struct BMIter__loop_of_face loop_of_face;
+	} data;
+
+	BMIter__begin_cb begin;
+	BMIter__step_cb step;
+
 	int count;  /* note, only some iterators set this, don't rely on it */
 	char itype;
 } BMIter;
@@ -143,32 +205,27 @@ int     BMO_iter_elem_count_flag(BMesh *bm, const char itype, void *data, const
 int     BM_iter_mesh_count_flag(const char itype, BMesh *bm, const char hflag, const bool value);
 
 /* private for bmesh_iterators_inline.c */
-void  bmiter__vert_of_mesh_begin(struct BMIter *iter);
-void *bmiter__vert_of_mesh_step(struct BMIter *iter);
-void  bmiter__edge_of_mesh_begin(struct BMIter *iter);
-void *bmiter__edge_of_mesh_step(struct BMIter *iter);
-void  bmiter__face_of_mesh_begin(struct BMIter *iter);
-void *bmiter__face_of_mesh_step(struct BMIter *iter);
-void  bmiter__edge_of_vert_begin(struct BMIter *iter);
-void *bmiter__edge_of_vert_step(struct BMIter *iter);
-void  bmiter__face_of_vert_begin(struct BMIter *iter);
-void *bmiter__face_of_vert_step(struct BMIter *iter);
-void  bmiter__loop_of_vert_begin(struct BMIter *iter);
-void *bmiter__loop_of_vert_step(struct BMIter *iter);
-void  bmiter__loops_of_edge_begin(struct BMIter *iter);
-void *bmiter__loops_of_edge_step(struct BMIter *iter);
-void  bmiter__loops_of_loop_begin(struct BMIter *iter);
-void *bmiter__loops_of_loop_step(struct BMIter *iter);
-void  bmiter__face_of_edge_begin(struct BMIter *iter);
-void *bmiter__face_of_edge_step(struct BMIter *iter);
-void  bmiter__vert_of_edge_begin(struct BMIter *iter);
-void *bmiter__vert_of_edge_step(struct BMIter *iter);
-void  bmiter__vert_of_face_begin(struct BMIter *iter);
-void *bmiter__vert_of_face_step(struct BMIter *iter);
-void  bmiter__edge_of_face_begin(struct BMIter *iter);
-void *bmiter__edge_of_face_step(struct BMIter *iter);
-void  bmiter__loop_of_face_begin(struct BMIter *iter);
-void *bmiter__loop_of_face_step(struct BMIter *iter);
+
+#define BMITER_CB_DEF(name) \
+	struct BMIter__##name; \
+	void  bmiter__##name##_begin(struct BMIter__##name *iter); \
+	void *bmiter__##name##_step(struct BMIter__##name *iter)
+
+BMITER_CB_DEF(vert_of_mesh);
+BMITER_CB_DEF(edge_of_mesh);
+BMITER_CB_DEF(face_of_mesh);
+BMITER_CB_DEF(edge_of_vert);
+BMITER_CB_DEF(face_of_vert);
+BMITER_CB_DEF(loop_of_vert);
+BMITER_CB_DEF(loop_of_edge);
+BMITER_CB_DEF(loop_of_loop);
+BMITER_CB_DEF(face_of_edge);
+BMITER_CB_DEF(vert_of_edge);
+BMITER_CB_DEF(vert_of_face);
+BMITER_CB_DEF(edge_of_face);
+BMITER_CB_DEF(loop_of_face);
+
+#undef BMITER_CB_DEF
 
 #include "intern/bmesh_iterators_inline.h"
 
diff --git a/source/blender/bmesh/intern/bmesh_iterators_inline.h b/source/blender/bmesh/intern/bmesh_iterators_inline.h
index faa109617d5..6a0eb0e0a30 100644
--- a/source/blender/bmesh/intern/bmesh_iterators_inline.h
+++ b/source/blender/bmesh/intern/bmesh_iterators_inline.h
@@ -54,87 +54,89 @@ BLI_INLINE bool BM_iter_init(BMIter *iter, BMesh *bm, const char itype, void *da
 {
 	/* int argtype; */
 	iter->itype = itype;
-	iter->bm = bm;
 
 	/* inlining optimizes out this switch when called with the defined type */
 	switch ((BMIterType)itype) {
 		case BM_VERTS_OF_MESH:
 			BLI_assert(bm != NULL);
 			BLI_assert(data == NULL);
-			iter->begin = bmiter__vert_of_mesh_begin;
-			iter->step =  bmiter__vert_of_mesh_step;
+			iter->begin = (BMIter__begin_cb)bmiter__vert_of_mesh_begin;
+			iter->step  = (BMIter__step_cb)bmiter__vert_of_mesh_step;
+			iter->data.vert_of_mesh.bm = bm;
 			break;
 		case BM_EDGES_OF_MESH:
 			BLI_assert(bm != NULL);
 			BLI_assert(data == NULL);
-			iter->begin = bmiter__edge_of_mesh_begin;
-			iter->step =  bmiter__edge_of_mesh_step;
+			iter->begin = (BMIter__begin_cb)bmiter__edge_of_mesh_begin;
+			iter->step  = (BMIter__step_cb)bmiter__edge_of_mesh_step;
+			iter->data.edge_of_mesh.bm = bm;
 			break;
 		case BM_FACES_OF_MESH:
 			BLI_assert(bm != NULL);
 			BLI_assert(data == NULL);
-			iter->begin = bmiter__face_of_mesh_begin;
-			iter->step =  bmiter__face_of_mesh_step;
+			iter->begin = (BMIter__begin_cb)bmiter__face_of_mesh_begin;
+			iter->step  = (BMIter__step_cb)bmiter__face_of_mesh_step;
+			iter->data.face_of_mesh.bm = bm;
 			break;
 		case BM_EDGES_OF_VERT:
 			BLI_assert(data != NULL);
-			iter->begin = bmiter__edge_of_vert_begin;
-			iter->step =  bmiter__edge_of_vert_step;
-			iter->vdata = (BMVert *)data;
+			iter->begin = (BMIter__begin_cb)bmiter__edge_of_vert_begin;
+			iter->step  = (BMIter__step_cb)bmiter__edge_of_vert_step;
+			iter->data.edge_of_vert.vdata = (BMVert *)data;
 			break;
 		case BM_FACES_OF_VERT:
 			BLI_assert(data != NULL);
-			iter->begin = bmiter__face_of_vert_begin;
-			iter->step =  bmiter__face_of_vert_step;
-			iter->vdata = (BMVert *)data;
+			iter->begin = (BMIter__begin_cb)bmiter__face_of_vert_begin;
+			iter->step  = (BMIter__step_cb)bmiter__face_of_vert_step;
+			iter->data.face_of_vert.vdata = (BMVert *)data;
 			break;
 		case BM_LOOPS_OF_VERT:
 			BLI_assert(data != NULL);
-			iter->begin = bmiter__loop_of_vert_begin;
-			iter->step =  bmiter__loop_of_vert_step;
-			iter->vdata = (BMVert *)data;
+			iter->begin = (BMIter__begin_cb)bmiter__loop_of_vert_begin;
+			iter->step  = (BMIter__step_cb)bmiter__loop_of_vert_step;
+			iter->data.loop_of_vert.vdata = (BMVert *)data;
 			break;
 		case BM_VERTS_OF_EDGE:
 			BLI_assert(data != NULL);
-			iter->begin = bmiter__vert_of_edge_begin;
-			iter->step =  bmiter__vert_of_edge_step;
-			iter->edata = (BMEdge *)data;
+			iter->begin = (BMIter__begin_cb)bmiter__vert_of_edge_begin;
+			iter->step  = (BMIter__step_cb)bmiter__vert_of_edge_step;
+			iter->data.vert_of_edge.edata = (BMEdge *)data;
 			break;
 		case BM_FACES_OF_EDGE:
 			BLI_assert(data != NULL);
-			iter->begin = bmiter__face_of_edge_begin;
-			iter->step =  bmiter__face_of_edge_step;
-			iter->edata = (BMEdge *)data;
+			iter->begin = (BMIter__begin_cb)bmiter__face_of_edge_begin;
+			iter->step  = (BMIter__step_cb)bmiter__face_of_edge_step;
+			iter->data.face_of_edge.edata = (BMEdge *)data;
 			break;
 		case BM_VERTS_OF_FACE:
 			BLI_assert(data != NULL);
-			iter->begin = bmiter__vert_of_face_begin;
-			iter->step =  bmiter__vert_of_face_step;
-			iter->pdata = (BMFace *)data;
+			iter->begin = (BMIter__begin_cb)bmiter__vert_of_face_begin;
+			iter->step  = (BMIter__step_cb)bmiter__vert_of_face_step;
+			iter->data.vert_of_face.pdata = (BMFace *)data;
 			break;
 		case BM_EDGES_OF_FACE:
 			BLI_assert(data != NULL);
-			iter->begin = bmiter__edge_of_face_begin;
-			iter->step =  bmiter__edge_of_face_step;
-			iter->pdata = (BMFace *)data;
+			iter->begin = (BMIter__begin_cb)bmiter__edge_of_face_begin;
+			iter->step  = (BMIter__step_cb)bmiter__edge_of_face_step;
+			iter->data.edge_of_face.pdata = (BMFace *)data;
 			break;
 		case BM_LOOPS_OF_FACE:
 			BLI_assert(data != NULL);
-			iter->begin = bmiter__loop_of_face_begin;
-			iter->step =  bmiter__loop_of_face_step;
-			iter->pdata = (BMFace *)data;
+			iter->begin = (BMIter__begin_cb)bmiter__loop_of_face_begin;
+			iter->step  = (BMIter__step_cb)bmiter__loop_of_face_step;
+			iter->data.loop_of_face.pdata = (BMFace *)data;
 			break;
 		case BM_LOOPS_OF_LOOP:
 			BLI_assert(data != NULL);
-			iter->begin = bmiter__loops_of_loop_begin;
-			iter->step =  bmiter__loops_of_loop_step;
-			iter->ldata = (BMLoop *)data;
+			iter->begin = (BMIter__begin_cb)bmiter__loop_of_loop_begin;
+			iter->step  = (BMIter__step_cb)bmiter__loop_of_loop_step;
+			iter->data.loop_of_loop.ldata = (BMLoop *)data;
 			break;
 		case BM_LOOPS_OF_EDGE:
 			BLI_assert(data != NULL);
-			iter->begin = bmiter__loops_of_edge_begin;
-			iter->step =  bmiter__loops_of_edge_step;
-			iter->edata = (BMEdge *)data;
+			iter->begin = (BMIter__begin_cb)bmiter__loop_of_edge_begin;
+			iter->step  = (BMIter__step_cb)bmiter__loop_of_edge_step;
+			iter->data.loop_of_edge.edata = (BMEdge *)data;
 			break;
 		default:
 			/* should never happen */