BMesh: add BM_face_share_vert_check/count
[blender.git] / source / blender / bmesh / intern / bmesh_queries.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributor(s): Joseph Eagar, Geoffrey Bantle, Campbell Barton
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/bmesh/intern/bmesh_queries.c
24  *  \ingroup bmesh
25  *
26  * This file contains functions for answering common
27  * Topological and geometric queries about a mesh, such
28  * as, "What is the angle between these two faces?" or,
29  * "How many faces are incident upon this vertex?" Tool
30  * authors should use the functions in this file instead
31  * of inspecting the mesh structure directly.
32  */
33
34 #include "MEM_guardedalloc.h"
35
36 #include "BLI_math.h"
37 #include "BLI_alloca.h"
38 #include "BLI_linklist.h"
39 #include "BLI_stackdefines.h"
40
41 #include "BKE_customdata.h"
42
43 #include "bmesh.h"
44 #include "intern/bmesh_private.h"
45
46 /**
47  * \brief Other Loop in Face Sharing an Edge
48  *
49  * Finds the other loop that shares \a v with \a e loop in \a f.
50  * <pre>
51  *     +----------+
52  *     |          |
53  *     |    f     |
54  *     |          |
55  *     +----------+ <-- return the face loop of this vertex.
56  *     v --> e
57  *     ^     ^ <------- These vert args define direction
58  *                      in the face to check.
59  *                      The faces loop direction is ignored.
60  * </pre>
61  *
62  * \note caller must ensure \a e is used in \a f
63  */
64 BMLoop *BM_face_other_edge_loop(BMFace *f, BMEdge *e, BMVert *v)
65 {
66         BMLoop *l = BM_face_edge_share_loop(f, e);
67         BLI_assert(l != NULL);
68         return BM_loop_other_edge_loop(l, v);
69 }
70
71 /**
72  * See #BM_face_other_edge_loop This is the same functionality
73  * to be used when the edges loop is already known.
74  */
75 BMLoop *BM_loop_other_edge_loop(BMLoop *l, BMVert *v)
76 {
77         BLI_assert(BM_vert_in_edge(l->e, v));
78         return l->v == v ? l->prev : l->next;
79 }
80
81 /**
82  * \brief Other Loop in Face Sharing a Vertex
83  *
84  * Finds the other loop in a face.
85  *
86  * This function returns a loop in \a f that shares an edge with \a v
87  * The direction is defined by \a v_prev, where the return value is
88  * the loop of what would be 'v_next'
89  * <pre>
90  *     +----------+ <-- return the face loop of this vertex.
91  *     |          |
92  *     |    f     |
93  *     |          |
94  *     +----------+
95  *     v_prev --> v
96  *     ^^^^^^     ^ <-- These vert args define direction
97  *                      in the face to check.
98  *                      The faces loop direction is ignored.
99  * </pre>
100  *
101  * \note \a v_prev and \a v _implicitly_ define an edge.
102  */
103 BMLoop *BM_face_other_vert_loop(BMFace *f, BMVert *v_prev, BMVert *v)
104 {
105         BMIter liter;
106         BMLoop *l_iter;
107
108         BLI_assert(BM_edge_exists(v_prev, v) != NULL);
109
110         BM_ITER_ELEM (l_iter, &liter, v, BM_LOOPS_OF_VERT) {
111                 if (l_iter->f == f) {
112                         break;
113                 }
114         }
115
116         if (l_iter) {
117                 if (l_iter->prev->v == v_prev) {
118                         return l_iter->next;
119                 }
120                 else if (l_iter->next->v == v_prev) {
121                         return l_iter->prev;
122                 }
123                 else {
124                         /* invalid args */
125                         BLI_assert(0);
126                         return NULL;
127                 }
128         }
129         else {
130                 /* invalid args */
131                 BLI_assert(0);
132                 return NULL;
133         }
134 }
135
136 /**
137  * \brief Other Loop in Face Sharing a Vert
138  *
139  * Finds the other loop that shares \a v with \a e loop in \a f.
140  * <pre>
141  *     +----------+ <-- return the face loop of this vertex.
142  *     |          |
143  *     |          |
144  *     |          |
145  *     +----------+ <-- This vertex defines the direction.
146  *           l    v
147  *           ^ <------- This loop defines both the face to search
148  *                      and the edge, in combination with 'v'
149  *                      The faces loop direction is ignored.
150  * </pre>
151  */
152
153 BMLoop *BM_loop_other_vert_loop(BMLoop *l, BMVert *v)
154 {
155 #if 0 /* works but slow */
156         return BM_face_other_vert_loop(l->f, BM_edge_other_vert(l->e, v), v);
157 #else
158         BMEdge *e = l->e;
159         BMVert *v_prev = BM_edge_other_vert(e, v);
160         if (l->v == v) {
161                 if (l->prev->v == v_prev) {
162                         return l->next;
163                 }
164                 else {
165                         BLI_assert(l->next->v == v_prev);
166
167                         return l->prev;
168                 }
169         }
170         else {
171                 BLI_assert(l->v == v_prev);
172
173                 if (l->prev->v == v) {
174                         return l->prev->prev;
175                 }
176                 else {
177                         BLI_assert(l->next->v == v);
178                         return l->next->next;
179                 }
180         }
181
182
183
184 #endif
185 }
186
187 /**
188  * Check if verts share a face.
189  */
190 bool BM_vert_pair_share_face_check(
191         BMVert *v_a, BMVert *v_b)
192 {
193         if (v_a->e && v_b->e) {
194                 BMIter iter;
195                 BMFace *f;
196
197                 BM_ITER_ELEM (f, &iter, v_a, BM_FACES_OF_VERT) {
198                         if (BM_vert_in_face(v_b, f)) {
199                                 return true;
200                         }
201                 }
202         }
203
204         return false;
205 }
206
207 bool BM_vert_pair_share_face_check_cb(
208         BMVert *v_a, BMVert *v_b,
209         bool (*test_fn)(BMFace *, void *user_data), void *user_data)
210 {
211         if (v_a->e && v_b->e) {
212                 BMIter iter;
213                 BMFace *f;
214
215                 BM_ITER_ELEM (f, &iter, v_a, BM_FACES_OF_VERT) {
216                         if (test_fn(f, user_data)) {
217                                 if (BM_vert_in_face(v_b, f)) {
218                                         return true;
219                                 }
220                         }
221                 }
222         }
223
224         return false;
225 }
226
227 /**
228  * Given 2 verts, find the smallest face they share and give back both loops.
229  */
230 BMFace *BM_vert_pair_share_face_by_len(
231         BMVert *v_a, BMVert *v_b,
232         BMLoop **r_l_a, BMLoop **r_l_b,
233         const bool allow_adjacent)
234 {
235         BMLoop *l_cur_a = NULL, *l_cur_b = NULL;
236         BMFace *f_cur = NULL;
237
238         if (v_a->e && v_b->e) {
239                 BMIter iter;
240                 BMLoop *l_a, *l_b;
241
242                 BM_ITER_ELEM (l_a, &iter, v_a, BM_LOOPS_OF_VERT) {
243                         if ((f_cur == NULL) || (l_a->f->len < f_cur->len)) {
244                                 l_b = BM_face_vert_share_loop(l_a->f, v_b);
245                                 if (l_b && (allow_adjacent || !BM_loop_is_adjacent(l_a, l_b))) {
246                                         f_cur = l_a->f;
247                                         l_cur_a = l_a;
248                                         l_cur_b = l_b;
249                                 }
250                         }
251                 }
252         }
253
254         *r_l_a = l_cur_a;
255         *r_l_b = l_cur_b;
256
257         return f_cur;
258 }
259
260 BMFace *BM_edge_pair_share_face_by_len(
261         BMEdge *e_a, BMEdge *e_b,
262         BMLoop **r_l_a, BMLoop **r_l_b,
263         const bool allow_adjacent)
264 {
265         BMLoop *l_cur_a = NULL, *l_cur_b = NULL;
266         BMFace *f_cur = NULL;
267
268         if (e_a->l && e_b->l) {
269                 BMIter iter;
270                 BMLoop *l_a, *l_b;
271
272                 BM_ITER_ELEM (l_a, &iter, e_a, BM_LOOPS_OF_EDGE) {
273                         if ((f_cur == NULL) || (l_a->f->len < f_cur->len)) {
274                                 l_b = BM_face_edge_share_loop(l_a->f, e_b);
275                                 if (l_b && (allow_adjacent || !BM_loop_is_adjacent(l_a, l_b))) {
276                                         f_cur = l_a->f;
277                                         l_cur_a = l_a;
278                                         l_cur_b = l_b;
279                                 }
280                         }
281                 }
282         }
283
284         *r_l_a = l_cur_a;
285         *r_l_b = l_cur_b;
286
287         return f_cur;
288 }
289
290 static float bm_face_calc_split_dot(BMLoop *l_a, BMLoop *l_b)
291 {
292         float no[2][3];
293
294         if ((BM_face_calc_normal_subset(l_a, l_b, no[0]) != 0.0f) &&
295             (BM_face_calc_normal_subset(l_b, l_a, no[1]) != 0.0f))
296         {
297                 return dot_v3v3(no[0], no[1]);
298         }
299         else {
300                 return -1.0f;
301         }
302 }
303
304 /**
305  * Check if a point is inside the corner defined by a loop
306  * (within the 2 planes defined by the loops corner & face normal).
307  *
308  * \return signed, squared distance to the loops planes, less than 0.0 when outside.
309  */
310 float BM_loop_point_side_of_loop_test(const BMLoop *l, const float co[3])
311 {
312         const float *axis = l->f->no;
313         return dist_signed_squared_to_corner_v3v3v3(co, l->prev->v->co, l->v->co, l->next->v->co, axis);
314 }
315
316 /**
317  * Check if a point is inside the edge defined by a loop
318  * (within the plane defined by the loops edge & face normal).
319  *
320  * \return signed, squared distance to the edge plane, less than 0.0 when outside.
321  */
322 float BM_loop_point_side_of_edge_test(const BMLoop *l, const float co[3])
323 {
324         const float *axis = l->f->no;
325         float dir[3];
326         float plane[4];
327
328         sub_v3_v3v3(dir, l->next->v->co, l->v->co);
329         cross_v3_v3v3(plane, axis, dir);
330
331         plane[3] = -dot_v3v3(plane, l->v->co);
332         return dist_signed_squared_to_plane_v3(co, plane);
333 }
334
335 /**
336  * Given 2 verts, find a face they share that has the lowest angle across these verts and give back both loops.
337  *
338  * This can be better then #BM_vert_pair_share_face_by_len because concave splits are ranked lowest.
339  */
340 BMFace *BM_vert_pair_share_face_by_angle(
341         BMVert *v_a, BMVert *v_b,
342         BMLoop **r_l_a, BMLoop **r_l_b,
343         const bool allow_adjacent)
344 {
345         BMLoop *l_cur_a = NULL, *l_cur_b = NULL;
346         BMFace *f_cur = NULL;
347
348         if (v_a->e && v_b->e) {
349                 BMIter iter;
350                 BMLoop *l_a, *l_b;
351                 float dot_best = -1.0f;
352
353                 BM_ITER_ELEM (l_a, &iter, v_a, BM_LOOPS_OF_VERT) {
354                         l_b = BM_face_vert_share_loop(l_a->f, v_b);
355                         if (l_b && (allow_adjacent || !BM_loop_is_adjacent(l_a, l_b))) {
356
357                                 if (f_cur == NULL) {
358                                         f_cur = l_a->f;
359                                         l_cur_a = l_a;
360                                         l_cur_b = l_b;
361                                 }
362                                 else {
363                                         /* avoid expensive calculations if we only ever find one face */
364                                         float dot;
365                                         if (dot_best == -1.0f) {
366                                                 dot_best = bm_face_calc_split_dot(l_cur_a, l_cur_b);
367                                         }
368
369                                         dot = bm_face_calc_split_dot(l_a, l_b);
370                                         if (dot > dot_best) {
371                                                 dot_best = dot;
372
373                                                 f_cur = l_a->f;
374                                                 l_cur_a = l_a;
375                                                 l_cur_b = l_b;
376                                         }
377                                 }
378                         }
379                 }
380         }
381
382         *r_l_a = l_cur_a;
383         *r_l_b = l_cur_b;
384
385         return f_cur;
386 }
387
388
389 /**
390  * Get the first loop of a vert. Uses the same initialization code for the first loop of the
391  * iterator API
392  */
393 BMLoop *BM_vert_find_first_loop(BMVert *v)
394 {
395         BMEdge *e;
396
397         if (!v->e)
398                 return NULL;
399
400         e = bmesh_disk_faceedge_find_first(v->e, v);
401
402         if (!e)
403                 return NULL;
404
405         return bmesh_radial_faceloop_find_first(e->l, v);
406 }
407
408 /**
409  * Returns true if the vertex is used in a given face.
410  */
411 bool BM_vert_in_face(BMVert *v, BMFace *f)
412 {
413         BMLoop *l_iter, *l_first;
414
415 #ifdef USE_BMESH_HOLES
416         BMLoopList *lst;
417         for (lst = f->loops.first; lst; lst = lst->next)
418 #endif
419         {
420 #ifdef USE_BMESH_HOLES
421                 l_iter = l_first = lst->first;
422 #else
423                 l_iter = l_first = f->l_first;
424 #endif
425                 do {
426                         if (l_iter->v == v) {
427                                 return true;
428                         }
429                 } while ((l_iter = l_iter->next) != l_first);
430         }
431
432         return false;
433 }
434
435 /**
436  * Compares the number of vertices in an array
437  * that appear in a given face
438  */
439 int BM_verts_in_face_count(BMVert **varr, int len, BMFace *f)
440 {
441         BMLoop *l_iter, *l_first;
442
443 #ifdef USE_BMESH_HOLES
444         BMLoopList *lst;
445 #endif
446
447         int i, count = 0;
448         
449         for (i = 0; i < len; i++) {
450                 BM_ELEM_API_FLAG_ENABLE(varr[i], _FLAG_OVERLAP);
451         }
452
453 #ifdef USE_BMESH_HOLES
454         for (lst = f->loops.first; lst; lst = lst->next)
455 #endif
456         {
457
458 #ifdef USE_BMESH_HOLES
459                 l_iter = l_first = lst->first;
460 #else
461                 l_iter = l_first = f->l_first;
462 #endif
463
464                 do {
465                         if (BM_ELEM_API_FLAG_TEST(l_iter->v, _FLAG_OVERLAP)) {
466                                 count++;
467                         }
468
469                 } while ((l_iter = l_iter->next) != l_first);
470         }
471
472         for (i = 0; i < len; i++) {
473                 BM_ELEM_API_FLAG_DISABLE(varr[i], _FLAG_OVERLAP);
474         }
475
476         return count;
477 }
478
479
480 /**
481  * Return true if all verts are in the face.
482  */
483 bool BM_verts_in_face(BMVert **varr, int len, BMFace *f)
484 {
485         BMLoop *l_iter, *l_first;
486
487 #ifdef USE_BMESH_HOLES
488         BMLoopList *lst;
489 #endif
490
491         int i;
492         bool ok = true;
493
494         /* simple check, we know can't succeed */
495         if (f->len < len) {
496                 return false;
497         }
498
499         for (i = 0; i < len; i++) {
500                 BM_ELEM_API_FLAG_ENABLE(varr[i], _FLAG_OVERLAP);
501         }
502
503 #ifdef USE_BMESH_HOLES
504         for (lst = f->loops.first; lst; lst = lst->next)
505 #endif
506         {
507
508 #ifdef USE_BMESH_HOLES
509                 l_iter = l_first = lst->first;
510 #else
511                 l_iter = l_first = f->l_first;
512 #endif
513
514                 do {
515                         if (BM_ELEM_API_FLAG_TEST(l_iter->v, _FLAG_OVERLAP)) {
516                                 /* pass */
517                         }
518                         else {
519                                 ok = false;
520                                 break;
521                         }
522
523                 } while ((l_iter = l_iter->next) != l_first);
524         }
525
526         for (i = 0; i < len; i++) {
527                 BM_ELEM_API_FLAG_DISABLE(varr[i], _FLAG_OVERLAP);
528         }
529
530         return ok;
531 }
532
533 /**
534  * Returns whether or not a given edge is part of a given face.
535  */
536 bool BM_edge_in_face(const BMEdge *e, const BMFace *f)
537 {
538         if (e->l) {
539                 const BMLoop *l_iter, *l_first;
540
541                 l_iter = l_first = e->l;
542                 do {
543                         if (l_iter->f == f) {
544                                 return true;
545                         }
546                 } while ((l_iter = l_iter->radial_next) != l_first);
547         }
548
549         return false;
550 }
551
552 /**
553  * Given a edge and a loop (assumes the edge is manifold). returns
554  * the other faces loop, sharing the same vertex.
555  *
556  * <pre>
557  * +-------------------+
558  * |                   |
559  * |                   |
560  * |l_other <-- return |
561  * +-------------------+ <-- A manifold edge between 2 faces
562  * |l    e  <-- edge   |
563  * |^ <-------- loop   |
564  * |                   |
565  * +-------------------+
566  * </pre>
567  */
568 BMLoop *BM_edge_other_loop(BMEdge *e, BMLoop *l)
569 {
570         BMLoop *l_other;
571
572         // BLI_assert(BM_edge_is_manifold(e));  // TOO strict, just check if we have another radial face
573         BLI_assert(e->l && e->l->radial_next != e->l);
574         BLI_assert(BM_vert_in_edge(e, l->v));
575
576         l_other = (l->e == e) ? l : l->prev;
577         l_other = l_other->radial_next;
578         BLI_assert(l_other->e == e);
579
580         if (l_other->v == l->v) {
581                 /* pass */
582         }
583         else if (l_other->next->v == l->v) {
584                 l_other = l_other->next;
585         }
586         else {
587                 BLI_assert(0);
588         }
589
590         return l_other;
591 }
592
593 /**
594  * Utility function to step around a fan of loops,
595  * using an edge to mark the previous side.
596  *
597  * \note all edges must be manifold,
598  * once a non manifold edge is hit, return NULL.
599  *
600  * <pre>
601  *                ,.,-->|
602  *            _,-'      |
603  *          ,'          | (notice how 'e_step'
604  *         /            |  and 'l' define the
605  *        /             |  direction the arrow
606  *       |     return   |  points).
607  *       |     loop --> |
608  * ---------------------+---------------------
609  *         ^      l --> |
610  *         |            |
611  *  assign e_step       |
612  *                      |
613  *   begin e_step ----> |
614  *                      |
615  * </pre>
616  */
617
618 BMLoop *BM_vert_step_fan_loop(BMLoop *l, BMEdge **e_step)
619 {
620         BMEdge *e_prev = *e_step;
621         BMEdge *e_next;
622         if (l->e == e_prev) {
623                 e_next = l->prev->e;
624         }
625         else if (l->prev->e == e_prev) {
626                 e_next = l->e;
627         }
628         else {
629                 BLI_assert(0);
630                 return NULL;
631         }
632
633         if (BM_edge_is_manifold(e_next)) {
634                 return BM_edge_other_loop((*e_step = e_next), l);
635         }
636         else {
637                 return NULL;
638         }
639 }
640
641
642
643 /**
644  * The function takes a vertex at the center of a fan and returns the opposite edge in the fan.
645  * All edges in the fan must be manifold, otherwise return NULL.
646  *
647  * \note This could (probably) be done more efficiently.
648  */
649 BMEdge *BM_vert_other_disk_edge(BMVert *v, BMEdge *e_first)
650 {
651         BMLoop *l_a;
652         int tot = 0;
653         int i;
654
655         BLI_assert(BM_vert_in_edge(e_first, v));
656
657         l_a = e_first->l;
658         do {
659                 l_a = BM_loop_other_vert_loop(l_a, v);
660                 l_a = BM_vert_in_edge(l_a->e, v) ? l_a : l_a->prev;
661                 if (BM_edge_is_manifold(l_a->e)) {
662                         l_a = l_a->radial_next;
663                 }
664                 else {
665                         return NULL;
666                 }
667
668                 tot++;
669         } while (l_a != e_first->l);
670
671         /* we know the total, now loop half way */
672         tot /= 2;
673         i = 0;
674
675         l_a = e_first->l;
676         do {
677                 if (i == tot) {
678                         l_a = BM_vert_in_edge(l_a->e, v) ? l_a : l_a->prev;
679                         return l_a->e;
680                 }
681
682                 l_a = BM_loop_other_vert_loop(l_a, v);
683                 l_a = BM_vert_in_edge(l_a->e, v) ? l_a : l_a->prev;
684                 if (BM_edge_is_manifold(l_a->e)) {
685                         l_a = l_a->radial_next;
686                 }
687                 /* this wont have changed from the previous loop */
688
689
690                 i++;
691         } while (l_a != e_first->l);
692
693         return NULL;
694 }
695
696 /**
697  * Returns edge length
698  */
699 float BM_edge_calc_length(const BMEdge *e)
700 {
701         return len_v3v3(e->v1->co, e->v2->co);
702 }
703
704 /**
705  * Returns edge length squared (for comparisons)
706  */
707 float BM_edge_calc_length_squared(const BMEdge *e)
708 {
709         return len_squared_v3v3(e->v1->co, e->v2->co);
710 }
711
712 /**
713  * Utility function, since enough times we have an edge
714  * and want to access 2 connected faces.
715  *
716  * \return true when only 2 faces are found.
717  */
718 bool BM_edge_face_pair(BMEdge *e, BMFace **r_fa, BMFace **r_fb)
719 {
720         BMLoop *la, *lb;
721
722         if ((la = e->l) &&
723             (lb = la->radial_next) &&
724             (la != lb) &&
725             (lb->radial_next == la))
726         {
727                 *r_fa = la->f;
728                 *r_fb = lb->f;
729                 return true;
730         }
731         else {
732                 *r_fa = NULL;
733                 *r_fb = NULL;
734                 return false;
735         }
736 }
737
738 /**
739  * Utility function, since enough times we have an edge
740  * and want to access 2 connected loops.
741  *
742  * \return true when only 2 faces are found.
743  */
744 bool BM_edge_loop_pair(BMEdge *e, BMLoop **r_la, BMLoop **r_lb)
745 {
746         BMLoop *la, *lb;
747
748         if ((la = e->l) &&
749             (lb = la->radial_next) &&
750             (la != lb) &&
751             (lb->radial_next == la))
752         {
753                 *r_la = la;
754                 *r_lb = lb;
755                 return true;
756         }
757         else {
758                 *r_la = NULL;
759                 *r_lb = NULL;
760                 return false;
761         }
762 }
763
764 /**
765  * Fast alternative to ``(BM_vert_edge_count(v) == 2)``
766  */
767 bool BM_vert_is_edge_pair(const BMVert *v)
768 {
769         const BMEdge *e = v->e;
770         if (e) {
771                 const BMDiskLink *dl = bmesh_disk_edge_link_from_vert(e, v);
772                 return (dl->next == dl->prev);
773         }
774         return false;
775 }
776
777 /**
778  *      Returns the number of edges around this vertex.
779  */
780 int BM_vert_edge_count(const BMVert *v)
781 {
782         return bmesh_disk_count(v);
783 }
784
785 int BM_vert_edge_count_ex(const BMVert *v, const int count_max)
786 {
787         return bmesh_disk_count_ex(v, count_max);
788 }
789
790 int BM_vert_edge_count_nonwire(const BMVert *v)
791 {
792         int count = 0;
793         BMIter eiter;
794         BMEdge *edge;
795         BM_ITER_ELEM (edge, &eiter, (BMVert *)v, BM_EDGES_OF_VERT) {
796                 if (edge->l) {
797                         count++;
798                 }
799         }
800         return count;
801 }
802 /**
803  *      Returns the number of faces around this edge
804  */
805 int BM_edge_face_count(const BMEdge *e)
806 {
807         int count = 0;
808
809         if (e->l) {
810                 BMLoop *l_iter, *l_first;
811
812                 l_iter = l_first = e->l;
813                 do {
814                         count++;
815                 } while ((l_iter = l_iter->radial_next) != l_first);
816         }
817
818         return count;
819 }
820
821 int BM_edge_face_count_ex(const BMEdge *e, const int count_max)
822 {
823         int count = 0;
824
825         if (e->l) {
826                 BMLoop *l_iter, *l_first;
827
828                 l_iter = l_first = e->l;
829                 do {
830                         count++;
831                         if (count == count_max) {
832                                 break;
833                         }
834                 } while ((l_iter = l_iter->radial_next) != l_first);
835         }
836
837         return count;
838 }
839
840 /**
841  * Returns the number of faces around this vert
842  * length matches #BM_LOOPS_OF_VERT iterator
843  */
844 int BM_vert_face_count(const BMVert *v)
845 {
846         return bmesh_disk_facevert_count(v);
847 }
848
849 int BM_vert_face_count_ex(const BMVert *v, int count_max)
850 {
851         return bmesh_disk_facevert_count_ex(v, count_max);
852 }
853
854 /**
855  * Return true if the vertex is connected to _any_ faces.
856  *
857  * same as ``BM_vert_face_count(v) != 0`` or ``BM_vert_find_first_loop(v) == NULL``
858  */
859 bool BM_vert_face_check(BMVert *v)
860 {
861         return v->e && (bmesh_disk_faceedge_find_first(v->e, v) != NULL);
862 }
863
864 /**
865  * Tests whether or not the vertex is part of a wire edge.
866  * (ie: has no faces attached to it)
867  */
868 bool BM_vert_is_wire(const BMVert *v)
869 {
870         if (v->e) {
871                 BMEdge *e_first, *e_iter;
872
873                 e_first = e_iter = v->e;
874                 do {
875                         if (e_iter->l) {
876                                 return false;
877                         }
878                 } while ((e_iter = bmesh_disk_edge_next(e_iter, v)) != e_first);
879
880                 return true;
881         }
882         else {
883                 return false;
884         }
885 }
886
887 /**
888  * A vertex is non-manifold if it meets the following conditions:
889  * 1: Loose - (has no edges/faces incident upon it).
890  * 2: Joins two distinct regions - (two pyramids joined at the tip).
891  * 3: Is part of a an edge with more than 2 faces.
892  * 4: Is part of a wire edge.
893  */
894 bool BM_vert_is_manifold(const BMVert *v)
895 {
896         BMEdge *e_iter, *e_first, *e_prev;
897         BMLoop *l_iter, *l_first;
898         int loop_num = 0, loop_num_region = 0, boundary_num = 0;
899
900         if (v->e == NULL) {
901                 /* loose vert */
902                 return false;
903         }
904
905         /* count edges while looking for non-manifold edges */
906         e_first = e_iter = v->e;
907         l_first = e_iter->l ? e_iter->l : NULL;
908         do {
909                 /* loose edge or edge shared by more than two faces,
910                  * edges with 1 face user are OK, otherwise we could
911                  * use BM_edge_is_manifold() here */
912                 if (e_iter->l == NULL || (e_iter->l != e_iter->l->radial_next->radial_next)) {
913                         return false;
914                 }
915
916                 /* count radial loops */
917                 if (e_iter->l->v == v) {
918                         loop_num += 1;
919                 }
920
921                 if (!BM_edge_is_boundary(e_iter)) {
922                         /* non boundary check opposite loop */
923                         if (e_iter->l->radial_next->v == v) {
924                                 loop_num += 1;
925                         }
926                 }
927                 else {
928                         /* start at the boundary */
929                         l_first = e_iter->l;
930                         boundary_num += 1;
931                         /* >2 boundaries cant be manifold */
932                         if (boundary_num == 3) {
933                                 return false;
934                         }
935                 }
936         } while ((e_iter = bmesh_disk_edge_next(e_iter, v)) != e_first);
937
938         e_first = l_first->e;
939         l_first = (l_first->v == v) ? l_first : l_first->next;
940         BLI_assert(l_first->v == v);
941
942         l_iter = l_first;
943         e_prev = e_first;
944
945         do {
946                 loop_num_region += 1;
947         } while (((l_iter = BM_vert_step_fan_loop(l_iter, &e_prev)) != l_first) && (l_iter != NULL));
948
949         return (loop_num == loop_num_region);
950 }
951
952 #define LOOP_VISIT _FLAG_WALK
953 #define EDGE_VISIT _FLAG_WALK
954
955 static int bm_loop_region_count__recursive(BMEdge *e, BMVert *v)
956 {
957         BMLoop *l_iter, *l_first;
958         int count = 0;
959
960         BLI_assert(!BM_ELEM_API_FLAG_TEST(e, EDGE_VISIT));
961         BM_ELEM_API_FLAG_ENABLE(e, EDGE_VISIT);
962
963         l_iter = l_first = e->l;
964         do {
965                 if (l_iter->v == v) {
966                         BMEdge *e_other = l_iter->prev->e;
967                         if (!BM_ELEM_API_FLAG_TEST(l_iter, LOOP_VISIT)) {
968                                 BM_ELEM_API_FLAG_ENABLE(l_iter, LOOP_VISIT);
969                                 count += 1;
970                         }
971                         if (!BM_ELEM_API_FLAG_TEST(e_other, EDGE_VISIT)) {
972                                 count += bm_loop_region_count__recursive(e_other, v);
973                         }
974                 }
975                 else if (l_iter->next->v == v) {
976                         BMEdge *e_other = l_iter->next->e;
977                         if (!BM_ELEM_API_FLAG_TEST(l_iter->next, LOOP_VISIT)) {
978                                 BM_ELEM_API_FLAG_ENABLE(l_iter->next, LOOP_VISIT);
979                                 count += 1;
980                         }
981                         if (!BM_ELEM_API_FLAG_TEST(e_other, EDGE_VISIT)) {
982                                 count += bm_loop_region_count__recursive(e_other, v);
983                         }
984                 }
985                 else {
986                         BLI_assert(0);
987                 }
988         } while ((l_iter = l_iter->radial_next) != l_first);
989
990         return count;
991 }
992
993 static int bm_loop_region_count__clear(BMLoop *l)
994 {
995         int count = 0;
996         BMEdge *e_iter, *e_first;
997
998         /* clear flags */
999         e_iter = e_first = l->e;
1000         do {
1001                 BM_ELEM_API_FLAG_DISABLE(e_iter, EDGE_VISIT);
1002                 if (e_iter->l) {
1003                         BMLoop *l_iter, *l_first;
1004                         l_iter = l_first = e_iter->l;
1005                         do {
1006                                 if (l_iter->v == l->v) {
1007                                         BM_ELEM_API_FLAG_DISABLE(l_iter, LOOP_VISIT);
1008                                         count += 1;
1009                                 }
1010                         } while ((l_iter = l_iter->radial_next) != l_first);
1011                 }
1012         } while ((e_iter = BM_DISK_EDGE_NEXT(e_iter, l->v)) != e_first);
1013
1014         return count;
1015 }
1016
1017 /**
1018  * The number of loops connected to this loop (not including disconnected regions).
1019  */
1020 int BM_loop_region_loops_count_ex(BMLoop *l, int *r_loop_total)
1021 {
1022         const int count       = bm_loop_region_count__recursive(l->e, l->v);
1023         const int count_total = bm_loop_region_count__clear(l);
1024         if (r_loop_total) {
1025                 *r_loop_total = count_total;
1026         }
1027         return count;
1028 }
1029
1030 #undef LOOP_VISIT
1031 #undef EDGE_VISIT
1032
1033 int BM_loop_region_loops_count(BMLoop *l)
1034 {
1035         return BM_loop_region_loops_count_ex(l, NULL);
1036 }
1037
1038 /**
1039  * A version of #BM_vert_is_manifold
1040  * which only checks if we're connected to multiple isolated regions.
1041  */
1042 bool BM_vert_is_manifold_region(const BMVert *v)
1043 {
1044         BMLoop *l_first = BM_vert_find_first_loop((BMVert *)v);
1045         if (l_first) {
1046                 int count, count_total;
1047                 count = BM_loop_region_loops_count_ex(l_first, &count_total);
1048                 return (count == count_total);
1049         }
1050         return true;
1051 }
1052
1053 /**
1054  * Check if the edge is convex or concave
1055  * (depends on face winding)
1056  */
1057 bool BM_edge_is_convex(const BMEdge *e)
1058 {
1059         if (BM_edge_is_manifold(e)) {
1060                 BMLoop *l1 = e->l;
1061                 BMLoop *l2 = e->l->radial_next;
1062                 if (!equals_v3v3(l1->f->no, l2->f->no)) {
1063                         float cross[3];
1064                         float l_dir[3];
1065                         cross_v3_v3v3(cross, l1->f->no, l2->f->no);
1066                         /* we assume contiguous normals, otherwise the result isn't meaningful */
1067                         sub_v3_v3v3(l_dir, l1->next->v->co, l1->v->co);
1068                         return (dot_v3v3(l_dir, cross) > 0.0f);
1069                 }
1070         }
1071         return true;
1072 }
1073
1074 /**
1075  * \return true when loop customdata is contiguous.
1076  */
1077 bool BM_edge_is_contiguous_loop_cd(
1078         const BMEdge *e,
1079         const int cd_loop_type, const int cd_loop_offset)
1080 {
1081         BLI_assert(cd_loop_offset != -1);
1082
1083         if (e->l && e->l->radial_next != e->l) {
1084                 const BMLoop *l_base_v1 = e->l;
1085                 const BMLoop *l_base_v2 = e->l->next;
1086                 const void *l_base_cd_v1 = BM_ELEM_CD_GET_VOID_P(l_base_v1, cd_loop_offset);
1087                 const void *l_base_cd_v2 = BM_ELEM_CD_GET_VOID_P(l_base_v2, cd_loop_offset);
1088                 const BMLoop *l_iter = e->l->radial_next;
1089                 do {
1090                         const BMLoop *l_iter_v1;
1091                         const BMLoop *l_iter_v2;
1092                         const void *l_iter_cd_v1;
1093                         const void *l_iter_cd_v2;
1094
1095                         if (l_iter->v == l_base_v1->v) {
1096                                 l_iter_v1 = l_iter;
1097                                 l_iter_v2 = l_iter->next;
1098                         }
1099                         else {
1100                                 l_iter_v1 = l_iter->next;
1101                                 l_iter_v2 = l_iter;
1102                         }
1103                         BLI_assert((l_iter_v1->v == l_base_v1->v) &&
1104                                    (l_iter_v2->v == l_base_v2->v));
1105
1106                         l_iter_cd_v1 = BM_ELEM_CD_GET_VOID_P(l_iter_v1, cd_loop_offset);
1107                         l_iter_cd_v2 = BM_ELEM_CD_GET_VOID_P(l_iter_v2, cd_loop_offset);
1108
1109
1110                         if ((CustomData_data_equals(cd_loop_type, l_base_cd_v1, l_iter_cd_v1) == 0) ||
1111                             (CustomData_data_equals(cd_loop_type, l_base_cd_v2, l_iter_cd_v2) == 0))
1112                         {
1113                                 return false;
1114                         }
1115
1116                 } while ((l_iter = l_iter->radial_next) != e->l);
1117         }
1118         return true;
1119 }
1120
1121 bool BM_vert_is_boundary(const BMVert *v)
1122 {
1123         if (v->e) {
1124                 BMEdge *e_first, *e_iter;
1125
1126                 e_first = e_iter = v->e;
1127                 do {
1128                         if (BM_edge_is_boundary(e_iter)) {
1129                                 return true;
1130                         }
1131                 } while ((e_iter = bmesh_disk_edge_next(e_iter, v)) != e_first);
1132
1133                 return false;
1134         }
1135         else {
1136                 return false;
1137         }
1138 }
1139
1140 /**
1141  * Returns the number of faces that are adjacent to both f1 and f2,
1142  * \note Could be sped up a bit by not using iterators and by tagging
1143  * faces on either side, then count the tags rather then searching.
1144  */
1145 int BM_face_share_face_count(BMFace *f1, BMFace *f2)
1146 {
1147         BMIter iter1, iter2;
1148         BMEdge *e;
1149         BMFace *f;
1150         int count = 0;
1151
1152         BM_ITER_ELEM (e, &iter1, f1, BM_EDGES_OF_FACE) {
1153                 BM_ITER_ELEM (f, &iter2, e, BM_FACES_OF_EDGE) {
1154                         if (f != f1 && f != f2 && BM_face_share_edge_check(f, f2))
1155                                 count++;
1156                 }
1157         }
1158
1159         return count;
1160 }
1161
1162 /**
1163  * same as #BM_face_share_face_count but returns a bool
1164  */
1165 bool BM_face_share_face_check(BMFace *f1, BMFace *f2)
1166 {
1167         BMIter iter1, iter2;
1168         BMEdge *e;
1169         BMFace *f;
1170
1171         BM_ITER_ELEM (e, &iter1, f1, BM_EDGES_OF_FACE) {
1172                 BM_ITER_ELEM (f, &iter2, e, BM_FACES_OF_EDGE) {
1173                         if (f != f1 && f != f2 && BM_face_share_edge_check(f, f2))
1174                                 return true;
1175                 }
1176         }
1177
1178         return false;
1179 }
1180
1181 /**
1182  *  Counts the number of edges two faces share (if any)
1183  */
1184 int BM_face_share_edge_count(BMFace *f_a, BMFace *f_b)
1185 {
1186         BMLoop *l_iter;
1187         BMLoop *l_first;
1188         int count = 0;
1189         
1190         l_iter = l_first = BM_FACE_FIRST_LOOP(f_a);
1191         do {
1192                 if (BM_edge_in_face(l_iter->e, f_b)) {
1193                         count++;
1194                 }
1195         } while ((l_iter = l_iter->next) != l_first);
1196
1197         return count;
1198 }
1199
1200 /**
1201  *  Returns true if the faces share an edge
1202  */
1203 bool BM_face_share_edge_check(BMFace *f1, BMFace *f2)
1204 {
1205         BMLoop *l_iter;
1206         BMLoop *l_first;
1207
1208         l_iter = l_first = BM_FACE_FIRST_LOOP(f1);
1209         do {
1210                 if (BM_edge_in_face(l_iter->e, f2)) {
1211                         return true;
1212                 }
1213         } while ((l_iter = l_iter->next) != l_first);
1214
1215         return false;
1216 }
1217
1218 /**
1219  *  Counts the number of verts two faces share (if any).
1220  */
1221 int BM_face_share_vert_count(BMFace *f_a, BMFace *f_b)
1222 {
1223         BMLoop *l_iter;
1224         BMLoop *l_first;
1225         int count = 0;
1226
1227         l_iter = l_first = BM_FACE_FIRST_LOOP(f_a);
1228         do {
1229                 if (BM_vert_in_face(l_iter->v, f_b)) {
1230                         count++;
1231                 }
1232         } while ((l_iter = l_iter->next) != l_first);
1233
1234         return count;
1235 }
1236
1237 /**
1238  *  Returns true if the faces share a vert.
1239  */
1240 bool BM_face_share_vert_check(BMFace *f_a, BMFace *f_b)
1241 {
1242         BMLoop *l_iter;
1243         BMLoop *l_first;
1244
1245         l_iter = l_first = BM_FACE_FIRST_LOOP(f_a);
1246         do {
1247                 if (BM_vert_in_face(l_iter->v, f_b)) {
1248                         return true;
1249                 }
1250         } while ((l_iter = l_iter->next) != l_first);
1251
1252         return false;
1253 }
1254
1255 /**
1256  * Test if e1 shares any faces with e2
1257  */
1258 bool BM_edge_share_face_check(BMEdge *e1, BMEdge *e2)
1259 {
1260         BMLoop *l;
1261         BMFace *f;
1262
1263         if (e1->l && e2->l) {
1264                 l = e1->l;
1265                 do {
1266                         f = l->f;
1267                         if (BM_edge_in_face(e2, f)) {
1268                                 return true;
1269                         }
1270                         l = l->radial_next;
1271                 } while (l != e1->l);
1272         }
1273         return false;
1274 }
1275
1276 /**
1277  *      Test if e1 shares any quad faces with e2
1278  */
1279 bool BM_edge_share_quad_check(BMEdge *e1, BMEdge *e2)
1280 {
1281         BMLoop *l;
1282         BMFace *f;
1283
1284         if (e1->l && e2->l) {
1285                 l = e1->l;
1286                 do {
1287                         f = l->f;
1288                         if (f->len == 4) {
1289                                 if (BM_edge_in_face(e2, f)) {
1290                                         return true;
1291                                 }
1292                         }
1293                         l = l->radial_next;
1294                 } while (l != e1->l);
1295         }
1296         return false;
1297 }
1298
1299 /**
1300  *      Tests to see if e1 shares a vertex with e2
1301  */
1302 bool BM_edge_share_vert_check(BMEdge *e1, BMEdge *e2)
1303 {
1304         return (e1->v1 == e2->v1 ||
1305                 e1->v1 == e2->v2 ||
1306                 e1->v2 == e2->v1 ||
1307                 e1->v2 == e2->v2);
1308 }
1309
1310 /**
1311  *      Return the shared vertex between the two edges or NULL
1312  */
1313 BMVert *BM_edge_share_vert(BMEdge *e1, BMEdge *e2)
1314 {
1315         BLI_assert(e1 != e2);
1316         if (BM_vert_in_edge(e2, e1->v1)) {
1317                 return e1->v1;
1318         }
1319         else if (BM_vert_in_edge(e2, e1->v2)) {
1320                 return e1->v2;
1321         }
1322         else {
1323                 return NULL;
1324         }
1325 }
1326
1327 /**
1328  * \brief Return the Loop Shared by Edge and Vert
1329  *
1330  * Finds the loop used which uses \a  in face loop \a l
1331  *
1332  * \note this function takes a loop rather then an edge
1333  * so we can select the face that the loop should be from.
1334  */
1335 BMLoop *BM_edge_vert_share_loop(BMLoop *l, BMVert *v)
1336 {
1337         BLI_assert(BM_vert_in_edge(l->e, v));
1338         if (l->v == v) {
1339                 return l;
1340         }
1341         else {
1342                 return l->next;
1343         }
1344 }
1345
1346 /**
1347  * \brief Return the Loop Shared by Face and Vertex
1348  *
1349  * Finds the loop used which uses \a v in face loop \a l
1350  *
1351  * \note currently this just uses simple loop in future may be sped up
1352  * using radial vars
1353  */
1354 BMLoop *BM_face_vert_share_loop(BMFace *f, BMVert *v)
1355 {
1356         BMLoop *l_first;
1357         BMLoop *l_iter;
1358
1359         l_iter = l_first = BM_FACE_FIRST_LOOP(f);
1360         do {
1361                 if (l_iter->v == v) {
1362                         return l_iter;
1363                 }
1364         } while ((l_iter = l_iter->next) != l_first);
1365
1366         return NULL;
1367 }
1368
1369 /**
1370  * \brief Return the Loop Shared by Face and Edge
1371  *
1372  * Finds the loop used which uses \a e in face loop \a l
1373  *
1374  * \note currently this just uses simple loop in future may be sped up
1375  * using radial vars
1376  */
1377 BMLoop *BM_face_edge_share_loop(BMFace *f, BMEdge *e)
1378 {
1379         BMLoop *l_first;
1380         BMLoop *l_iter;
1381
1382         l_iter = l_first = e->l;
1383         do {
1384                 if (l_iter->f == f) {
1385                         return l_iter;
1386                 }
1387         } while ((l_iter = l_iter->radial_next) != l_first);
1388
1389         return NULL;
1390 }
1391
1392 /**
1393  * Returns the verts of an edge as used in a face
1394  * if used in a face at all, otherwise just assign as used in the edge.
1395  *
1396  * Useful to get a deterministic winding order when calling
1397  * BM_face_create_ngon() on an arbitrary array of verts,
1398  * though be sure to pick an edge which has a face.
1399  *
1400  * \note This is in fact quite a simple check, mainly include this function so the intent is more obvious.
1401  * We know these 2 verts will _always_ make up the loops edge
1402  */
1403 void BM_edge_ordered_verts_ex(
1404         const BMEdge *edge, BMVert **r_v1, BMVert **r_v2,
1405         const BMLoop *edge_loop)
1406 {
1407         BLI_assert(edge_loop->e == edge);
1408         (void)edge; /* quiet warning in release build */
1409         *r_v1 = edge_loop->v;
1410         *r_v2 = edge_loop->next->v;
1411 }
1412
1413 void BM_edge_ordered_verts(const BMEdge *edge, BMVert **r_v1, BMVert **r_v2)
1414 {
1415         BM_edge_ordered_verts_ex(edge, r_v1, r_v2, edge->l);
1416 }
1417
1418 /**
1419  * \return The previous loop, over \a eps_sq distance from \a l (or \a NULL if l_stop is reached).
1420  */
1421 BMLoop *BM_loop_find_prev_nodouble(BMLoop *l, BMLoop *l_stop, const float eps_sq)
1422 {
1423         BMLoop *l_step = l->prev;
1424
1425         BLI_assert(!ELEM(l_stop, NULL, l));
1426
1427         while (UNLIKELY(len_squared_v3v3(l->v->co, l_step->v->co) < eps_sq)) {
1428                 l_step = l_step->prev;
1429                 BLI_assert(l_step != l);
1430                 if (UNLIKELY(l_step == l_stop)) {
1431                         return NULL;
1432                 }
1433         }
1434
1435         return l_step;
1436 }
1437
1438 /**
1439  * \return The next loop, over \a eps_sq distance from \a l (or \a NULL if l_stop is reached).
1440  */
1441 BMLoop *BM_loop_find_next_nodouble(BMLoop *l, BMLoop *l_stop, const float eps_sq)
1442 {
1443         BMLoop *l_step = l->next;
1444
1445         BLI_assert(!ELEM(l_stop, NULL, l));
1446
1447         while (UNLIKELY(len_squared_v3v3(l->v->co, l_step->v->co) < eps_sq)) {
1448                 l_step = l_step->next;
1449                 BLI_assert(l_step != l);
1450                 if (UNLIKELY(l_step == l_stop)) {
1451                         return NULL;
1452                 }
1453         }
1454
1455         return l_step;
1456 }
1457
1458 /**
1459  * Check if the loop is convex or concave
1460  * (depends on face normal)
1461  */
1462 bool BM_loop_is_convex(const BMLoop *l)
1463 {
1464         float e_dir_prev[3];
1465         float e_dir_next[3];
1466         float l_no[3];
1467
1468         sub_v3_v3v3(e_dir_prev, l->prev->v->co, l->v->co);
1469         sub_v3_v3v3(e_dir_next, l->next->v->co, l->v->co);
1470         cross_v3_v3v3(l_no, e_dir_next, e_dir_prev);
1471         return dot_v3v3(l_no, l->f->no) > 0.0f;
1472 }
1473
1474 /**
1475  * Calculates the angle between the previous and next loops
1476  * (angle at this loops face corner).
1477  *
1478  * \return angle in radians
1479  */
1480 float BM_loop_calc_face_angle(const BMLoop *l)
1481 {
1482         return angle_v3v3v3(l->prev->v->co,
1483                             l->v->co,
1484                             l->next->v->co);
1485 }
1486
1487 /**
1488  * \brief BM_loop_calc_face_normal
1489  *
1490  * Calculate the normal at this loop corner or fallback to the face normal on straight lines.
1491  *
1492  * \param l The loop to calculate the normal at
1493  * \param r_normal Resulting normal
1494  */
1495 void BM_loop_calc_face_normal(const BMLoop *l, float r_normal[3])
1496 {
1497         if (normal_tri_v3(r_normal,
1498                           l->prev->v->co,
1499                           l->v->co,
1500                           l->next->v->co) != 0.0f)
1501         {
1502                 /* pass */
1503         }
1504         else {
1505                 copy_v3_v3(r_normal, l->f->no);
1506         }
1507 }
1508
1509 /**
1510  * \brief BM_loop_calc_face_direction
1511  *
1512  * Calculate the direction a loop is pointing.
1513  *
1514  * \param l The loop to calculate the direction at
1515  * \param r_dir Resulting direction
1516  */
1517 void BM_loop_calc_face_direction(const BMLoop *l, float r_dir[3])
1518 {
1519         float v_prev[3];
1520         float v_next[3];
1521
1522         sub_v3_v3v3(v_prev, l->v->co, l->prev->v->co);
1523         sub_v3_v3v3(v_next, l->next->v->co, l->v->co);
1524
1525         normalize_v3(v_prev);
1526         normalize_v3(v_next);
1527
1528         add_v3_v3v3(r_dir, v_prev, v_next);
1529         normalize_v3(r_dir);
1530 }
1531
1532 /**
1533  * \brief BM_loop_calc_face_tangent
1534  *
1535  * Calculate the tangent at this loop corner or fallback to the face normal on straight lines.
1536  * This vector always points inward into the face.
1537  *
1538  * \param l The loop to calculate the tangent at
1539  * \param r_tangent Resulting tangent
1540  */
1541 void BM_loop_calc_face_tangent(const BMLoop *l, float r_tangent[3])
1542 {
1543         float v_prev[3];
1544         float v_next[3];
1545         float dir[3];
1546
1547         sub_v3_v3v3(v_prev, l->prev->v->co, l->v->co);
1548         sub_v3_v3v3(v_next, l->v->co, l->next->v->co);
1549
1550         normalize_v3(v_prev);
1551         normalize_v3(v_next);
1552         add_v3_v3v3(dir, v_prev, v_next);
1553
1554         if (compare_v3v3(v_prev, v_next, FLT_EPSILON * 10.0f) == false) {
1555                 float nor[3]; /* for this purpose doesn't need to be normalized */
1556                 cross_v3_v3v3(nor, v_prev, v_next);
1557                 /* concave face check */
1558                 if (UNLIKELY(dot_v3v3(nor, l->f->no) < 0.0f)) {
1559                         negate_v3(nor);
1560                 }
1561                 cross_v3_v3v3(r_tangent, dir, nor);
1562         }
1563         else {
1564                 /* prev/next are the same - compare with face normal since we don't have one */
1565                 cross_v3_v3v3(r_tangent, dir, l->f->no);
1566         }
1567
1568         normalize_v3(r_tangent);
1569 }
1570
1571 /**
1572  * \brief BMESH EDGE/FACE ANGLE
1573  *
1574  *  Calculates the angle between two faces.
1575  *  Assumes the face normals are correct.
1576  *
1577  * \return angle in radians
1578  */
1579 float BM_edge_calc_face_angle_ex(const BMEdge *e, const float fallback)
1580 {
1581         if (BM_edge_is_manifold(e)) {
1582                 const BMLoop *l1 = e->l;
1583                 const BMLoop *l2 = e->l->radial_next;
1584                 return angle_normalized_v3v3(l1->f->no, l2->f->no);
1585         }
1586         else {
1587                 return fallback;
1588         }
1589 }
1590 float BM_edge_calc_face_angle(const BMEdge *e)
1591 {
1592         return BM_edge_calc_face_angle_ex(e, DEG2RADF(90.0f));
1593 }
1594
1595 /**
1596  * \brief BMESH EDGE/FACE ANGLE
1597  *
1598  *  Calculates the angle between two faces.
1599  *  Assumes the face normals are correct.
1600  *
1601  * \return angle in radians
1602  */
1603 float BM_edge_calc_face_angle_signed_ex(const BMEdge *e, const float fallback)
1604 {
1605         if (BM_edge_is_manifold(e)) {
1606                 BMLoop *l1 = e->l;
1607                 BMLoop *l2 = e->l->radial_next;
1608                 const float angle = angle_normalized_v3v3(l1->f->no, l2->f->no);
1609                 return BM_edge_is_convex(e) ? angle : -angle;
1610         }
1611         else {
1612                 return fallback;
1613         }
1614 }
1615 float BM_edge_calc_face_angle_signed(const BMEdge *e)
1616 {
1617         return BM_edge_calc_face_angle_signed_ex(e, DEG2RADF(90.0f));
1618 }
1619
1620 /**
1621  * \brief BMESH EDGE/FACE TANGENT
1622  *
1623  * Calculate the tangent at this loop corner or fallback to the face normal on straight lines.
1624  * This vector always points inward into the face.
1625  *
1626  * \brief BM_edge_calc_face_tangent
1627  * \param e
1628  * \param e_loop The loop to calculate the tangent at,
1629  * used to get the face and winding direction.
1630  * \param r_tangent The loop corner tangent to set
1631  */
1632
1633 void BM_edge_calc_face_tangent(const BMEdge *e, const BMLoop *e_loop, float r_tangent[3])
1634 {
1635         float tvec[3];
1636         BMVert *v1, *v2;
1637         BM_edge_ordered_verts_ex(e, &v1, &v2, e_loop);
1638
1639         sub_v3_v3v3(tvec, v1->co, v2->co); /* use for temp storage */
1640         /* note, we could average the tangents of both loops,
1641          * for non flat ngons it will give a better direction */
1642         cross_v3_v3v3(r_tangent, tvec, e_loop->f->no);
1643         normalize_v3(r_tangent);
1644 }
1645
1646 /**
1647  * \brief BMESH VERT/EDGE ANGLE
1648  *
1649  * Calculates the angle a verts 2 edges.
1650  *
1651  * \returns the angle in radians
1652  */
1653 float BM_vert_calc_edge_angle_ex(const BMVert *v, const float fallback)
1654 {
1655         BMEdge *e1, *e2;
1656
1657         /* saves BM_vert_edge_count(v) and and edge iterator,
1658          * get the edges and count them both at once */
1659
1660         if ((e1 = v->e) &&
1661             (e2 =  bmesh_disk_edge_next(e1, v)) &&
1662             /* make sure we come full circle and only have 2 connected edges */
1663             (e1 == bmesh_disk_edge_next(e2, v)))
1664         {
1665                 BMVert *v1 = BM_edge_other_vert(e1, v);
1666                 BMVert *v2 = BM_edge_other_vert(e2, v);
1667
1668                 return (float)M_PI - angle_v3v3v3(v1->co, v->co, v2->co);
1669         }
1670         else {
1671                 return fallback;
1672         }
1673 }
1674
1675 float BM_vert_calc_edge_angle(const BMVert *v)
1676 {
1677         return BM_vert_calc_edge_angle_ex(v, DEG2RADF(90.0f));
1678 }
1679
1680 /**
1681  * \note this isn't optimal to run on an array of verts,
1682  * see 'solidify_add_thickness' for a function which runs on an array.
1683  */
1684 float BM_vert_calc_shell_factor(const BMVert *v)
1685 {
1686         BMIter iter;
1687         BMLoop *l;
1688         float accum_shell = 0.0f;
1689         float accum_angle = 0.0f;
1690
1691         BM_ITER_ELEM (l, &iter, (BMVert *)v, BM_LOOPS_OF_VERT) {
1692                 const float face_angle = BM_loop_calc_face_angle(l);
1693                 accum_shell += shell_v3v3_normalized_to_dist(v->no, l->f->no) * face_angle;
1694                 accum_angle += face_angle;
1695         }
1696
1697         if (accum_angle != 0.0f) {
1698                 return accum_shell / accum_angle;
1699         }
1700         else {
1701                 return 1.0f;
1702         }
1703 }
1704 /* alternate version of #BM_vert_calc_shell_factor which only
1705  * uses 'hflag' faces, but falls back to all if none found. */
1706 float BM_vert_calc_shell_factor_ex(const BMVert *v, const float no[3], const char hflag)
1707 {
1708         BMIter iter;
1709         const BMLoop *l;
1710         float accum_shell = 0.0f;
1711         float accum_angle = 0.0f;
1712         int tot_sel = 0, tot = 0;
1713
1714         BM_ITER_ELEM (l, &iter, (BMVert *)v, BM_LOOPS_OF_VERT) {
1715                 if (BM_elem_flag_test(l->f, hflag)) {  /* <-- main difference to BM_vert_calc_shell_factor! */
1716                         const float face_angle = BM_loop_calc_face_angle(l);
1717                         accum_shell += shell_v3v3_normalized_to_dist(no, l->f->no) * face_angle;
1718                         accum_angle += face_angle;
1719                         tot_sel++;
1720                 }
1721                 tot++;
1722         }
1723
1724         if (accum_angle != 0.0f) {
1725                 return accum_shell / accum_angle;
1726         }
1727         else {
1728                 /* other main difference from BM_vert_calc_shell_factor! */
1729                 if (tot != 0 && tot_sel == 0) {
1730                         /* none selected, so use all */
1731                         return BM_vert_calc_shell_factor(v);
1732                 }
1733                 else {
1734                         return 1.0f;
1735                 }
1736         }
1737 }
1738
1739 /**
1740  * \note quite an obscure function.
1741  * used in bmesh operators that have a relative scale options,
1742  */
1743 float BM_vert_calc_mean_tagged_edge_length(const BMVert *v)
1744 {
1745         BMIter iter;
1746         BMEdge *e;
1747         int tot;
1748         float length = 0.0f;
1749
1750         BM_ITER_ELEM_INDEX (e, &iter, (BMVert *)v, BM_EDGES_OF_VERT, tot) {
1751                 const BMVert *v_other = BM_edge_other_vert(e, v);
1752                 if (BM_elem_flag_test(v_other, BM_ELEM_TAG)) {
1753                         length += BM_edge_calc_length(e);
1754                 }
1755         }
1756
1757         if (tot) {
1758                 return length / (float)tot;
1759         }
1760         else {
1761                 return 0.0f;
1762         }
1763 }
1764
1765
1766 /**
1767  * Returns the loop of the shortest edge in f.
1768  */
1769 BMLoop *BM_face_find_shortest_loop(BMFace *f)
1770 {
1771         BMLoop *shortest_loop = NULL;
1772         float shortest_len = FLT_MAX;
1773
1774         BMLoop *l_iter;
1775         BMLoop *l_first;
1776
1777         l_iter = l_first = BM_FACE_FIRST_LOOP(f);
1778
1779         do {
1780                 const float len_sq = len_squared_v3v3(l_iter->v->co, l_iter->next->v->co);
1781                 if (len_sq <= shortest_len) {
1782                         shortest_loop = l_iter;
1783                         shortest_len = len_sq;
1784                 }
1785         } while ((l_iter = l_iter->next) != l_first);
1786
1787         return shortest_loop;
1788 }
1789
1790 /**
1791  * Returns the loop of the longest edge in f.
1792  */
1793 BMLoop *BM_face_find_longest_loop(BMFace *f)
1794 {
1795         BMLoop *longest_loop = NULL;
1796         float len_max_sq = 0.0f;
1797
1798         BMLoop *l_iter;
1799         BMLoop *l_first;
1800
1801         l_iter = l_first = BM_FACE_FIRST_LOOP(f);
1802
1803         do {
1804                 const float len_sq = len_squared_v3v3(l_iter->v->co, l_iter->next->v->co);
1805                 if (len_sq >= len_max_sq) {
1806                         longest_loop = l_iter;
1807                         len_max_sq = len_sq;
1808                 }
1809         } while ((l_iter = l_iter->next) != l_first);
1810
1811         return longest_loop;
1812 }
1813
1814 /**
1815  * Returns the edge existing between \a v_a and \a v_b, or NULL if there isn't one.
1816  *
1817  * \note multiple edges may exist between any two vertices, and therefore
1818  * this function only returns the first one found.
1819  */
1820 #if 0
1821 BMEdge *BM_edge_exists(BMVert *v_a, BMVert *v_b)
1822 {
1823         BMIter iter;
1824         BMEdge *e;
1825
1826
1827         BLI_assert(v_a != v_b);
1828         BLI_assert(v_a->head.htype == BM_VERT && v_b->head.htype == BM_VERT);
1829
1830         BM_ITER_ELEM (e, &iter, v_a, BM_EDGES_OF_VERT) {
1831                 if (e->v1 == v_b || e->v2 == v_b)
1832                         return e;
1833         }
1834
1835         return NULL;
1836 }
1837 #else
1838 BMEdge *BM_edge_exists(BMVert *v_a, BMVert *v_b)
1839 {
1840         /* speedup by looping over both edges verts
1841          * where one vert may connect to many edges but not the other. */
1842
1843         BMEdge *e_a, *e_b;
1844
1845         BLI_assert(v_a != v_b);
1846         BLI_assert(v_a->head.htype == BM_VERT && v_b->head.htype == BM_VERT);
1847
1848         if ((e_a = v_a->e) && (e_b = v_b->e)) {
1849                 BMEdge *e_a_iter = e_a, *e_b_iter = e_b;
1850
1851                 do {
1852                         if (BM_vert_in_edge(e_a_iter, v_b)) {
1853                                 return e_a_iter;
1854                         }
1855                         if (BM_vert_in_edge(e_b_iter, v_a)) {
1856                                 return e_b_iter;
1857                         }
1858                 } while (((e_a_iter = bmesh_disk_edge_next(e_a_iter, v_a)) != e_a) &&
1859                          ((e_b_iter = bmesh_disk_edge_next(e_b_iter, v_b)) != e_b));
1860         }
1861
1862         return NULL;
1863 }
1864 #endif
1865
1866 /**
1867  * Returns an edge sharing the same vertices as this one.
1868  * This isn't an invalid state but tools should clean up these cases before
1869  * returning the mesh to the user.
1870  */
1871 BMEdge *BM_edge_find_double(BMEdge *e)
1872 {
1873         BMVert *v       = e->v1;
1874         BMVert *v_other = e->v2;
1875
1876         BMEdge *e_iter;
1877
1878         e_iter = e;
1879         while ((e_iter = bmesh_disk_edge_next(e_iter, v)) != e) {
1880                 if (UNLIKELY(BM_vert_in_edge(e_iter, v_other))) {
1881                         return e_iter;
1882                 }
1883         }
1884
1885         return NULL;
1886 }
1887
1888 /**
1889  * Given a set of vertices (varr), find out if
1890  * there is a face with exactly those vertices
1891  * (and only those vertices).
1892  *
1893  * \note there used to be a BM_face_exists_overlap function that checks for partial overlap.
1894  */
1895 bool BM_face_exists(BMVert **varr, int len, BMFace **r_existface)
1896 {
1897         if (varr[0]->e) {
1898                 BMEdge *e_iter, *e_first;
1899                 e_iter = e_first = varr[0]->e;
1900
1901                 /* would normally use BM_LOOPS_OF_VERT, but this runs so often,
1902                  * its faster to iterate on the data directly */
1903                 do {
1904                         if (e_iter->l) {
1905                                 BMLoop *l_iter_radial, *l_first_radial;
1906                                 l_iter_radial = l_first_radial = e_iter->l;
1907
1908                                 do {
1909                                         if ((l_iter_radial->v == varr[0]) &&
1910                                             (l_iter_radial->f->len == len))
1911                                         {
1912                                                 /* the fist 2 verts match, now check the remaining (len - 2) faces do too
1913                                                  * winding isn't known, so check in both directions */
1914                                                 int i_walk = 2;
1915
1916                                                 if (l_iter_radial->next->v == varr[1]) {
1917                                                         BMLoop *l_walk = l_iter_radial->next->next;
1918                                                         do {
1919                                                                 if (l_walk->v != varr[i_walk]) {
1920                                                                         break;
1921                                                                 }
1922                                                         } while ((l_walk = l_walk->next), ++i_walk != len);
1923                                                 }
1924                                                 else if (l_iter_radial->prev->v == varr[1]) {
1925                                                         BMLoop *l_walk = l_iter_radial->prev->prev;
1926                                                         do {
1927                                                                 if (l_walk->v != varr[i_walk]) {
1928                                                                         break;
1929                                                                 }
1930                                                         } while ((l_walk = l_walk->prev), ++i_walk != len);
1931                                                 }
1932
1933                                                 if (i_walk == len) {
1934                                                         if (r_existface) {
1935                                                                 *r_existface = l_iter_radial->f;
1936                                                         }
1937                                                         return true;
1938                                                 }
1939                                         }
1940                                 } while ((l_iter_radial = l_iter_radial->radial_next) != l_first_radial);
1941
1942                         }
1943                 } while ((e_iter = BM_DISK_EDGE_NEXT(e_iter, varr[0])) != e_first);
1944         }
1945
1946         if (r_existface) {
1947                 *r_existface = NULL;
1948         }
1949         return false;
1950 }
1951
1952
1953 /**
1954  * Given a set of vertices and edges (\a varr, \a earr), find out if
1955  * all those vertices are filled in by existing faces that _only_ use those vertices.
1956  *
1957  * This is for use in cases where creating a face is possible but would result in
1958  * many overlapping faces.
1959  *
1960  * An example of how this is used: when 2 tri's are selected that share an edge,
1961  * pressing Fkey would make a new overlapping quad (without a check like this)
1962  *
1963  * \a earr and \a varr can be in any order, however they _must_ form a closed loop.
1964  */
1965 bool BM_face_exists_multi(BMVert **varr, BMEdge **earr, int len)
1966 {
1967         BMFace *f;
1968         BMEdge *e;
1969         BMVert *v;
1970         bool ok;
1971         int tot_tag;
1972
1973         BMIter fiter;
1974         BMIter viter;
1975
1976         int i;
1977
1978         for (i = 0; i < len; i++) {
1979                 /* save some time by looping over edge faces rather then vert faces
1980                  * will still loop over some faces twice but not as many */
1981                 BM_ITER_ELEM (f, &fiter, earr[i], BM_FACES_OF_EDGE) {
1982                         BM_elem_flag_disable(f, BM_ELEM_INTERNAL_TAG);
1983                         BM_ITER_ELEM (v, &viter, f, BM_VERTS_OF_FACE) {
1984                                 BM_elem_flag_disable(v, BM_ELEM_INTERNAL_TAG);
1985                         }
1986                 }
1987
1988                 /* clear all edge tags */
1989                 BM_ITER_ELEM (e, &fiter, varr[i], BM_EDGES_OF_VERT) {
1990                         BM_elem_flag_disable(e, BM_ELEM_INTERNAL_TAG);
1991                 }
1992         }
1993
1994         /* now tag all verts and edges in the boundary array as true so
1995          * we can know if a face-vert is from our array */
1996         for (i = 0; i < len; i++) {
1997                 BM_elem_flag_enable(varr[i], BM_ELEM_INTERNAL_TAG);
1998                 BM_elem_flag_enable(earr[i], BM_ELEM_INTERNAL_TAG);
1999         }
2000
2001
2002         /* so! boundary is tagged, everything else cleared */
2003
2004
2005         /* 1) tag all faces connected to edges - if all their verts are boundary */
2006         tot_tag = 0;
2007         for (i = 0; i < len; i++) {
2008                 BM_ITER_ELEM (f, &fiter, earr[i], BM_FACES_OF_EDGE) {
2009                         if (!BM_elem_flag_test(f, BM_ELEM_INTERNAL_TAG)) {
2010                                 ok = true;
2011                                 BM_ITER_ELEM (v, &viter, f, BM_VERTS_OF_FACE) {
2012                                         if (!BM_elem_flag_test(v, BM_ELEM_INTERNAL_TAG)) {
2013                                                 ok = false;
2014                                                 break;
2015                                         }
2016                                 }
2017
2018                                 if (ok) {
2019                                         /* we only use boundary verts */
2020                                         BM_elem_flag_enable(f, BM_ELEM_INTERNAL_TAG);
2021                                         tot_tag++;
2022                                 }
2023                         }
2024                         else {
2025                                 /* we already found! */
2026                         }
2027                 }
2028         }
2029
2030         if (tot_tag == 0) {
2031                 /* no faces use only boundary verts, quit early */
2032                 return false;
2033         }
2034
2035         /* 2) loop over non-boundary edges that use boundary verts,
2036          *    check each have 2 tagges faces connected (faces that only use 'varr' verts) */
2037         ok = true;
2038         for (i = 0; i < len; i++) {
2039                 BM_ITER_ELEM (e, &fiter, varr[i], BM_EDGES_OF_VERT) {
2040
2041                         if (/* non-boundary edge */
2042                             BM_elem_flag_test(e, BM_ELEM_INTERNAL_TAG) == false &&
2043                             /* ...using boundary verts */
2044                             BM_elem_flag_test(e->v1, BM_ELEM_INTERNAL_TAG) &&
2045                             BM_elem_flag_test(e->v2, BM_ELEM_INTERNAL_TAG))
2046                         {
2047                                 int tot_face_tag = 0;
2048                                 BM_ITER_ELEM (f, &fiter, e, BM_FACES_OF_EDGE) {
2049                                         if (BM_elem_flag_test(f, BM_ELEM_INTERNAL_TAG)) {
2050                                                 tot_face_tag++;
2051                                         }
2052                                 }
2053
2054                                 if (tot_face_tag != 2) {
2055                                         ok = false;
2056                                         break;
2057                                 }
2058
2059                         }
2060                 }
2061
2062                 if (ok == false) {
2063                         break;
2064                 }
2065         }
2066
2067         return ok;
2068 }
2069
2070 /* same as 'BM_face_exists_multi' but built vert array from edges */
2071 bool BM_face_exists_multi_edge(BMEdge **earr, int len)
2072 {
2073         BMVert **varr = BLI_array_alloca(varr, len);
2074
2075         bool ok;
2076         int i, i_next;
2077
2078         /* first check if verts have edges, if not we can bail out early */
2079         ok = true;
2080         for (i = len - 1, i_next = 0; i_next < len; (i = i_next++)) {
2081                 if (!(varr[i] = BM_edge_share_vert(earr[i], earr[i_next]))) {
2082                         ok = false;
2083                         break;
2084                 }
2085         }
2086
2087         if (ok == false) {
2088                 BMESH_ASSERT(0);
2089                 return false;
2090         }
2091
2092         ok = BM_face_exists_multi(varr, earr, len);
2093
2094         return ok;
2095 }
2096
2097
2098 /**
2099  * Given a set of vertices (varr), find out if
2100  * all those vertices overlap an existing face.
2101  *
2102  * \note The face may contain other verts \b not in \a varr.
2103  *
2104  * \note Its possible there are more than one overlapping faces,
2105  * in this case the first one found will be assigned to \a r_f_overlap.
2106  *
2107  * \param varr  Array of unordered verts.
2108  * \param len  \a varr array length.
2109  * \param r_f_overlap  The overlapping face to return.
2110  * \return Success
2111  */
2112
2113 bool BM_face_exists_overlap(BMVert **varr, const int len, BMFace **r_f_overlap)
2114 {
2115         BMIter viter;
2116         BMFace *f;
2117         int i;
2118         bool is_overlap = false;
2119         LinkNode *f_lnk = NULL;
2120
2121         if (r_f_overlap) {
2122                 *r_f_overlap = NULL;
2123         }
2124
2125 #ifdef DEBUG
2126         /* check flag isn't already set */
2127         for (i = 0; i < len; i++) {
2128                 BM_ITER_ELEM (f, &viter, varr[i], BM_FACES_OF_VERT) {
2129                         BLI_assert(BM_ELEM_API_FLAG_TEST(f, _FLAG_OVERLAP) == 0);
2130                 }
2131         }
2132 #endif
2133
2134         for (i = 0; i < len; i++) {
2135                 BM_ITER_ELEM (f, &viter, varr[i], BM_FACES_OF_VERT) {
2136                         if (BM_ELEM_API_FLAG_TEST(f, _FLAG_OVERLAP) == 0) {
2137                                 if (len <= BM_verts_in_face_count(varr, len, f)) {
2138                                         if (r_f_overlap)
2139                                                 *r_f_overlap = f;
2140
2141                                         is_overlap = true;
2142                                         break;
2143                                 }
2144
2145                                 BM_ELEM_API_FLAG_ENABLE(f, _FLAG_OVERLAP);
2146                                 BLI_linklist_prepend_alloca(&f_lnk, f);
2147                         }
2148                 }
2149         }
2150
2151         for (; f_lnk; f_lnk = f_lnk->next) {
2152                 BM_ELEM_API_FLAG_DISABLE((BMFace *)f_lnk->link, _FLAG_OVERLAP);
2153         }
2154
2155         return is_overlap;
2156 }
2157
2158 /**
2159  * Given a set of vertices (varr), find out if
2160  * there is a face that uses vertices only from this list
2161  * (that the face is a subset or made from the vertices given).
2162  *
2163  * \param varr  Array of unordered verts.
2164  * \param len  varr array length.
2165  */
2166 bool BM_face_exists_overlap_subset(BMVert **varr, const int len)
2167 {
2168         BMIter viter;
2169         BMFace *f;
2170         int i;
2171         bool is_init = false;
2172         bool is_overlap = false;
2173         LinkNode *f_lnk = NULL;
2174
2175 #ifdef DEBUG
2176         /* check flag isn't already set */
2177         for (i = 0; i < len; i++) {
2178                 BLI_assert(BM_ELEM_API_FLAG_TEST(varr[i], _FLAG_OVERLAP) == 0);
2179                 BM_ITER_ELEM (f, &viter, varr[i], BM_FACES_OF_VERT) {
2180                         BLI_assert(BM_ELEM_API_FLAG_TEST(f, _FLAG_OVERLAP) == 0);
2181                 }
2182         }
2183 #endif
2184
2185         for (i = 0; i < len; i++) {
2186                 BM_ITER_ELEM (f, &viter, varr[i], BM_FACES_OF_VERT) {
2187                         if ((f->len <= len) && (BM_ELEM_API_FLAG_TEST(f, _FLAG_OVERLAP) == 0)) {
2188                                 /* check if all vers in this face are flagged*/
2189                                 BMLoop *l_iter, *l_first;
2190
2191                                 if (is_init == false) {
2192                                         is_init = true;
2193                                         for (i = 0; i < len; i++) {
2194                                                 BM_ELEM_API_FLAG_ENABLE(varr[i], _FLAG_OVERLAP);
2195                                         }
2196                                 }
2197
2198                                 l_iter = l_first = BM_FACE_FIRST_LOOP(f);
2199                                 is_overlap = true;
2200                                 do {
2201                                         if (BM_ELEM_API_FLAG_TEST(l_iter->v, _FLAG_OVERLAP) == 0) {
2202                                                 is_overlap = false;
2203                                                 break;
2204                                         }
2205                                 } while ((l_iter = l_iter->next) != l_first);
2206
2207                                 if (is_overlap) {
2208                                         break;
2209                                 }
2210
2211                                 BM_ELEM_API_FLAG_ENABLE(f, _FLAG_OVERLAP);
2212                                 BLI_linklist_prepend_alloca(&f_lnk, f);
2213                         }
2214                 }
2215         }
2216
2217         if (is_init == true) {
2218                 for (i = 0; i < len; i++) {
2219                         BM_ELEM_API_FLAG_DISABLE(varr[i], _FLAG_OVERLAP);
2220                 }
2221         }
2222
2223         for (; f_lnk; f_lnk = f_lnk->next) {
2224                 BM_ELEM_API_FLAG_DISABLE((BMFace *)f_lnk->link, _FLAG_OVERLAP);
2225         }
2226
2227         return is_overlap;
2228 }
2229
2230 bool BM_vert_is_all_edge_flag_test(const BMVert *v, const char hflag, const bool respect_hide)
2231 {
2232         if (v->e) {
2233                 BMEdge *e_other;
2234                 BMIter eiter;
2235
2236                 BM_ITER_ELEM (e_other, &eiter, (BMVert *)v, BM_EDGES_OF_VERT) {
2237                         if (!respect_hide || !BM_elem_flag_test(e_other, BM_ELEM_HIDDEN)) {
2238                                 if (!BM_elem_flag_test(e_other, hflag)) {
2239                                         return false;
2240                                 }
2241                         }
2242                 }
2243         }
2244
2245         return true;
2246 }
2247
2248 bool BM_vert_is_all_face_flag_test(const BMVert *v, const char hflag, const bool respect_hide)
2249 {
2250         if (v->e) {
2251                 BMEdge *f_other;
2252                 BMIter fiter;
2253
2254                 BM_ITER_ELEM (f_other, &fiter, (BMVert *)v, BM_FACES_OF_VERT) {
2255                         if (!respect_hide || !BM_elem_flag_test(f_other, BM_ELEM_HIDDEN)) {
2256                                 if (!BM_elem_flag_test(f_other, hflag)) {
2257                                         return false;
2258                                 }
2259                         }
2260                 }
2261         }
2262
2263         return true;
2264 }
2265
2266
2267 bool BM_edge_is_all_face_flag_test(const BMEdge *e, const char hflag, const bool respect_hide)
2268 {
2269         if (e->l) {
2270                 BMLoop *l_iter, *l_first;
2271
2272                 l_iter = l_first = e->l;
2273                 do {
2274                         if (!respect_hide || !BM_elem_flag_test(l_iter->f, BM_ELEM_HIDDEN)) {
2275                                 if (!BM_elem_flag_test(l_iter->f, hflag)) {
2276                                         return false;
2277                                 }
2278                         }
2279                 } while ((l_iter = l_iter->radial_next) != l_first);
2280         }
2281
2282         return true;
2283 }
2284
2285 /* convenience functions for checking flags */
2286 bool BM_edge_is_any_vert_flag_test(const BMEdge *e, const char hflag)
2287 {
2288         return (BM_elem_flag_test(e->v1, hflag) ||
2289                 BM_elem_flag_test(e->v2, hflag));
2290 }
2291
2292 bool BM_face_is_any_vert_flag_test(const BMFace *f, const char hflag)
2293 {
2294         BMLoop *l_iter;
2295         BMLoop *l_first;
2296
2297         l_iter = l_first = BM_FACE_FIRST_LOOP(f);
2298         do {
2299                 if (BM_elem_flag_test(l_iter->v, hflag)) {
2300                         return true;
2301                 }
2302         } while ((l_iter = l_iter->next) != l_first);
2303         return false;
2304 }
2305
2306 bool BM_face_is_any_edge_flag_test(const BMFace *f, const char hflag)
2307 {
2308         BMLoop *l_iter;
2309         BMLoop *l_first;
2310
2311         l_iter = l_first = BM_FACE_FIRST_LOOP(f);
2312         do {
2313                 if (BM_elem_flag_test(l_iter->e, hflag)) {
2314                         return true;
2315                 }
2316         } while ((l_iter = l_iter->next) != l_first);
2317         return false;
2318 }
2319
2320 /**
2321  * Use within assert's to check normals are valid.
2322  */
2323 bool BM_face_is_normal_valid(const BMFace *f)
2324 {
2325         const float eps = 0.0001f;
2326         float no[3];
2327
2328         BM_face_calc_normal(f, no);
2329         return len_squared_v3v3(no, f->no) < (eps * eps);
2330 }
2331
2332 static void bm_mesh_calc_volume_face(const BMFace *f, float *r_vol)
2333 {
2334         const int tottri = f->len - 2;
2335         BMLoop **loops = BLI_array_alloca(loops, f->len);
2336         unsigned int (*index)[3] = BLI_array_alloca(index, tottri);
2337         int j;
2338
2339         BM_face_calc_tessellation(f, false, loops, index);
2340
2341         for (j = 0; j < tottri; j++) {
2342                 const float *p1 = loops[index[j][0]]->v->co;
2343                 const float *p2 = loops[index[j][1]]->v->co;
2344                 const float *p3 = loops[index[j][2]]->v->co;
2345
2346                 /* co1.dot(co2.cross(co3)) / 6.0 */
2347                 float cross[3];
2348                 cross_v3_v3v3(cross, p2, p3);
2349                 *r_vol += (1.0f / 6.0f) * dot_v3v3(p1, cross);
2350         }
2351 }
2352 float BM_mesh_calc_volume(BMesh *bm, bool is_signed)
2353 {
2354         /* warning, calls own tessellation function, may be slow */
2355         float vol = 0.0f;
2356         BMFace *f;
2357         BMIter fiter;
2358
2359         BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
2360                 bm_mesh_calc_volume_face(f, &vol);
2361         }
2362
2363         if (is_signed == false) {
2364                 vol = fabsf(vol);
2365         }
2366
2367         return vol;
2368 }
2369
2370 /* note, almost duplicate of BM_mesh_calc_edge_groups, keep in sync */
2371 /**
2372  * Calculate isolated groups of faces with optional filtering.
2373  *
2374  * \param bm  the BMesh.
2375  * \param r_groups_array  Array of ints to fill in, length of bm->totface
2376  *        (or when hflag_test is set, the number of flagged faces).
2377  * \param r_group_index  index, length pairs into \a r_groups_array, size of return value
2378  *        int pairs: (array_start, array_length).
2379  * \param filter_fn  Filter the edge-loops or vert-loops we step over (depends on \a htype_step).
2380  * \param user_data  Optional user data for \a filter_fn, can be NULL.
2381  * \param hflag_test  Optional flag to test faces,
2382  *        use to exclude faces from the calculation, 0 for all faces.
2383  * \param htype_step  BM_VERT to walk over face-verts, BM_EDGE to walk over faces edges
2384  *        (having both set is supported too).
2385  * \return The number of groups found.
2386  */
2387 int BM_mesh_calc_face_groups(
2388         BMesh *bm, int *r_groups_array, int (**r_group_index)[2],
2389         BMLoopFilterFunc filter_fn, void *user_data,
2390         const char hflag_test, const char htype_step)
2391 {
2392 #ifdef DEBUG
2393         int group_index_len = 1;
2394 #else
2395         int group_index_len = 32;
2396 #endif
2397
2398         int (*group_index)[2] = MEM_mallocN(sizeof(*group_index) * group_index_len, __func__);
2399
2400         int *group_array = r_groups_array;
2401         STACK_DECLARE(group_array);
2402
2403         int group_curr = 0;
2404
2405         unsigned int tot_faces = 0;
2406         unsigned int tot_touch = 0;
2407
2408         BMFace **stack;
2409         STACK_DECLARE(stack);
2410
2411         BMIter iter;
2412         BMFace *f;
2413         int i;
2414
2415         STACK_INIT(group_array, bm->totface);
2416
2417         BLI_assert(((htype_step & ~(BM_VERT | BM_EDGE)) == 0) && (htype_step != 0));
2418
2419         /* init the array */
2420         BM_ITER_MESH_INDEX (f, &iter, bm, BM_FACES_OF_MESH, i) {
2421                 if ((hflag_test == 0) || BM_elem_flag_test(f, hflag_test)) {
2422                         tot_faces++;
2423                         BM_elem_flag_disable(f, BM_ELEM_TAG);
2424                 }
2425                 else {
2426                         /* never walk over tagged */
2427                         BM_elem_flag_enable(f, BM_ELEM_TAG);
2428                 }
2429
2430                 BM_elem_index_set(f, i); /* set_inline */
2431         }
2432         bm->elem_index_dirty &= ~BM_FACE;
2433
2434         /* detect groups */
2435         stack = MEM_mallocN(sizeof(*stack) * tot_faces, __func__);
2436
2437         while (tot_touch != tot_faces) {
2438                 int *group_item;
2439                 bool ok = false;
2440
2441                 BLI_assert(tot_touch < tot_faces);
2442
2443                 STACK_INIT(stack, tot_faces);
2444
2445                 BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
2446                         if (BM_elem_flag_test(f, BM_ELEM_TAG) == false) {
2447                                 BM_elem_flag_enable(f, BM_ELEM_TAG);
2448                                 STACK_PUSH(stack, f);
2449                                 ok = true;
2450                                 break;
2451                         }
2452                 }
2453
2454                 BLI_assert(ok == true);
2455                 UNUSED_VARS_NDEBUG(ok);
2456
2457                 /* manage arrays */
2458                 if (group_index_len == group_curr) {
2459                         group_index_len *= 2;
2460                         group_index = MEM_reallocN(group_index, sizeof(*group_index) * group_index_len);
2461                 }
2462
2463                 group_item = group_index[group_curr];
2464                 group_item[0] = STACK_SIZE(group_array);
2465                 group_item[1] = 0;
2466
2467                 while ((f = STACK_POP(stack))) {
2468                         BMLoop *l_iter, *l_first;
2469
2470                         /* add face */
2471                         STACK_PUSH(group_array, BM_elem_index_get(f));
2472                         tot_touch++;
2473                         group_item[1]++;
2474                         /* done */
2475
2476                         if (htype_step & BM_EDGE) {
2477                                 /* search for other faces */
2478                                 l_iter = l_first = BM_FACE_FIRST_LOOP(f);
2479                                 do {
2480                                         BMLoop *l_radial_iter = l_iter->radial_next;
2481                                         if ((l_radial_iter != l_iter) &&
2482                                             ((filter_fn == NULL) || filter_fn(l_iter, user_data)))
2483                                         {
2484                                                 do {
2485                                                         BMFace *f_other = l_radial_iter->f;
2486                                                         if (BM_elem_flag_test(f_other, BM_ELEM_TAG) == false) {
2487                                                                 BM_elem_flag_enable(f_other, BM_ELEM_TAG);
2488                                                                 STACK_PUSH(stack, f_other);
2489                                                         }
2490                                                 } while ((l_radial_iter = l_radial_iter->radial_next) != l_iter);
2491                                         }
2492                                 } while ((l_iter = l_iter->next) != l_first);
2493                         }
2494
2495                         if (htype_step & BM_VERT) {
2496                                 BMIter liter;
2497                                 /* search for other faces */
2498                                 l_iter = l_first = BM_FACE_FIRST_LOOP(f);
2499                                 do {
2500                                         if ((filter_fn == NULL) || filter_fn(l_iter, user_data)) {
2501                                                 BMLoop *l_other;
2502                                                 BM_ITER_ELEM (l_other, &liter, l_iter, BM_LOOPS_OF_LOOP) {
2503                                                         BMFace *f_other = l_other->f;
2504                                                         if (BM_elem_flag_test(f_other, BM_ELEM_TAG) == false) {
2505                                                                 BM_elem_flag_enable(f_other, BM_ELEM_TAG);
2506                                                                 STACK_PUSH(stack, f_other);
2507                                                         }
2508                                                 }
2509                                         }
2510                                 } while ((l_iter = l_iter->next) != l_first);
2511                         }
2512                 }
2513
2514                 group_curr++;
2515         }
2516
2517         MEM_freeN(stack);
2518
2519         /* reduce alloc to required size */
2520         group_index = MEM_reallocN(group_index, sizeof(*group_index) * group_curr);
2521         *r_group_index = group_index;
2522
2523         return group_curr;
2524 }
2525
2526 /* note, almost duplicate of BM_mesh_calc_face_groups, keep in sync */
2527 /**
2528  * Calculate isolated groups of edges with optional filtering.
2529  *
2530  * \param bm  the BMesh.
2531  * \param r_groups_array  Array of ints to fill in, length of bm->totedge
2532  *        (or when hflag_test is set, the number of flagged edges).
2533  * \param r_group_index  index, length pairs into \a r_groups_array, size of return value
2534  *        int pairs: (array_start, array_length).
2535  * \param filter_fn  Filter the edges or verts we step over (depends on \a htype_step)
2536  *        as to which types we deal with.
2537  * \param user_data  Optional user data for \a filter_fn, can be NULL.
2538  * \param hflag_test  Optional flag to test edges,
2539  *        use to exclude edges from the calculation, 0 for all edges.
2540  * \return The number of groups found.
2541  *
2542  * \note Unlike #BM_mesh_calc_face_groups there is no 'htype_step' argument,
2543  *       since we always walk over verts.
2544  */
2545 int BM_mesh_calc_edge_groups(
2546         BMesh *bm, int *r_groups_array, int (**r_group_index)[2],
2547         BMVertFilterFunc filter_fn, void *user_data,
2548         const char hflag_test)
2549 {
2550 #ifdef DEBUG
2551         int group_index_len = 1;
2552 #else
2553         int group_index_len = 32;
2554 #endif
2555
2556         int (*group_index)[2] = MEM_mallocN(sizeof(*group_index) * group_index_len, __func__);
2557
2558         int *group_array = r_groups_array;
2559         STACK_DECLARE(group_array);
2560
2561         int group_curr = 0;
2562
2563         unsigned int tot_edges = 0;
2564         unsigned int tot_touch = 0;
2565
2566         BMEdge **stack;
2567         STACK_DECLARE(stack);
2568
2569         BMIter iter;
2570         BMEdge *e;
2571         int i;
2572
2573         STACK_INIT(group_array, bm->totedge);
2574
2575         /* init the array */
2576         BM_ITER_MESH_INDEX (e, &iter, bm, BM_EDGES_OF_MESH, i) {
2577                 if ((hflag_test == 0) || BM_elem_flag_test(e, hflag_test)) {
2578                         tot_edges++;
2579                         BM_elem_flag_disable(e, BM_ELEM_TAG);
2580                 }
2581                 else {
2582                         /* never walk over tagged */
2583                         BM_elem_flag_enable(e, BM_ELEM_TAG);
2584                 }
2585
2586                 BM_elem_index_set(e, i); /* set_inline */
2587         }
2588         bm->elem_index_dirty &= ~BM_EDGE;
2589
2590         /* detect groups */
2591         stack = MEM_mallocN(sizeof(*stack) * tot_edges, __func__);
2592
2593         while (tot_touch != tot_edges) {
2594                 int *group_item;
2595                 bool ok = false;
2596
2597                 BLI_assert(tot_touch < tot_edges);
2598
2599                 STACK_INIT(stack, tot_edges);
2600
2601                 BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
2602                         if (BM_elem_flag_test(e, BM_ELEM_TAG) == false) {
2603                                 BM_elem_flag_enable(e, BM_ELEM_TAG);
2604                                 STACK_PUSH(stack, e);
2605                                 ok = true;
2606                                 break;
2607                         }
2608                 }
2609
2610                 BLI_assert(ok == true);
2611                 UNUSED_VARS_NDEBUG(ok);
2612
2613                 /* manage arrays */
2614                 if (group_index_len == group_curr) {
2615                         group_index_len *= 2;
2616                         group_index = MEM_reallocN(group_index, sizeof(*group_index) * group_index_len);
2617                 }
2618
2619                 group_item = group_index[group_curr];
2620                 group_item[0] = STACK_SIZE(group_array);
2621                 group_item[1] = 0;
2622
2623                 while ((e = STACK_POP(stack))) {
2624                         BMIter viter;
2625                         BMIter eiter;
2626                         BMVert *v;
2627
2628                         /* add edge */
2629                         STACK_PUSH(group_array, BM_elem_index_get(e));
2630                         tot_touch++;
2631                         group_item[1]++;
2632                         /* done */
2633
2634                         /* search for other edges */
2635                         BM_ITER_ELEM (v, &viter, e, BM_VERTS_OF_EDGE) {
2636                                 if ((filter_fn == NULL) || filter_fn(v, user_data)) {
2637                                         BMEdge *e_other;
2638                                         BM_ITER_ELEM (e_other, &eiter, v, BM_EDGES_OF_VERT) {
2639                                                 if (BM_elem_flag_test(e_other, BM_ELEM_TAG) == false) {
2640                                                         BM_elem_flag_enable(e_other, BM_ELEM_TAG);
2641                                                         STACK_PUSH(stack, e_other);
2642                                                 }
2643                                         }
2644                                 }
2645                         }
2646                 }
2647
2648                 group_curr++;
2649         }
2650
2651         MEM_freeN(stack);
2652
2653         /* reduce alloc to required size */
2654         group_index = MEM_reallocN(group_index, sizeof(*group_index) * group_curr);
2655         *r_group_index = group_index;
2656
2657         return group_curr;
2658 }
2659
2660 float bmesh_subd_falloff_calc(const int falloff, float val)
2661 {
2662         switch (falloff) {
2663                 case SUBD_FALLOFF_SMOOTH:
2664                         val = 3.0f * val * val - 2.0f * val * val * val;
2665                         break;
2666                 case SUBD_FALLOFF_SPHERE:
2667                         val = sqrtf(2.0f * val - val * val);
2668                         break;
2669                 case SUBD_FALLOFF_ROOT:
2670                         val = sqrtf(val);
2671                         break;
2672                 case SUBD_FALLOFF_SHARP:
2673                         val = val * val;
2674                         break;
2675                 case SUBD_FALLOFF_LIN:
2676                         break;
2677                 case SUBD_FALLOFF_INVSQUARE:
2678                         val = val * (2.0f - val);
2679                         break;
2680                 default:
2681                         BLI_assert(0);
2682                         break;
2683         }
2684
2685         return val;
2686 }