7 files changed, 154 insertions, 145 deletions

diff --git a/source/blender/blenkernel/intern/brush.c b/source/blender/blenkernel/intern/brush.c
index 76b0cad337f..ae6ae6087af 100644
--- a/source/blender/blenkernel/intern/brush.c
+++ b/source/blender/blenkernel/intern/brush.c
@@ -937,7 +937,7 @@ void BKE_brush_jitter_pos(const Scene *scene, Brush *brush, const float pos[2],
 	do {
 		rand_pos[0] = BLI_rng_get_float(brush_rng) - 0.5f;
 		rand_pos[1] = BLI_rng_get_float(brush_rng) - 0.5f;
-	} while (len_squared_v2(rand_pos) > (0.5f * 0.5f));
+	} while (len_squared_v2(rand_pos) > SQUARE(0.5f));
 
 
 	if (brush->flag & BRUSH_ABSOLUTE_JITTER) {
diff --git a/source/blender/blenkernel/intern/constraint.c b/source/blender/blenkernel/intern/constraint.c
index ee7bad773fa..e4b60c12d64 100644
--- a/source/blender/blenkernel/intern/constraint.c
+++ b/source/blender/blenkernel/intern/constraint.c
@@ -2658,7 +2658,7 @@ static void stretchto_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *t
 	if (VALID_CONS_TARGET(ct)) {
 		float size[3], scale[3], vec[3], xx[3], zz[3], orth[3];
 		float totmat[3][3];
-		float dist;
+		float dist, bulge;
 		
 		/* store scaling before destroying obmat */
 		mat4_to_size(size, cob->matrix);
@@ -2676,7 +2676,7 @@ static void stretchto_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *t
 /*		vec[2] /= size[2];*/
 		
 /*		dist = normalize_v3(vec);*/
-		
+
 		dist = len_v3v3(cob->matrix[3], ct->matrix[3]);
 		/* Only Y constrained object axis scale should be used, to keep same length when scaling it. */
 		dist /= size[1];
@@ -2684,23 +2684,60 @@ static void stretchto_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *t
 		/* data->orglength==0 occurs on first run, and after 'R' button is clicked */
 		if (data->orglength == 0)
 			data->orglength = dist;
-		if (data->bulge == 0)
-			data->bulge = 1.0;
-		
+
 		scale[1] = dist / data->orglength;
+		
+		bulge = powf(data->orglength / dist, data->bulge);
+		
+		if (data->flag & STRETCHTOCON_USE_BULGE_MAX) {
+			const float bulge_median = ((data->flag & STRETCHTOCON_USE_BULGE_MIN) ?
+			                            0.5f * (data->bulge_min + data->bulge_max) : 0.0f);
+			const float bulge_range = data->bulge_max - bulge_median;
+			float x, bulge_smoothed;
+
+			x = bulge_range != 0.0f ? (bulge - bulge_median) / bulge_range : 0.0f;
+			CLAMP(x, -1.0f, 1.0f);
+			bulge_smoothed = bulge_median + bulge_range * sinf(0.5f*M_PI * x);
+
+			if (data->flag & STRETCHTOCON_USE_BULGE_MIN) {
+				CLAMP_MIN(bulge, data->bulge_min);
+			}
+			CLAMP_MAX(bulge, data->bulge_max);
+
+			bulge = interpf(bulge_smoothed, bulge, data->bulge_smooth);
+		}
+		else if (data->flag & STRETCHTOCON_USE_BULGE_MIN) {
+			/* The quadratic formula below creates a smooth asymptote
+			 * of the clamped bulge value. By scaling x with the inverse smooth factor
+			 * the smoothed area becomes smaller ("less smoothing").
+			 * For very small smoothing factor below epsilon it is replaced
+			 * by the clamped version to avoid floating point precision issues.
+			 */
+			const float epsilon = 0.000001f;
+			if (data->bulge_smooth < epsilon) {
+				CLAMP_MIN(bulge, data->bulge_min);
+			}
+			else {
+				float scale = data->bulge_smooth;
+				float inv_scale = 1.0f / scale;
+				float x = (bulge - data->bulge_min) * 0.5f * inv_scale;
+				bulge = scale * (x + sqrtf((x * x) + 1.0f)) + data->bulge_min;
+			}
+		}
+		
 		switch (data->volmode) {
 			/* volume preserving scaling */
 			case VOLUME_XZ:
-				scale[0] = 1.0f - sqrtf(data->bulge) + sqrtf(data->bulge * (data->orglength / dist));
+				scale[0] = sqrtf(bulge);
 				scale[2] = scale[0];
 				break;
 			case VOLUME_X:
-				scale[0] = 1.0f + data->bulge * (data->orglength / dist - 1);
+				scale[0] = bulge;
 				scale[2] = 1.0;
 				break;
 			case VOLUME_Z:
 				scale[0] = 1.0;
-				scale[2] = 1.0f + data->bulge * (data->orglength / dist - 1);
+				scale[2] = bulge;
 				break;
 			/* don't care for volume */
 			case NO_VOLUME:
diff --git a/source/blender/blenkernel/intern/linestyle.c b/source/blender/blenkernel/intern/linestyle.c
index 5e17117a875..bcdaf9b7af0 100644
--- a/source/blender/blenkernel/intern/linestyle.c
+++ b/source/blender/blenkernel/intern/linestyle.c
@@ -442,7 +442,7 @@ LineStyleModifier *BKE_linestyle_alpha_modifier_add(FreestyleLineStyle *linestyl
 		{
 			LineStyleAlphaModifier_Material *p = (LineStyleAlphaModifier_Material *)m;
 			p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
-			p->mat_attr = LS_MODIFIER_MATERIAL_ALPHA;
+			p->mat_attr = LS_MODIFIER_MATERIAL_LINE_A;
 			break;
 		}
 		default:
diff --git a/source/blender/blenkernel/intern/mesh_mapping.c b/source/blender/blenkernel/intern/mesh_mapping.c
index 82065750791..53d1aae104c 100644
--- a/source/blender/blenkernel/intern/mesh_mapping.c
+++ b/source/blender/blenkernel/intern/mesh_mapping.c
@@ -416,18 +416,22 @@ int *BKE_mesh_calc_smoothgroups(const MEdge *medge, const int totedge,
 		while (ps_curr_idx != ps_end_idx) {
 			const MPoly *mp;
 			const MLoop *ml;
+			bool sharp_poly;
 			int j;
 
 			poly = poly_stack[ps_curr_idx++];
 			BLI_assert(poly_groups[poly] == poly_group_id);
 
 			mp = &mpoly[poly];
+			sharp_poly = !(mp->flag & ME_SMOOTH);
 			for (ml = &mloop[mp->loopstart], j = mp->totloop; j--; ml++) {
 				/* loop over poly users */
 				const MeshElemMap *map_ele = &edge_poly_map[ml->e];
 				const int *p = map_ele->indices;
 				int i = map_ele->count;
-				if (!(medge[ml->e].flag & ME_SHARP)) {
+				/* Edge is smooth only if its poly is not sharp, edge is not sharp,
+				 * and edge is used by exactly two polygons. */
+				if (!sharp_poly && !(medge[ml->e].flag & ME_SHARP) && i == 2) {
 					for (; i--; p++) {
 						/* if we meet other non initialized its a bug */
 						BLI_assert(ELEM(poly_groups[*p], 0, poly_group_id));
@@ -482,6 +486,11 @@ int *BKE_mesh_calc_smoothgroups(const MEdge *medge, const int totedge,
 		}
 	}
 
+	if (use_bitflags) {
+		/* used bits are zero-based. */
+		tot_group++;
+	}
+
 	if (UNLIKELY(group_id_overflow)) {
 		int i = totpoly, *gid = poly_groups;
 		for (; i--; gid++) {
@@ -489,13 +498,15 @@ int *BKE_mesh_calc_smoothgroups(const MEdge *medge, const int totedge,
 				*gid = 0;
 			}
 		}
+		/* Using 0 as group id adds one more group! */
+		tot_group++;
 	}
 
 	MEM_freeN(edge_poly_map);
 	MEM_freeN(edge_poly_mem);
 	MEM_freeN(poly_stack);
 
-	*r_totgroup = tot_group + 1;
+	*r_totgroup = tot_group;
 
 	return poly_groups;
 }
diff --git a/source/blender/blenkernel/intern/multires.c b/source/blender/blenkernel/intern/multires.c
index 246ef8a33f5..df992cc9aed 100644
--- a/source/blender/blenkernel/intern/multires.c
+++ b/source/blender/blenkernel/intern/multires.c
@@ -272,9 +272,7 @@ static MDisps *multires_mdisps_initialize_hidden(Mesh *me, int level)
 			BLI_assert(!md->hidden);
 
 			md->hidden = BLI_BITMAP_NEW(gridarea, "MDisps.hidden initialize");
-
-			for (k = 0; k < gridarea; k++)
-				BLI_BITMAP_ENABLE(md->hidden, k);
+			BLI_BITMAP_SET_ALL(md->hidden, true, gridarea);
 		}
 	}
 
diff --git a/source/blender/blenkernel/intern/object.c b/source/blender/blenkernel/intern/object.c
index 755ce91a8af..7a8843f3308 100644
--- a/source/blender/blenkernel/intern/object.c
+++ b/source/blender/blenkernel/intern/object.c
@@ -1126,7 +1126,7 @@ static LodLevel *lod_level_select(Object *ob, const float camera_position[3])
 	}
 	else {
 		/* check for lower LoD */
-		while (current->next && dist_sq > (current->next->distance * current->next->distance)) {
+		while (current->next && dist_sq > SQUARE(current->next->distance)) {
 			current = current->next;
 		}
 	}
diff --git a/source/blender/blenkernel/intern/pbvh_bmesh.c b/source/blender/blenkernel/intern/pbvh_bmesh.c
index 9e18d54614b..01bca44d3b6 100644
--- a/source/blender/blenkernel/intern/pbvh_bmesh.c
+++ b/source/blender/blenkernel/intern/pbvh_bmesh.c
@@ -41,6 +41,13 @@
 
 #include <assert.h>
 
+// #define USE_VERIFY
+
+#ifdef USE_VERIFY
+static void pbvh_bmesh_verify(PBVH *bvh);
+#endif
+
+
 /****************************** Building ******************************/
 
 /* Update node data after splitting */
@@ -1297,6 +1304,10 @@ bool BKE_pbvh_bmesh_update_topology(PBVH *bvh, PBVHTopologyUpdateMode mode,
 	BLI_buffer_free(&edge_loops);
 	BLI_buffer_free(&deleted_faces);
 
+#ifdef USE_VERIFY
+	pbvh_bmesh_verify(bvh);
+#endif
+
 	return modified;
 }
 
@@ -1418,104 +1429,28 @@ struct GSet *BKE_pbvh_bmesh_node_faces(PBVHNode *node)
 
 #if 0
 
-void bli_gset_duplicate_key_check(GSet *gs)
+static void pbvh_bmesh_print(PBVH *bvh)
 {
-	GSetIterator gs_iter1, gs_iter2;
-
-	GSET_ITER (gs_iter1, gs) {
-		void *key1 = BLI_gsetIterator_getKey(&gs_iter1);
-		int dup = -1;
-
-		GSET_ITER (gs_iter2, gs) {
-			void *key2 = BLI_gsetIterator_getKey(&gs_iter2);
-
-			if (key1 == key2) {
-				dup++;
-				if (dup > 0) {
-					BLI_assert(!"duplicate in hash");
-				}
-			}
-		}
-	}
-}
-
-void bmesh_print(BMesh *bm)
-{
-	BMIter iter, siter;
-	BMVert *v;
-	BMEdge *e;
-	BMFace *f;
-	BMLoop *l;
-
-	fprintf(stderr, "\nbm=%p, totvert=%d, totedge=%d, "
-	        "totloop=%d, totface=%d\n",
-	        bm, bm->totvert, bm->totedge,
-	        bm->totloop, bm->totface);
-
-	fprintf(stderr, "vertices:\n");
-	BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
-		fprintf(stderr, "  %d co=(%.3f %.3f %.3f) oflag=%x\n",
-		        BM_elem_index_get(v), v->co[0], v->co[1], v->co[2],
-		        v->oflags[bm->stackdepth - 1].f);
-	}
-
-	fprintf(stderr, "edges:\n");
-	BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
-		fprintf(stderr, "  %d v1=%d, v2=%d, oflag=%x\n",
-		        BM_elem_index_get(e),
-		        BM_elem_index_get(e->v1),
-		        BM_elem_index_get(e->v2),
-		        e->oflags[bm->stackdepth - 1].f);
-	}
-
-	fprintf(stderr, "faces:\n");
-	BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
-		fprintf(stderr, "  %d len=%d, oflag=%x\n",
-		        BM_elem_index_get(f), f->len,
-		        f->oflags[bm->stackdepth - 1].f);
-
-		fprintf(stderr, "    v: ");
-		BM_ITER_ELEM(v, &siter, f, BM_VERTS_OF_FACE) {
-			fprintf(stderr, "%d ", BM_elem_index_get(v));
-		}
-		fprintf(stderr, "\n");
-
-		fprintf(stderr, "    e: ");
-		BM_ITER_ELEM(e, &siter, f, BM_EDGES_OF_FACE) {
-			fprintf(stderr, "%d ", BM_elem_index_get(e));
-		}
-		fprintf(stderr, "\n");
-
-		fprintf(stderr, "    l: ");
-		BM_ITER_ELEM(l, &siter, f, BM_LOOPS_OF_FACE) {
-			fprintf(stderr, "%d(v=%d, e=%d) ",
-			        BM_elem_index_get(l),
-			        BM_elem_index_get(l->v),
-			        BM_elem_index_get(l->e));
-		}
-		fprintf(stderr, "\n");
-	}	
-}
-
-void pbvh_bmesh_print(PBVH *bvh)
-{
-	GHashIterator gh_iter;
 	GSetIterator gs_iter;
 	int n;
+	BMIter iter;
+	BMFace *f;
+	BMVert *v;
 
 	fprintf(stderr, "\npbvh=%p\n", bvh);
 	fprintf(stderr, "bm_face_to_node:\n");
-	GHASH_ITER (gh_iter, bvh->bm_face_to_node) {
+
+	BM_ITER_MESH(f, &iter, bvh->bm, BM_FACES_OF_MESH) {
 		fprintf(stderr, "  %d -> %d\n",
-		        BM_elem_index_get((BMFace *)BLI_ghashIterator_getKey(&gh_iter)),
-		        GET_INT_FROM_POINTER(BLI_ghashIterator_getValue(&gh_iter)));
+		        BM_elem_index_get(v),
+		        pbvh_bmesh_node_lookup_index(bvh, f));
 	}
 
 	fprintf(stderr, "bm_vert_to_node:\n");
-	GHASH_ITER (gh_iter, bvh->bm_vert_to_node) {
+	BM_ITER_MESH(v, &iter, bvh->bm, BM_FACES_OF_MESH) {
 		fprintf(stderr, "  %d -> %d\n",
-		        BM_elem_index_get((BMVert *)BLI_ghashIterator_getKey(&gh_iter)),
-		        GET_INT_FROM_POINTER(BLI_ghashIterator_getValue(&gh_iter)));
+		        BM_elem_index_get(v),
+		        pbvh_bmesh_node_lookup_index(bvh, v));
 	}
 
 	for (n = 0; n < bvh->totnode; n++) {
@@ -1524,9 +1459,9 @@ void pbvh_bmesh_print(PBVH *bvh)
 			continue;
 
 		fprintf(stderr, "node %d\n  faces:\n", n);
-		GHASH_ITER (gh_iter, node->bm_faces)
+		GSET_ITER (gs_iter, node->bm_faces)
 			fprintf(stderr, "    %d\n",
-			        BM_elem_index_get((BMFace *)BLI_ghashIterator_getKey(&gh_iter)));
+			        BM_elem_index_get((BMFace *)BLI_gsetIterator_getKey(&gs_iter)));
 		fprintf(stderr, "  unique verts:\n");
 		GSET_ITER (gs_iter, node->bm_unique_verts)
 			fprintf(stderr, "    %d\n",
@@ -1538,7 +1473,7 @@ void pbvh_bmesh_print(PBVH *bvh)
 	}
 }
 
-void print_flag_factors(int flag)
+static void print_flag_factors(int flag)
 {
 	int i;
 	printf("flag=0x%x:\n", flag);
@@ -1548,24 +1483,53 @@ void print_flag_factors(int flag)
 		}
 	}
 }
+#endif
+
+
+#ifdef USE_VERIFY
 
-void pbvh_bmesh_verify(PBVH *bvh)
+static void pbvh_bmesh_verify(PBVH *bvh)
 {
-	GHashIterator gh_iter;
 	GSetIterator gs_iter;
-	int i, vert_count = 0;
+	int i;
 	BMIter iter;
-	BMVert *vi;
+	BMFace *f;
+	BMVert *v;
+
+	GSet *faces_all;
+	GSet *verts_all;
+
+
+	/* build list of faces & verts to lookup */
+	faces_all = BLI_gset_ptr_new_ex(__func__, bvh->bm->totface);
+	verts_all = BLI_gset_ptr_new_ex(__func__, bvh->bm->totvert);
+
+	BM_ITER_MESH(f, &iter, bvh->bm, BM_FACES_OF_MESH) {
+		BLI_gset_insert(faces_all, f);
+	}
+	BM_ITER_MESH(v, &iter, bvh->bm, BM_VERTS_OF_MESH) {
+		if (BM_ELEM_CD_GET_INT(v, bvh->cd_vert_node_offset) != DYNTOPO_NODE_NONE) {
+			BLI_gset_insert(verts_all, v);
+		}
+	}
+
+	/* Check vert/face counts */
+	{
+		int totface = 0, totvert = 0;
+		for (i = 0; i < bvh->totnode; i++) {
+			PBVHNode *n = &bvh->nodes[i];
+			totface += n->bm_faces ? BLI_gset_size(n->bm_faces) : 0;
+			totvert += n->bm_unique_verts ? BLI_gset_size(n->bm_unique_verts) : 0;
+		}
+
+		BLI_assert(totface == BLI_gset_size(faces_all));
+		BLI_assert(totvert == BLI_gset_size(verts_all));
+	}
 
-	/* Check faces */
-	BLI_assert(bvh->bm->totface == BLI_ghash_size(bvh->bm_face_to_node));
-	GHASH_ITER (gh_iter, bvh->bm_face_to_node) {
+	BM_ITER_MESH(f, &iter, bvh->bm, BM_FACES_OF_MESH) {
 		BMIter bm_iter;
 		BMVert *v;
-		BMFace *f = BLI_ghashIterator_getKey(&gh_iter);
-		void *nip = BLI_ghashIterator_getValue(&gh_iter);
-		int ni = GET_INT_FROM_POINTER(nip);
-		PBVHNode *n = &bvh->nodes[ni];
+		PBVHNode *n = pbvh_bmesh_node_lookup(bvh, f);
 
 		/* Check that the face's node is a leaf */
 		BLI_assert(n->flag & PBVH_Leaf);
@@ -1582,7 +1546,7 @@ void pbvh_bmesh_verify(PBVH *bvh)
 			           BLI_gset_haskey(n->bm_other_verts, v));
 
 			/* Check that the vertex has a node owner */
-			nv = pbvh_bmesh_node_lookup(bvh, bvh->bm_vert_to_node, v);
+			nv = pbvh_bmesh_node_lookup(bvh, v);
 
 			/* Check that the vertex's node knows it owns the vert */
 			BLI_assert(BLI_gset_haskey(nv->bm_unique_verts, v));
@@ -1593,16 +1557,18 @@ void pbvh_bmesh_verify(PBVH *bvh)
 	}
 
 	/* Check verts */
-	BLI_assert(bvh->bm->totvert == BLI_ghash_size(bvh->bm_vert_to_node));
-	GHASH_ITER (gh_iter, bvh->bm_vert_to_node) {
+	BM_ITER_MESH(v, &iter, bvh->bm, BM_VERTS_OF_MESH) {
 		BMIter bm_iter;
-		BMVert *v = BLI_ghashIterator_getKey(&gh_iter);
-		BMFace *f;
-		void *nip = BLI_ghashIterator_getValue(&gh_iter);
-		int ni = GET_INT_FROM_POINTER(nip);
-		PBVHNode *n = &bvh->nodes[ni];
+		PBVHNode *n;
 		bool found;
 
+		/* vertex isn't tracked */
+		if (BM_ELEM_CD_GET_INT(v, bvh->cd_vert_node_offset) == DYNTOPO_NODE_NONE) {
+			continue;
+		}
+
+		n = pbvh_bmesh_node_lookup(bvh, v);
+
 		/* Check that the vert's node is a leaf */
 		BLI_assert(n->flag & PBVH_Leaf);
 
@@ -1615,7 +1581,7 @@ void pbvh_bmesh_verify(PBVH *bvh)
 		/* Check that the vert's node also contains one of the vert's
 		 * adjacent faces */
 		BM_ITER_ELEM (f, &bm_iter, v, BM_FACES_OF_VERT) {
-			if (BLI_ghash_lookup(bvh->bm_face_to_node, f) == nip) {
+			if (pbvh_bmesh_node_lookup(bvh, f) == n) {
 				found = true;
 				break;
 			}
@@ -1626,9 +1592,10 @@ void pbvh_bmesh_verify(PBVH *bvh)
 		/* total freak stuff, check if node exists somewhere else */
 		/* Slow */
 		for (i = 0; i < bvh->totnode; i++) {
-			PBVHNode *n = &bvh->nodes[i];
-			if (i != ni && n->bm_unique_verts)
-				BLI_assert(!BLI_gset_haskey(n->bm_unique_verts, v));
+			PBVHNode *n_other = &bvh->nodes[i];
+			if ((n != n_other) && (n_other->bm_unique_verts)) {
+				BLI_assert(!BLI_gset_haskey(n_other->bm_unique_verts, v));
+			}
 		}
 
 #endif
@@ -1656,36 +1623,32 @@ void pbvh_bmesh_verify(PBVH *bvh)
 	for (i = 0; i < bvh->totnode; i++) {
 		PBVHNode *n = &bvh->nodes[i];
 		if (n->flag & PBVH_Leaf) {
-			/* Check for duplicate entries */
-			/* Slow */
-#if 0
-			bli_gset_duplicate_key_check(n->bm_faces);
-			bli_gset_duplicate_key_check(n->bm_unique_verts);
-			bli_gset_duplicate_key_check(n->bm_other_verts);
-#endif
 
-			GHASH_ITER (gh_iter, n->bm_faces) {
-				BMFace *f = BLI_ghashIterator_getKey(&gh_iter);
-				void *nip = BLI_ghash_lookup(bvh->bm_face_to_node, f);
-				BLI_assert(BLI_ghash_haskey(bvh->bm_face_to_node, f));
-				BLI_assert(GET_INT_FROM_POINTER(nip) == (n - bvh->nodes));
+			GSET_ITER (gs_iter, n->bm_faces) {
+				BMFace *f = BLI_gsetIterator_getKey(&gs_iter);
+				PBVHNode *n_other = pbvh_bmesh_node_lookup(bvh, f);
+				BLI_assert(n == n_other);
+				BLI_assert(BLI_gset_haskey(faces_all, f));
 			}
 
 			GSET_ITER (gs_iter, n->bm_unique_verts) {
 				BMVert *v = BLI_gsetIterator_getKey(&gs_iter);
-				void *nip = BLI_ghash_lookup(bvh->bm_vert_to_node, v);
-				BLI_assert(BLI_ghash_haskey(bvh->bm_vert_to_node, v));
+				PBVHNode *n_other = pbvh_bmesh_node_lookup(bvh, v);
 				BLI_assert(!BLI_gset_haskey(n->bm_other_verts, v));
-				BLI_assert(GET_INT_FROM_POINTER(nip) == (n - bvh->nodes));
+				BLI_assert(n == n_other);
+				BLI_assert(BLI_gset_haskey(verts_all, v));
 			}
 
 			GSET_ITER (gs_iter, n->bm_other_verts) {
 				BMVert *v = BLI_gsetIterator_getKey(&gs_iter);
-				BLI_assert(BLI_ghash_haskey(bvh->bm_vert_to_node, v));
 				BLI_assert(BM_vert_face_count(v) > 0);
+				BLI_assert(BLI_gset_haskey(verts_all, v));
 			}
 		}
 	}
+
+	BLI_gset_free(faces_all, NULL);
+	BLI_gset_free(verts_all, NULL);
 }
 
 #endif