bmesh: internal api change, remove BMOElemMapping, its not needed since the values can be stored in the ghash directly.

saves 24 bytes per element (per vertex/edge/face on a 64bit system), for bmesh operators.

source/blender/bmesh/intern/bmesh_operator_api.h

@@ -398,7 +398,7 @@ int BMO_slot_buffer_count(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot
 int BMO_slot_map_count(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name);
 
 void BMO_slot_map_insert(BMOperator *op, BMOpSlot *slot,
-                         const void *element, const void *data, const int len);
+                         const void *element, const void *data);
 
 /* flags all elements in a mapping.  note that the mapping must only have
  * bmesh elements in it.*/
@@ -452,7 +452,7 @@ typedef struct BMOIter {
 	BMOpSlot *slot;
 	int cur; //for arrays
 	GHashIterator giter;
-	void *val;
+	void **val;
 	char restrictmask; /* bitwise '&' with BMHeader.htype */
 } BMOIter;
 
@@ -463,15 +463,12 @@ void *BMO_iter_new(BMOIter *iter,
                    const char restrictmask);
 void *BMO_iter_step(BMOIter *iter);
 
-/* returns a pointer to the key value when iterating over mappings.
+void **BMO_iter_map_value_p(BMOIter *iter);
- * remember for pointer maps this will be a pointer to a pointer.*/
+void  *BMO_iter_map_value_ptr(BMOIter *iter);
-void *BMO_iter_map_value(BMOIter *iter);
 
-/* use this for pointer mappings */
+float BMO_iter_map_value_float(BMOIter *iter);
-void *BMO_iter_map_value_p(BMOIter *iter);
+int   BMO_iter_map_value_int(BMOIter *iter);
-
+bool  BMO_iter_map_value_bool(BMOIter *iter);
-/* use this for float mappings */
-float BMO_iter_map_value_f(BMOIter *iter);
 
 #define BMO_ITER(ele, iter, slot_args, slot_name, restrict_flag)   \
 	for (ele = BMO_iter_new(iter, slot_args, slot_name, restrict_flag); ele; ele = BMO_iter_step(iter))
@@ -479,16 +476,6 @@ float BMO_iter_map_value_f(BMOIter *iter);
 /******************* Inlined Functions********************/
 typedef void (*opexec)(BMesh *bm, BMOperator *op);
 
-/* mappings map elements to data, which
- * follows the mapping struct in memory. */
-typedef struct BMOElemMapping {
-	BMHeader *element;
-	int len;
-} BMOElemMapping;
-
-/* pointer after BMOElemMapping */
-#define BMO_OP_SLOT_MAPPING_DATA(var) (void *)(((BMOElemMapping *)var) + 1)
-
 extern const int BMO_OPSLOT_TYPEINFO[BMO_OP_SLOT_TOTAL_TYPES];
 
 int BMO_opcode_from_opname(const char *opname);

source/blender/bmesh/intern/bmesh_operator_api_inline.h

@@ -72,23 +72,26 @@ BLI_INLINE void _bmo_elem_flag_toggle(BMesh *bm, BMFlagLayer *oflags, const shor
 BLI_INLINE void BMO_slot_map_int_insert(BMOperator *op, BMOpSlot *slot,
                                         void *element, const int val)
 {
+	union { void *ptr; int val; } t = {NULL};
 	BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_INT);
-	BMO_slot_map_insert(op, slot, element, &val, sizeof(int));
+	BMO_slot_map_insert(op, slot, element, ((t.val = val), t.ptr));
 }
 
 BLI_INLINE void BMO_slot_map_bool_insert(BMOperator *op, BMOpSlot *slot,
                                         void *element, const int val)
 {
+	union { void *ptr; int val; } t = {NULL};
 	BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_BOOL);
 	BLI_assert(val == false || val == true);
-	BMO_slot_map_insert(op, slot, element, &val, sizeof(int));
+	BMO_slot_map_insert(op, slot, element, ((t.val = val), t.ptr));
 }
 
 BLI_INLINE void BMO_slot_map_float_insert(BMOperator *op, BMOpSlot *slot,
                                           void *element, const float val)
 {
+	union { void *ptr; float val; } t = {NULL};
 	BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_FLT);
-	BMO_slot_map_insert(op, slot, element, &val, sizeof(float));
+	BMO_slot_map_insert(op, slot, element, ((t.val = val), t.ptr));
 }
 
 
@@ -101,14 +104,14 @@ BLI_INLINE void BMO_slot_map_ptr_insert(BMOperator *op, BMOpSlot *slot,
                                         const void *element, void *val)
 {
 	BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_INTERNAL);
-	BMO_slot_map_insert(op, slot, element, &val, sizeof(void *));
+	BMO_slot_map_insert(op, slot, element, val);
 }
 
 BLI_INLINE void BMO_slot_map_elem_insert(BMOperator *op, BMOpSlot *slot,
                                         const void *element, void *val)
 {
 	BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_ELEM);
-	BMO_slot_map_insert(op, slot, element, &val, sizeof(void *));
+	BMO_slot_map_insert(op, slot, element, val);
 }
 
 
@@ -117,7 +120,7 @@ BLI_INLINE void BMO_slot_map_empty_insert(BMOperator *op, BMOpSlot *slot,
                                         const void *element)
 {
 	BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_EMPTY);
-	BMO_slot_map_insert(op, slot, element, NULL, 0);
+	BMO_slot_map_insert(op, slot, element, NULL);
 }
 
 BLI_INLINE bool BMO_slot_map_contains(BMOpSlot *slot, const void *element)
@@ -126,57 +129,57 @@ BLI_INLINE bool BMO_slot_map_contains(BMOpSlot *slot, const void *element)
 	return BLI_ghash_haskey(slot->data.ghash, element);
 }
 
-BLI_INLINE void *BMO_slot_map_data_get(BMOpSlot *slot, const void *element)
+BLI_INLINE void **BMO_slot_map_data_get(BMOpSlot *slot, const void *element)
 {
-	BMOElemMapping *mapping;
-	BLI_assert(slot->slot_type == BMO_OP_SLOT_MAPPING);
 
-	mapping = (BMOElemMapping *)BLI_ghash_lookup(slot->data.ghash, element);
+	return BLI_ghash_lookup_p(slot->data.ghash, element);
-
-	if (!mapping) {
-		return NULL;
-	}
-
-	return mapping + 1;
 }
 
 BLI_INLINE float BMO_slot_map_float_get(BMOpSlot *slot, const void *element)
 {
-	float *val;
+	void **data;
 	BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_FLT);
 
-	val = (float *) BMO_slot_map_data_get(slot, element);
+	data = BMO_slot_map_data_get(slot, element);
-	if (val) return *val;
+	if (data) {
-
+		return **(float **)data;
-	return 0.0f;
+	}
+	else {
+		return 0.0f;
+	}
 }
 
 BLI_INLINE int BMO_slot_map_int_get(BMOpSlot *slot, const void *element)
 {
-	int *val;
+	void **data;
 	BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_INT);
 
-	val = (int *) BMO_slot_map_data_get(slot, element);
+	data = BMO_slot_map_data_get(slot, element);
-	if (val) return *val;
+	if (data) {
-
+		return **(int **)data;
-	return 0;
+	}
+	else {
+		return 0;
+	}
 }
 
 BLI_INLINE bool BMO_slot_map_bool_get(BMOpSlot *slot, const void *element)
 {
-	int *val;
+	void **data;
 	BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_BOOL);
 
-	val = (int *) BMO_slot_map_data_get(slot, element);
+	data = BMO_slot_map_data_get(slot, element);
-	BLI_assert(val == NULL || *val == false || *val == true);
+	if (data) {
-	if (val) return (bool)*val;
+		return **(int **)data;
-
+	}
-	return false;
+	else {
+		return false;
+	}
 }
 
 BLI_INLINE void *BMO_slot_map_ptr_get(BMOpSlot *slot, const void *element)
 {
-	void **val = (void **) BMO_slot_map_data_get(slot, element);
+	void **val = BMO_slot_map_data_get(slot, element);
 	BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_INTERNAL);
 	if (val) return *val;
 

source/blender/bmesh/intern/bmesh_operators.c

@@ -74,7 +74,7 @@ const int BMO_OPSLOT_TYPEINFO[BMO_OP_SLOT_TOTAL_TYPES] = {
 	0,                      /*  7: unused */
 	sizeof(float) * 3,      /*  8: BMO_OP_SLOT_VEC */
 	sizeof(void *),	        /*  9: BMO_OP_SLOT_ELEMENT_BUF */
-	sizeof(BMOElemMapping)  /* 10: BMO_OP_SLOT_MAPPING */
+	sizeof(void *)          /* 10: BMO_OP_SLOT_MAPPING */
 };
 
 /* Dummy slot so there is something to return when slot name lookup fails */
@@ -345,19 +345,13 @@ void _bmo_slot_copy(BMOpSlot slot_args_src[BMO_OP_MAX_SLOTS], const char *slot_n
 	}
 	else if (slot_dst->slot_type == BMO_OP_SLOT_MAPPING) {
 		GHashIterator it;
-		BMOElemMapping *srcmap, *dstmap;
-
 		for (BLI_ghashIterator_init(&it, slot_src->data.ghash);
-		     (srcmap = BLI_ghashIterator_getValue(&it));
+		     BLI_ghashIterator_done(&it) == false;
 		     BLI_ghashIterator_step(&it))
 		{
-			dstmap = BLI_memarena_alloc(arena_dst, sizeof(*dstmap) + srcmap->len);
+			void *key = BLI_ghashIterator_getKey(&it);
-
+			void *val = BLI_ghashIterator_getValue(&it);
-			dstmap->element = srcmap->element;
+			BLI_ghash_insert(slot_dst->data.ghash, key, val);
-			dstmap->len = srcmap->len;
-			memcpy(BMO_OP_SLOT_MAPPING_DATA(dstmap), BMO_OP_SLOT_MAPPING_DATA(srcmap), srcmap->len);
-
-			BLI_ghash_insert(slot_dst->data.ghash, dstmap->element, dstmap);
 		}
 	}
 	else {
@@ -631,19 +625,12 @@ int BMO_slot_map_count(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_na
  * value, it doesn't store a reference to it. */
 
 void BMO_slot_map_insert(BMOperator *op, BMOpSlot *slot,
-                         const void *element, const void *data, const int len)
+                         const void *element, const void *data)
 {
-	BMOElemMapping *mapping;
 	BLI_assert(slot->slot_type == BMO_OP_SLOT_MAPPING);
 	BMO_ASSERT_SLOT_IN_OP(slot, op);
 
-	mapping = (BMOElemMapping *) BLI_memarena_alloc(op->arena, sizeof(*mapping) + len);
+	BLI_ghash_insert(slot->data.ghash, (void *)element, (void *)data);
-
-	mapping->element = (BMHeader *) element;
-	mapping->len = len;
-	memcpy(BMO_OP_SLOT_MAPPING_DATA(mapping), data, len);
-
-	BLI_ghash_insert(slot->data.ghash, (void *)element, mapping);
 }
 
 #if 0
@@ -1388,11 +1375,8 @@ void *BMO_iter_step(BMOIter *iter)
 		return ele;
 	}
 	else if (slot->slot_type == BMO_OP_SLOT_MAPPING) {
-		BMOElemMapping *map;
 		void *ret = BLI_ghashIterator_getKey(&iter->giter);
-		map = BLI_ghashIterator_getValue(&iter->giter);
+		iter->val = BLI_ghashIterator_getValue_p(&iter->giter);
-		
-		iter->val = BMO_OP_SLOT_MAPPING_DATA(map);
 
 		BLI_ghashIterator_step(&iter->giter);
 
@@ -1406,19 +1390,40 @@ void *BMO_iter_step(BMOIter *iter)
 }
 
 /* used for iterating over mappings */
-void *BMO_iter_map_value(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_iter_map_value_p(BMOIter *iter)
 {
 	return iter->val;
 }
 
-void *BMO_iter_map_value_p(BMOIter *iter)
+void *BMO_iter_map_value_ptr(BMOIter *iter)
 {
-	return *((void **)iter->val);
+	BLI_assert(ELEM(iter->slot->slot_subtype.map,
+	                BMO_OP_SLOT_SUBTYPE_MAP_ELEM, BMO_OP_SLOT_SUBTYPE_MAP_INTERNAL));
+	return iter->val ? *iter->val : NULL;
 }
 
-float BMO_iter_map_value_f(BMOIter *iter)
+
+float BMO_iter_map_value_float(BMOIter *iter)
 {
-	return *((float *)iter->val);
+	BLI_assert(iter->slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_FLT);
+	return **((float **)iter->val);
+}
+
+int BMO_iter_map_value_int(BMOIter *iter)
+{
+	BLI_assert(iter->slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_INT);
+	return **((int **)iter->val);
+}
+
+bool BMO_iter_map_value_bool(BMOIter *iter)
+{
+	BLI_assert(iter->slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_BOOL);
+	return **((int **)iter->val);
 }
 
 /* error system */

source/blender/bmesh/operators/bmo_extrude.c

@@ -170,7 +170,7 @@ void bmo_extrude_edge_only_exec(BMesh *bm, BMOperator *op)
 
 	for (e = BMO_iter_new(&siter, dupeop.slots_out, "boundary_map.out", 0); e; e = BMO_iter_step(&siter)) {
 		BMVert *f_verts[4];
-		e_new = *(BMEdge **)BMO_iter_map_value(&siter);
+		e_new = BMO_iter_map_value_ptr(&siter);
 
 		if (e->l && e->v1 != e->l->v) {
 			f_verts[0] = e->v1;
@@ -372,7 +372,7 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op)
 			continue;
 		}
 
-		e_new = *(BMEdge **)BMO_iter_map_value(&siter);
+		e_new = BMO_iter_map_value_ptr(&siter);
 
 		if (!e_new) {
 			continue;
@@ -407,7 +407,7 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op)
 
 	/* link isolated vert */
 	for (v = BMO_iter_new(&siter, dupeop.slots_out, "isovert_map.out", 0); v; v = BMO_iter_step(&siter)) {
-		BMVert *v2 = *((void **)BMO_iter_map_value(&siter));
+		BMVert *v2 = BMO_iter_map_value_ptr(&siter);
 		BM_edge_create(bm, v, v2, v->e, BM_CREATE_NO_DOUBLE);
 	}
 

source/blender/bmesh/operators/bmo_subdivide.c

@@ -921,7 +921,7 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op)
 		}
 
 		if (BMO_elem_flag_test(bm, face, FACE_CUSTOMFILL)) {
-			pat = BMO_slot_map_data_get(params.slot_custom_patterns, face);
+			pat = *BMO_slot_map_data_get(params.slot_custom_patterns, face);
 			for (i = 0; i < pat->len; i++) {
 				matched = 1;
 				for (j = 0; j < pat->len; j++) {

source/blender/modifiers/intern/MOD_array.c

@@ -199,7 +199,7 @@ static int *find_doubles_index_map(BMesh *bm, BMOperator *dupe_op,
 
 	/*element type argument doesn't do anything here*/
 	BMO_ITER (v, &oiter, find_op.slots_out, "targetmap.out", 0) {
-		v2 = BMO_iter_map_value_p(&oiter);
+		v2 = BMO_iter_map_value_ptr(&oiter);
 
 		index_map[BM_elem_index_get(v)] = BM_elem_index_get(v2) + 1;
 	}
@@ -272,7 +272,7 @@ static void bm_merge_dm_transform(BMesh *bm, DerivedMesh *dm, float mat[4][4],
 
 		/* add new merge targets to weld operator */
 		BMO_ITER (v, &oiter, find_op.slots_out, "targetmap.out", 0) {
-			v2 = BMO_iter_map_value_p(&oiter);
+			v2 = BMO_iter_map_value_ptr(&oiter);
 			/* check in case the target vertex (v2) is already marked
 			 * for merging */
 			while ((v3 = BMO_slot_map_elem_get(slot_targetmap, v2))) {
@@ -320,7 +320,7 @@ static void merge_first_last(BMesh *bm,
 	slot_targetmap = BMO_slot_get(weld_op->slots_in, "targetmap");
 	BMO_ITER (v, &oiter, find_op.slots_out, "targetmap.out", 0) {
 		if (!BMO_slot_map_contains(slot_targetmap, v)) {
-			v2 = BMO_iter_map_value_p(&oiter);
+			v2 = BMO_iter_map_value_ptr(&oiter);
 			BMO_slot_map_elem_insert(weld_op, slot_targetmap, v, v2);
 		}
 	}

source/blender/python/bmesh/bmesh_py_ops_call.c

@@ -581,11 +581,11 @@ static PyObject *bpy_slot_to_py(BMesh *bm, BMOpSlot *slot)
 					item = PyDict_New();
 					if (slot_hash) {
 						GHASH_ITER (hash_iter, slot_hash) {
-							BMHeader       *ele_key = BLI_ghashIterator_getKey(&hash_iter);
+							BMHeader *ele_key = BLI_ghashIterator_getKey(&hash_iter);
-							BMOElemMapping *ele_val = BLI_ghashIterator_getValue(&hash_iter);
+							void     *ele_val = BLI_ghashIterator_getValue(&hash_iter);
 
-							PyObject *py_key =  BPy_BMElem_CreatePyObject(bm,  ele_key);
+							PyObject *py_key =  BPy_BMElem_CreatePyObject(bm, ele_key);
-							PyObject *py_val =  BPy_BMElem_CreatePyObject(bm, *(void **)BMO_OP_SLOT_MAPPING_DATA(ele_val));
+							PyObject *py_val =  BPy_BMElem_CreatePyObject(bm, ele_val);
 
 							PyDict_SetItem(item, py_key, py_val);
 							Py_DECREF(py_key);
@@ -599,11 +599,11 @@ static PyObject *bpy_slot_to_py(BMesh *bm, BMOpSlot *slot)
 					item = PyDict_New();
 					if (slot_hash) {
 						GHASH_ITER (hash_iter, slot_hash) {
-							BMHeader       *ele_key = BLI_ghashIterator_getKey(&hash_iter);
+							BMHeader *ele_key = BLI_ghashIterator_getKey(&hash_iter);
-							BMOElemMapping *ele_val = BLI_ghashIterator_getValue(&hash_iter);
+							void     *ele_val = BLI_ghashIterator_getValue(&hash_iter);
 
 							PyObject *py_key =  BPy_BMElem_CreatePyObject(bm,  ele_key);
-							PyObject *py_val =  PyFloat_FromDouble(*(float *)BMO_OP_SLOT_MAPPING_DATA(ele_val));
+							PyObject *py_val =  PyFloat_FromDouble(*(float *)&ele_val);
 
 							PyDict_SetItem(item, py_key, py_val);
 							Py_DECREF(py_key);
@@ -617,11 +617,11 @@ static PyObject *bpy_slot_to_py(BMesh *bm, BMOpSlot *slot)
 					item = PyDict_New();
 					if (slot_hash) {
 						GHASH_ITER (hash_iter, slot_hash) {
-							BMHeader       *ele_key = BLI_ghashIterator_getKey(&hash_iter);
+							BMHeader *ele_key = BLI_ghashIterator_getKey(&hash_iter);
-							BMOElemMapping *ele_val = BLI_ghashIterator_getValue(&hash_iter);
+							void     *ele_val = BLI_ghashIterator_getValue(&hash_iter);
 
 							PyObject *py_key =  BPy_BMElem_CreatePyObject(bm,  ele_key);
-							PyObject *py_val =  PyLong_FromLong(*(int *)BMO_OP_SLOT_MAPPING_DATA(ele_val));
+							PyObject *py_val =  PyLong_FromLong(*(int *)&ele_val);
 
 							PyDict_SetItem(item, py_key, py_val);
 							Py_DECREF(py_key);
@@ -635,11 +635,11 @@ static PyObject *bpy_slot_to_py(BMesh *bm, BMOpSlot *slot)
 					item = PyDict_New();
 					if (slot_hash) {
 						GHASH_ITER (hash_iter, slot_hash) {
-							BMHeader       *ele_key = BLI_ghashIterator_getKey(&hash_iter);
+							BMHeader *ele_key = BLI_ghashIterator_getKey(&hash_iter);
-							BMOElemMapping *ele_val = BLI_ghashIterator_getValue(&hash_iter);
+							void     *ele_val = BLI_ghashIterator_getValue(&hash_iter);
 
 							PyObject *py_key =  BPy_BMElem_CreatePyObject(bm,  ele_key);
-							PyObject *py_val =  PyBool_FromLong(*(int *)BMO_OP_SLOT_MAPPING_DATA(ele_val));
+							PyObject *py_val =  PyBool_FromLong(*(int *)&ele_val);
 
 							PyDict_SetItem(item, py_key, py_val);
 							Py_DECREF(py_key);