e7a93c6aad55097e70e9138571bc401d42db0165
[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  * Test if e1 shares any faces with e2
1220  */
1221 bool BM_edge_share_face_check(BMEdge *e1, BMEdge *e2)
1222 {
1223         BMLoop *l;
1224         BMFace *f;
1225
1226         if (e1->l && e2->l) {
1227                 l = e1->l;
1228                 do {
1229                         f = l->f;
1230                         if (BM_edge_in_face(e2, f)) {
1231                                 return true;
1232                         }
1233                         l = l->radial_next;
1234                 } while (l != e1->l);
1235         }
1236         return false;
1237 }
1238
1239 /**
1240  *      Test if e1 shares any quad faces with e2
1241  */
1242 bool BM_edge_share_quad_check(BMEdge *e1, BMEdge *e2)
1243 {
1244         BMLoop *l;
1245         BMFace *f;
1246
1247         if (e1->l && e2->l) {
1248                 l = e1->l;
1249                 do {
1250                         f = l->f;
1251                         if (f->len == 4) {
1252                                 if (BM_edge_in_face(e2, f)) {
1253                                         return true;
1254                                 }
1255                         }
1256                         l = l->radial_next;
1257                 } while (l != e1->l);
1258         }
1259         return false;
1260 }
1261
1262 /**
1263  *      Tests to see if e1 shares a vertex with e2
1264  */
1265 bool BM_edge_share_vert_check(BMEdge *e1, BMEdge *e2)
1266 {
1267         return (e1->v1 == e2->v1 ||
1268                 e1->v1 == e2->v2 ||
1269                 e1->v2 == e2->v1 ||
1270                 e1->v2 == e2->v2);
1271 }
1272
1273 /**
1274  *      Return the shared vertex between the two edges or NULL
1275  */
1276 BMVert *BM_edge_share_vert(BMEdge *e1, BMEdge *e2)
1277 {
1278         BLI_assert(e1 != e2);
1279         if (BM_vert_in_edge(e2, e1->v1)) {
1280                 return e1->v1;
1281         }
1282         else if (BM_vert_in_edge(e2, e1->v2)) {
1283                 return e1->v2;
1284         }
1285         else {
1286                 return NULL;
1287         }
1288 }
1289
1290 /**
1291  * \brief Return the Loop Shared by Edge and Vert
1292  *
1293  * Finds the loop used which uses \a  in face loop \a l
1294  *
1295  * \note this function takes a loop rather then an edge
1296  * so we can select the face that the loop should be from.
1297  */
1298 BMLoop *BM_edge_vert_share_loop(BMLoop *l, BMVert *v)
1299 {
1300         BLI_assert(BM_vert_in_edge(l->e, v));
1301         if (l->v == v) {
1302                 return l;
1303         }
1304         else {
1305                 return l->next;
1306         }
1307 }
1308
1309 /**
1310  * \brief Return the Loop Shared by Face and Vertex
1311  *
1312  * Finds the loop used which uses \a v in face loop \a l
1313  *
1314  * \note currently this just uses simple loop in future may be sped up
1315  * using radial vars
1316  */
1317 BMLoop *BM_face_vert_share_loop(BMFace *f, BMVert *v)
1318 {
1319         BMLoop *l_first;
1320         BMLoop *l_iter;
1321
1322         l_iter = l_first = BM_FACE_FIRST_LOOP(f);
1323         do {
1324                 if (l_iter->v == v) {
1325                         return l_iter;
1326                 }
1327         } while ((l_iter = l_iter->next) != l_first);
1328
1329         return NULL;
1330 }
1331
1332 /**
1333  * \brief Return the Loop Shared by Face and Edge
1334  *
1335  * Finds the loop used which uses \a e in face loop \a l
1336  *
1337  * \note currently this just uses simple loop in future may be sped up
1338  * using radial vars
1339  */
1340 BMLoop *BM_face_edge_share_loop(BMFace *f, BMEdge *e)
1341 {
1342         BMLoop *l_first;
1343         BMLoop *l_iter;
1344
1345         l_iter = l_first = e->l;
1346         do {
1347                 if (l_iter->f == f) {
1348                         return l_iter;
1349                 }
1350         } while ((l_iter = l_iter->radial_next) != l_first);
1351
1352         return NULL;
1353 }
1354
1355 /**
1356  * Returns the verts of an edge as used in a face
1357  * if used in a face at all, otherwise just assign as used in the edge.
1358  *
1359  * Useful to get a deterministic winding order when calling
1360  * BM_face_create_ngon() on an arbitrary array of verts,
1361  * though be sure to pick an edge which has a face.
1362  *
1363  * \note This is in fact quite a simple check, mainly include this function so the intent is more obvious.
1364  * We know these 2 verts will _always_ make up the loops edge
1365  */
1366 void BM_edge_ordered_verts_ex(
1367         const BMEdge *edge, BMVert **r_v1, BMVert **r_v2,
1368         const BMLoop *edge_loop)
1369 {
1370         BLI_assert(edge_loop->e == edge);
1371         (void)edge; /* quiet warning in release build */
1372         *r_v1 = edge_loop->v;
1373         *r_v2 = edge_loop->next->v;
1374 }
1375
1376 void BM_edge_ordered_verts(const BMEdge *edge, BMVert **r_v1, BMVert **r_v2)
1377 {
1378         BM_edge_ordered_verts_ex(edge, r_v1, r_v2, edge->l);
1379 }
1380
1381 /**
1382  * \return The previous loop, over \a eps_sq distance from \a l (or \a NULL if l_stop is reached).
1383  */
1384 BMLoop *BM_loop_find_prev_nodouble(BMLoop *l, BMLoop *l_stop, const float eps_sq)
1385 {
1386         BMLoop *l_step = l->prev;
1387
1388         BLI_assert(!ELEM(l_stop, NULL, l));
1389
1390         while (UNLIKELY(len_squared_v3v3(l->v->co, l_step->v->co) < eps_sq)) {
1391                 l_step = l_step->prev;
1392                 BLI_assert(l_step != l);
1393                 if (UNLIKELY(l_step == l_stop)) {
1394                         return NULL;
1395                 }
1396         }
1397
1398         return l_step;
1399 }
1400
1401 /**
1402  * \return The next loop, over \a eps_sq distance from \a l (or \a NULL if l_stop is reached).
1403  */
1404 BMLoop *BM_loop_find_next_nodouble(BMLoop *l, BMLoop *l_stop, const float eps_sq)
1405 {
1406         BMLoop *l_step = l->next;
1407
1408         BLI_assert(!ELEM(l_stop, NULL, l));
1409
1410         while (UNLIKELY(len_squared_v3v3(l->v->co, l_step->v->co) < eps_sq)) {
1411                 l_step = l_step->next;
1412                 BLI_assert(l_step != l);
1413                 if (UNLIKELY(l_step == l_stop)) {
1414                         return NULL;
1415                 }
1416         }
1417
1418         return l_step;
1419 }
1420
1421 /**
1422  * Check if the loop is convex or concave
1423  * (depends on face normal)
1424  */
1425 bool BM_loop_is_convex(const BMLoop *l)
1426 {
1427         float e_dir_prev[3];
1428         float e_dir_next[3];
1429         float l_no[3];
1430
1431         sub_v3_v3v3(e_dir_prev, l->prev->v->co, l->v->co);
1432         sub_v3_v3v3(e_dir_next, l->next->v->co, l->v->co);
1433         cross_v3_v3v3(l_no, e_dir_next, e_dir_prev);
1434         return dot_v3v3(l_no, l->f->no) > 0.0f;
1435 }
1436
1437 /**
1438  * Calculates the angle between the previous and next loops
1439  * (angle at this loops face corner).
1440  *
1441  * \return angle in radians
1442  */
1443 float BM_loop_calc_face_angle(const BMLoop *l)
1444 {
1445         return angle_v3v3v3(l->prev->v->co,
1446                             l->v->co,
1447                             l->next->v->co);
1448 }
1449
1450 /**
1451  * \brief BM_loop_calc_face_normal
1452  *
1453  * Calculate the normal at this loop corner or fallback to the face normal on straight lines.
1454  *
1455  * \param l The loop to calculate the normal at
1456  * \param r_normal Resulting normal
1457  */
1458 void BM_loop_calc_face_normal(const BMLoop *l, float r_normal[3])
1459 {
1460         if (normal_tri_v3(r_normal,
1461                           l->prev->v->co,
1462                           l->v->co,
1463                           l->next->v->co) != 0.0f)
1464         {
1465                 /* pass */
1466         }
1467         else {
1468                 copy_v3_v3(r_normal, l->f->no);
1469         }
1470 }
1471
1472 /**
1473  * \brief BM_loop_calc_face_direction
1474  *
1475  * Calculate the direction a loop is pointing.
1476  *
1477  * \param l The loop to calculate the direction at
1478  * \param r_dir Resulting direction
1479  */
1480 void BM_loop_calc_face_direction(const BMLoop *l, float r_dir[3])
1481 {
1482         float v_prev[3];
1483         float v_next[3];
1484
1485         sub_v3_v3v3(v_prev, l->v->co, l->prev->v->co);
1486         sub_v3_v3v3(v_next, l->next->v->co, l->v->co);
1487
1488         normalize_v3(v_prev);
1489         normalize_v3(v_next);
1490
1491         add_v3_v3v3(r_dir, v_prev, v_next);
1492         normalize_v3(r_dir);
1493 }
1494
1495 /**
1496  * \brief BM_loop_calc_face_tangent
1497  *
1498  * Calculate the tangent at this loop corner or fallback to the face normal on straight lines.
1499  * This vector always points inward into the face.
1500  *
1501  * \param l The loop to calculate the tangent at
1502  * \param r_tangent Resulting tangent
1503  */
1504 void BM_loop_calc_face_tangent(const BMLoop *l, float r_tangent[3])
1505 {
1506         float v_prev[3];
1507         float v_next[3];
1508         float dir[3];
1509
1510         sub_v3_v3v3(v_prev, l->prev->v->co, l->v->co);
1511         sub_v3_v3v3(v_next, l->v->co, l->next->v->co);
1512
1513         normalize_v3(v_prev);
1514         normalize_v3(v_next);
1515         add_v3_v3v3(dir, v_prev, v_next);
1516
1517         if (compare_v3v3(v_prev, v_next, FLT_EPSILON * 10.0f) == false) {
1518                 float nor[3]; /* for this purpose doesn't need to be normalized */
1519                 cross_v3_v3v3(nor, v_prev, v_next);
1520                 /* concave face check */
1521                 if (UNLIKELY(dot_v3v3(nor, l->f->no) < 0.0f)) {
1522                         negate_v3(nor);
1523                 }
1524                 cross_v3_v3v3(r_tangent, dir, nor);
1525         }
1526         else {
1527                 /* prev/next are the same - compare with face normal since we don't have one */
1528                 cross_v3_v3v3(r_tangent, dir, l->f->no);
1529         }
1530
1531         normalize_v3(r_tangent);
1532 }
1533
1534 /**
1535  * \brief BMESH EDGE/FACE ANGLE
1536  *
1537  *  Calculates the angle between two faces.
1538  *  Assumes the face normals are correct.
1539  *
1540  * \return angle in radians
1541  */
1542 float BM_edge_calc_face_angle_ex(const BMEdge *e, const float fallback)
1543 {
1544         if (BM_edge_is_manifold(e)) {
1545                 const BMLoop *l1 = e->l;
1546                 const BMLoop *l2 = e->l->radial_next;
1547                 return angle_normalized_v3v3(l1->f->no, l2->f->no);
1548         }
1549         else {
1550                 return fallback;
1551         }
1552 }
1553 float BM_edge_calc_face_angle(const BMEdge *e)
1554 {
1555         return BM_edge_calc_face_angle_ex(e, DEG2RADF(90.0f));
1556 }
1557
1558 /**
1559  * \brief BMESH EDGE/FACE ANGLE
1560  *
1561  *  Calculates the angle between two faces.
1562  *  Assumes the face normals are correct.
1563  *
1564  * \return angle in radians
1565  */
1566 float BM_edge_calc_face_angle_signed_ex(const BMEdge *e, const float fallback)
1567 {
1568         if (BM_edge_is_manifold(e)) {
1569                 BMLoop *l1 = e->l;
1570                 BMLoop *l2 = e->l->radial_next;
1571                 const float angle = angle_normalized_v3v3(l1->f->no, l2->f->no);
1572                 return BM_edge_is_convex(e) ? angle : -angle;
1573         }
1574         else {
1575                 return fallback;
1576         }
1577 }
1578 float BM_edge_calc_face_angle_signed(const BMEdge *e)
1579 {
1580         return BM_edge_calc_face_angle_signed_ex(e, DEG2RADF(90.0f));
1581 }
1582
1583 /**
1584  * \brief BMESH EDGE/FACE TANGENT
1585  *
1586  * Calculate the tangent at this loop corner or fallback to the face normal on straight lines.
1587  * This vector always points inward into the face.
1588  *
1589  * \brief BM_edge_calc_face_tangent
1590  * \param e
1591  * \param e_loop The loop to calculate the tangent at,
1592  * used to get the face and winding direction.
1593  * \param r_tangent The loop corner tangent to set
1594  */
1595
1596 void BM_edge_calc_face_tangent(const BMEdge *e, const BMLoop *e_loop, float r_tangent[3])
1597 {
1598         float tvec[3];
1599         BMVert *v1, *v2;
1600         BM_edge_ordered_verts_ex(e, &v1, &v2, e_loop);
1601
1602         sub_v3_v3v3(tvec, v1->co, v2->co); /* use for temp storage */
1603         /* note, we could average the tangents of both loops,
1604          * for non flat ngons it will give a better direction */
1605         cross_v3_v3v3(r_tangent, tvec, e_loop->f->no);
1606         normalize_v3(r_tangent);
1607 }
1608
1609 /**
1610  * \brief BMESH VERT/EDGE ANGLE
1611  *
1612  * Calculates the angle a verts 2 edges.
1613  *
1614  * \returns the angle in radians
1615  */
1616 float BM_vert_calc_edge_angle_ex(const BMVert *v, const float fallback)
1617 {
1618         BMEdge *e1, *e2;
1619
1620         /* saves BM_vert_edge_count(v) and and edge iterator,
1621          * get the edges and count them both at once */
1622
1623         if ((e1 = v->e) &&
1624             (e2 =  bmesh_disk_edge_next(e1, v)) &&
1625             /* make sure we come full circle and only have 2 connected edges */
1626             (e1 == bmesh_disk_edge_next(e2, v)))
1627         {
1628                 BMVert *v1 = BM_edge_other_vert(e1, v);
1629                 BMVert *v2 = BM_edge_other_vert(e2, v);
1630
1631                 return (float)M_PI - angle_v3v3v3(v1->co, v->co, v2->co);
1632         }
1633         else {
1634                 return fallback;
1635         }
1636 }
1637
1638 float BM_vert_calc_edge_angle(const BMVert *v)
1639 {
1640         return BM_vert_calc_edge_angle_ex(v, DEG2RADF(90.0f));
1641 }
1642
1643 /**
1644  * \note this isn't optimal to run on an array of verts,
1645  * see 'solidify_add_thickness' for a function which runs on an array.
1646  */
1647 float BM_vert_calc_shell_factor(const BMVert *v)
1648 {
1649         BMIter iter;
1650         BMLoop *l;
1651         float accum_shell = 0.0f;
1652         float accum_angle = 0.0f;
1653
1654         BM_ITER_ELEM (l, &iter, (BMVert *)v, BM_LOOPS_OF_VERT) {
1655                 const float face_angle = BM_loop_calc_face_angle(l);
1656                 accum_shell += shell_v3v3_normalized_to_dist(v->no, l->f->no) * face_angle;
1657                 accum_angle += face_angle;
1658         }
1659
1660         if (accum_angle != 0.0f) {
1661                 return accum_shell / accum_angle;
1662         }
1663         else {
1664                 return 1.0f;
1665         }
1666 }
1667 /* alternate version of #BM_vert_calc_shell_factor which only
1668  * uses 'hflag' faces, but falls back to all if none found. */
1669 float BM_vert_calc_shell_factor_ex(const BMVert *v, const float no[3], const char hflag)
1670 {
1671         BMIter iter;
1672         const BMLoop *l;
1673         float accum_shell = 0.0f;
1674         float accum_angle = 0.0f;
1675         int tot_sel = 0, tot = 0;
1676
1677         BM_ITER_ELEM (l, &iter, (BMVert *)v, BM_LOOPS_OF_VERT) {
1678                 if (BM_elem_flag_test(l->f, hflag)) {  /* <-- main difference to BM_vert_calc_shell_factor! */
1679                         const float face_angle = BM_loop_calc_face_angle(l);
1680                         accum_shell += shell_v3v3_normalized_to_dist(no, l->f->no) * face_angle;
1681                         accum_angle += face_angle;
1682                         tot_sel++;
1683                 }
1684                 tot++;
1685         }
1686
1687         if (accum_angle != 0.0f) {
1688                 return accum_shell / accum_angle;
1689         }
1690         else {
1691                 /* other main difference from BM_vert_calc_shell_factor! */
1692                 if (tot != 0 && tot_sel == 0) {
1693                         /* none selected, so use all */
1694                         return BM_vert_calc_shell_factor(v);
1695                 }
1696                 else {
1697                         return 1.0f;
1698                 }
1699         }
1700 }
1701
1702 /**
1703  * \note quite an obscure function.
1704  * used in bmesh operators that have a relative scale options,
1705  */
1706 float BM_vert_calc_mean_tagged_edge_length(const BMVert *v)
1707 {
1708         BMIter iter;
1709         BMEdge *e;
1710         int tot;
1711         float length = 0.0f;
1712
1713         BM_ITER_ELEM_INDEX (e, &iter, (BMVert *)v, BM_EDGES_OF_VERT, tot) {
1714                 const BMVert *v_other = BM_edge_other_vert(e, v);
1715                 if (BM_elem_flag_test(v_other, BM_ELEM_TAG)) {
1716                         length += BM_edge_calc_length(e);
1717                 }
1718         }
1719
1720         if (tot) {
1721                 return length / (float)tot;
1722         }
1723         else {
1724                 return 0.0f;
1725         }
1726 }
1727
1728
1729 /**
1730  * Returns the loop of the shortest edge in f.
1731  */
1732 BMLoop *BM_face_find_shortest_loop(BMFace *f)
1733 {
1734         BMLoop *shortest_loop = NULL;
1735         float shortest_len = FLT_MAX;
1736
1737         BMLoop *l_iter;
1738         BMLoop *l_first;
1739
1740         l_iter = l_first = BM_FACE_FIRST_LOOP(f);
1741
1742         do {
1743                 const float len_sq = len_squared_v3v3(l_iter->v->co, l_iter->next->v->co);
1744                 if (len_sq <= shortest_len) {
1745                         shortest_loop = l_iter;
1746                         shortest_len = len_sq;
1747                 }
1748         } while ((l_iter = l_iter->next) != l_first);
1749
1750         return shortest_loop;
1751 }
1752
1753 /**
1754  * Returns the loop of the longest edge in f.
1755  */
1756 BMLoop *BM_face_find_longest_loop(BMFace *f)
1757 {
1758         BMLoop *longest_loop = NULL;
1759         float len_max_sq = 0.0f;
1760
1761         BMLoop *l_iter;
1762         BMLoop *l_first;
1763
1764         l_iter = l_first = BM_FACE_FIRST_LOOP(f);
1765
1766         do {
1767                 const float len_sq = len_squared_v3v3(l_iter->v->co, l_iter->next->v->co);
1768                 if (len_sq >= len_max_sq) {
1769                         longest_loop = l_iter;
1770                         len_max_sq = len_sq;
1771                 }
1772         } while ((l_iter = l_iter->next) != l_first);
1773
1774         return longest_loop;
1775 }
1776
1777 /**
1778  * Returns the edge existing between \a v_a and \a v_b, or NULL if there isn't one.
1779  *
1780  * \note multiple edges may exist between any two vertices, and therefore
1781  * this function only returns the first one found.
1782  */
1783 #if 0
1784 BMEdge *BM_edge_exists(BMVert *v_a, BMVert *v_b)
1785 {
1786         BMIter iter;
1787         BMEdge *e;
1788
1789
1790         BLI_assert(v_a != v_b);
1791         BLI_assert(v_a->head.htype == BM_VERT && v_b->head.htype == BM_VERT);
1792
1793         BM_ITER_ELEM (e, &iter, v_a, BM_EDGES_OF_VERT) {
1794                 if (e->v1 == v_b || e->v2 == v_b)
1795                         return e;
1796         }
1797
1798         return NULL;
1799 }
1800 #else
1801 BMEdge *BM_edge_exists(BMVert *v_a, BMVert *v_b)
1802 {
1803         /* speedup by looping over both edges verts
1804          * where one vert may connect to many edges but not the other. */
1805
1806         BMEdge *e_a, *e_b;
1807
1808         BLI_assert(v_a != v_b);
1809         BLI_assert(v_a->head.htype == BM_VERT && v_b->head.htype == BM_VERT);
1810
1811         if ((e_a = v_a->e) && (e_b = v_b->e)) {
1812                 BMEdge *e_a_iter = e_a, *e_b_iter = e_b;
1813
1814                 do {
1815                         if (BM_vert_in_edge(e_a_iter, v_b)) {
1816                                 return e_a_iter;
1817                         }
1818                         if (BM_vert_in_edge(e_b_iter, v_a)) {
1819                                 return e_b_iter;
1820                         }
1821                 } while (((e_a_iter = bmesh_disk_edge_next(e_a_iter, v_a)) != e_a) &&
1822                          ((e_b_iter = bmesh_disk_edge_next(e_b_iter, v_b)) != e_b));
1823         }
1824
1825         return NULL;
1826 }
1827 #endif
1828
1829 /**
1830  * Returns an edge sharing the same vertices as this one.
1831  * This isn't an invalid state but tools should clean up these cases before
1832  * returning the mesh to the user.
1833  */
1834 BMEdge *BM_edge_find_double(BMEdge *e)
1835 {
1836         BMVert *v       = e->v1;
1837         BMVert *v_other = e->v2;
1838
1839         BMEdge *e_iter;
1840
1841         e_iter = e;
1842         while ((e_iter = bmesh_disk_edge_next(e_iter, v)) != e) {
1843                 if (UNLIKELY(BM_vert_in_edge(e_iter, v_other))) {
1844                         return e_iter;
1845                 }
1846         }
1847
1848         return NULL;
1849 }
1850
1851 /**
1852  * Given a set of vertices (varr), find out if
1853  * there is a face with exactly those vertices
1854  * (and only those vertices).
1855  *
1856  * \note there used to be a BM_face_exists_overlap function that checks for partial overlap.
1857  */
1858 bool BM_face_exists(BMVert **varr, int len, BMFace **r_existface)
1859 {
1860         if (varr[0]->e) {
1861                 BMEdge *e_iter, *e_first;
1862                 e_iter = e_first = varr[0]->e;
1863
1864                 /* would normally use BM_LOOPS_OF_VERT, but this runs so often,
1865                  * its faster to iterate on the data directly */
1866                 do {
1867                         if (e_iter->l) {
1868                                 BMLoop *l_iter_radial, *l_first_radial;
1869                                 l_iter_radial = l_first_radial = e_iter->l;
1870
1871                                 do {
1872                                         if ((l_iter_radial->v == varr[0]) &&
1873                                             (l_iter_radial->f->len == len))
1874                                         {
1875                                                 /* the fist 2 verts match, now check the remaining (len - 2) faces do too
1876                                                  * winding isn't known, so check in both directions */
1877                                                 int i_walk = 2;
1878
1879                                                 if (l_iter_radial->next->v == varr[1]) {
1880                                                         BMLoop *l_walk = l_iter_radial->next->next;
1881                                                         do {
1882                                                                 if (l_walk->v != varr[i_walk]) {
1883                                                                         break;
1884                                                                 }
1885                                                         } while ((l_walk = l_walk->next), ++i_walk != len);
1886                                                 }
1887                                                 else if (l_iter_radial->prev->v == varr[1]) {
1888                                                         BMLoop *l_walk = l_iter_radial->prev->prev;
1889                                                         do {
1890                                                                 if (l_walk->v != varr[i_walk]) {
1891                                                                         break;
1892                                                                 }
1893                                                         } while ((l_walk = l_walk->prev), ++i_walk != len);
1894                                                 }
1895
1896                                                 if (i_walk == len) {
1897                                                         if (r_existface) {
1898                                                                 *r_existface = l_iter_radial->f;
1899                                                         }
1900                                                         return true;
1901                                                 }
1902                                         }
1903                                 } while ((l_iter_radial = l_iter_radial->radial_next) != l_first_radial);
1904
1905                         }
1906                 } while ((e_iter = BM_DISK_EDGE_NEXT(e_iter, varr[0])) != e_first);
1907         }
1908
1909         if (r_existface) {
1910                 *r_existface = NULL;
1911         }
1912         return false;
1913 }
1914
1915
1916 /**
1917  * Given a set of vertices and edges (\a varr, \a earr), find out if
1918  * all those vertices are filled in by existing faces that _only_ use those vertices.
1919  *
1920  * This is for use in cases where creating a face is possible but would result in
1921  * many overlapping faces.
1922  *
1923  * An example of how this is used: when 2 tri's are selected that share an edge,
1924  * pressing Fkey would make a new overlapping quad (without a check like this)
1925  *
1926  * \a earr and \a varr can be in any order, however they _must_ form a closed loop.
1927  */
1928 bool BM_face_exists_multi(BMVert **varr, BMEdge **earr, int len)
1929 {
1930         BMFace *f;
1931         BMEdge *e;
1932         BMVert *v;
1933         bool ok;
1934         int tot_tag;
1935
1936         BMIter fiter;
1937         BMIter viter;
1938
1939         int i;
1940
1941         for (i = 0; i < len; i++) {
1942                 /* save some time by looping over edge faces rather then vert faces
1943                  * will still loop over some faces twice but not as many */
1944                 BM_ITER_ELEM (f, &fiter, earr[i], BM_FACES_OF_EDGE) {
1945                         BM_elem_flag_disable(f, BM_ELEM_INTERNAL_TAG);
1946                         BM_ITER_ELEM (v, &viter, f, BM_VERTS_OF_FACE) {
1947                                 BM_elem_flag_disable(v, BM_ELEM_INTERNAL_TAG);
1948                         }
1949                 }
1950
1951                 /* clear all edge tags */
1952                 BM_ITER_ELEM (e, &fiter, varr[i], BM_EDGES_OF_VERT) {
1953                         BM_elem_flag_disable(e, BM_ELEM_INTERNAL_TAG);
1954                 }
1955         }
1956
1957         /* now tag all verts and edges in the boundary array as true so
1958          * we can know if a face-vert is from our array */
1959         for (i = 0; i < len; i++) {
1960                 BM_elem_flag_enable(varr[i], BM_ELEM_INTERNAL_TAG);
1961                 BM_elem_flag_enable(earr[i], BM_ELEM_INTERNAL_TAG);
1962         }
1963
1964
1965         /* so! boundary is tagged, everything else cleared */
1966
1967
1968         /* 1) tag all faces connected to edges - if all their verts are boundary */
1969         tot_tag = 0;
1970         for (i = 0; i < len; i++) {
1971                 BM_ITER_ELEM (f, &fiter, earr[i], BM_FACES_OF_EDGE) {
1972                         if (!BM_elem_flag_test(f, BM_ELEM_INTERNAL_TAG)) {
1973                                 ok = true;
1974                                 BM_ITER_ELEM (v, &viter, f, BM_VERTS_OF_FACE) {
1975                                         if (!BM_elem_flag_test(v, BM_ELEM_INTERNAL_TAG)) {
1976                                                 ok = false;
1977                                                 break;
1978                                         }
1979                                 }
1980
1981                                 if (ok) {
1982                                         /* we only use boundary verts */
1983                                         BM_elem_flag_enable(f, BM_ELEM_INTERNAL_TAG);
1984                                         tot_tag++;
1985                                 }
1986                         }
1987                         else {
1988                                 /* we already found! */
1989                         }
1990                 }
1991         }
1992
1993         if (tot_tag == 0) {
1994                 /* no faces use only boundary verts, quit early */
1995                 return false;
1996         }
1997
1998         /* 2) loop over non-boundary edges that use boundary verts,
1999          *    check each have 2 tagges faces connected (faces that only use 'varr' verts) */
2000         ok = true;
2001         for (i = 0; i < len; i++) {
2002                 BM_ITER_ELEM (e, &fiter, varr[i], BM_EDGES_OF_VERT) {
2003
2004                         if (/* non-boundary edge */
2005                             BM_elem_flag_test(e, BM_ELEM_INTERNAL_TAG) == false &&
2006                             /* ...using boundary verts */
2007                             BM_elem_flag_test(e->v1, BM_ELEM_INTERNAL_TAG) &&
2008                             BM_elem_flag_test(e->v2, BM_ELEM_INTERNAL_TAG))
2009                         {
2010                                 int tot_face_tag = 0;
2011                                 BM_ITER_ELEM (f, &fiter, e, BM_FACES_OF_EDGE) {
2012                                         if (BM_elem_flag_test(f, BM_ELEM_INTERNAL_TAG)) {
2013                                                 tot_face_tag++;
2014                                         }
2015                                 }
2016
2017                                 if (tot_face_tag != 2) {
2018                                         ok = false;
2019                                         break;
2020                                 }
2021
2022                         }
2023                 }
2024
2025                 if (ok == false) {
2026                         break;
2027                 }
2028         }
2029
2030         return ok;
2031 }
2032
2033 /* same as 'BM_face_exists_multi' but built vert array from edges */
2034 bool BM_face_exists_multi_edge(BMEdge **earr, int len)
2035 {
2036         BMVert **varr = BLI_array_alloca(varr, len);
2037
2038         bool ok;
2039         int i, i_next;
2040
2041         /* first check if verts have edges, if not we can bail out early */
2042         ok = true;
2043         for (i = len - 1, i_next = 0; i_next < len; (i = i_next++)) {
2044                 if (!(varr[i] = BM_edge_share_vert(earr[i], earr[i_next]))) {
2045                         ok = false;
2046                         break;
2047                 }
2048         }
2049
2050         if (ok == false) {
2051                 BMESH_ASSERT(0);
2052                 return false;
2053         }
2054
2055         ok = BM_face_exists_multi(varr, earr, len);
2056
2057         return ok;
2058 }
2059
2060
2061 /**
2062  * Given a set of vertices (varr), find out if
2063  * all those vertices overlap an existing face.
2064  *
2065  * \note The face may contain other verts \b not in \a varr.
2066  *
2067  * \note Its possible there are more than one overlapping faces,
2068  * in this case the first one found will be assigned to \a r_f_overlap.
2069  *
2070  * \param varr  Array of unordered verts.
2071  * \param len  \a varr array length.
2072  * \param r_f_overlap  The overlapping face to return.
2073  * \return Success
2074  */
2075
2076 bool BM_face_exists_overlap(BMVert **varr, const int len, BMFace **r_f_overlap)
2077 {
2078         BMIter viter;
2079         BMFace *f;
2080         int i;
2081         bool is_overlap = false;
2082         LinkNode *f_lnk = NULL;
2083
2084         if (r_f_overlap) {
2085                 *r_f_overlap = NULL;
2086         }
2087
2088 #ifdef DEBUG
2089         /* check flag isn't already set */
2090         for (i = 0; i < len; i++) {
2091                 BM_ITER_ELEM (f, &viter, varr[i], BM_FACES_OF_VERT) {
2092                         BLI_assert(BM_ELEM_API_FLAG_TEST(f, _FLAG_OVERLAP) == 0);
2093                 }
2094         }
2095 #endif
2096
2097         for (i = 0; i < len; i++) {
2098                 BM_ITER_ELEM (f, &viter, varr[i], BM_FACES_OF_VERT) {
2099                         if (BM_ELEM_API_FLAG_TEST(f, _FLAG_OVERLAP) == 0) {
2100                                 if (len <= BM_verts_in_face_count(varr, len, f)) {
2101                                         if (r_f_overlap)
2102                                                 *r_f_overlap = f;
2103
2104                                         is_overlap = true;
2105                                         break;
2106                                 }
2107
2108                                 BM_ELEM_API_FLAG_ENABLE(f, _FLAG_OVERLAP);
2109                                 BLI_linklist_prepend_alloca(&f_lnk, f);
2110                         }
2111                 }
2112         }
2113
2114         for (; f_lnk; f_lnk = f_lnk->next) {
2115                 BM_ELEM_API_FLAG_DISABLE((BMFace *)f_lnk->link, _FLAG_OVERLAP);
2116         }
2117
2118         return is_overlap;
2119 }
2120
2121 /**
2122  * Given a set of vertices (varr), find out if
2123  * there is a face that uses vertices only from this list
2124  * (that the face is a subset or made from the vertices given).
2125  *
2126  * \param varr  Array of unordered verts.
2127  * \param len  varr array length.
2128  */
2129 bool BM_face_exists_overlap_subset(BMVert **varr, const int len)
2130 {
2131         BMIter viter;
2132         BMFace *f;
2133         int i;
2134         bool is_init = false;
2135         bool is_overlap = false;
2136         LinkNode *f_lnk = NULL;
2137
2138 #ifdef DEBUG
2139         /* check flag isn't already set */
2140         for (i = 0; i < len; i++) {
2141                 BLI_assert(BM_ELEM_API_FLAG_TEST(varr[i], _FLAG_OVERLAP) == 0);
2142                 BM_ITER_ELEM (f, &viter, varr[i], BM_FACES_OF_VERT) {
2143                         BLI_assert(BM_ELEM_API_FLAG_TEST(f, _FLAG_OVERLAP) == 0);
2144                 }
2145         }
2146 #endif
2147
2148         for (i = 0; i < len; i++) {
2149                 BM_ITER_ELEM (f, &viter, varr[i], BM_FACES_OF_VERT) {
2150                         if ((f->len <= len) && (BM_ELEM_API_FLAG_TEST(f, _FLAG_OVERLAP) == 0)) {
2151                                 /* check if all vers in this face are flagged*/
2152                                 BMLoop *l_iter, *l_first;
2153
2154                                 if (is_init == false) {
2155                                         is_init = true;
2156                                         for (i = 0; i < len; i++) {
2157                                                 BM_ELEM_API_FLAG_ENABLE(varr[i], _FLAG_OVERLAP);
2158                                         }
2159                                 }
2160
2161                                 l_iter = l_first = BM_FACE_FIRST_LOOP(f);
2162                                 is_overlap = true;
2163                                 do {
2164                                         if (BM_ELEM_API_FLAG_TEST(l_iter->v, _FLAG_OVERLAP) == 0) {
2165                                                 is_overlap = false;
2166                                                 break;
2167                                         }
2168                                 } while ((l_iter = l_iter->next) != l_first);
2169
2170                                 if (is_overlap) {
2171                                         break;
2172                                 }
2173
2174                                 BM_ELEM_API_FLAG_ENABLE(f, _FLAG_OVERLAP);
2175                                 BLI_linklist_prepend_alloca(&f_lnk, f);
2176                         }
2177                 }
2178         }
2179
2180         if (is_init == true) {
2181                 for (i = 0; i < len; i++) {
2182                         BM_ELEM_API_FLAG_DISABLE(varr[i], _FLAG_OVERLAP);
2183                 }
2184         }
2185
2186         for (; f_lnk; f_lnk = f_lnk->next) {
2187                 BM_ELEM_API_FLAG_DISABLE((BMFace *)f_lnk->link, _FLAG_OVERLAP);
2188         }
2189
2190         return is_overlap;
2191 }
2192
2193 bool BM_vert_is_all_edge_flag_test(const BMVert *v, const char hflag, const bool respect_hide)
2194 {
2195         if (v->e) {
2196                 BMEdge *e_other;
2197                 BMIter eiter;
2198
2199                 BM_ITER_ELEM (e_other, &eiter, (BMVert *)v, BM_EDGES_OF_VERT) {
2200                         if (!respect_hide || !BM_elem_flag_test(e_other, BM_ELEM_HIDDEN)) {
2201                                 if (!BM_elem_flag_test(e_other, hflag)) {
2202                                         return false;
2203                                 }
2204                         }
2205                 }
2206         }
2207
2208         return true;
2209 }
2210
2211 bool BM_vert_is_all_face_flag_test(const BMVert *v, const char hflag, const bool respect_hide)
2212 {
2213         if (v->e) {
2214                 BMEdge *f_other;
2215                 BMIter fiter;
2216
2217                 BM_ITER_ELEM (f_other, &fiter, (BMVert *)v, BM_FACES_OF_VERT) {
2218                         if (!respect_hide || !BM_elem_flag_test(f_other, BM_ELEM_HIDDEN)) {
2219                                 if (!BM_elem_flag_test(f_other, hflag)) {
2220                                         return false;
2221                                 }
2222                         }
2223                 }
2224         }
2225
2226         return true;
2227 }
2228
2229
2230 bool BM_edge_is_all_face_flag_test(const BMEdge *e, const char hflag, const bool respect_hide)
2231 {
2232         if (e->l) {
2233                 BMLoop *l_iter, *l_first;
2234
2235                 l_iter = l_first = e->l;
2236                 do {
2237                         if (!respect_hide || !BM_elem_flag_test(l_iter->f, BM_ELEM_HIDDEN)) {
2238                                 if (!BM_elem_flag_test(l_iter->f, hflag)) {
2239                                         return false;
2240                                 }
2241                         }
2242                 } while ((l_iter = l_iter->radial_next) != l_first);
2243         }
2244
2245         return true;
2246 }
2247
2248 /* convenience functions for checking flags */
2249 bool BM_edge_is_any_vert_flag_test(const BMEdge *e, const char hflag)
2250 {
2251         return (BM_elem_flag_test(e->v1, hflag) ||
2252                 BM_elem_flag_test(e->v2, hflag));
2253 }
2254
2255 bool BM_face_is_any_vert_flag_test(const BMFace *f, const char hflag)
2256 {
2257         BMLoop *l_iter;
2258         BMLoop *l_first;
2259
2260         l_iter = l_first = BM_FACE_FIRST_LOOP(f);
2261         do {
2262                 if (BM_elem_flag_test(l_iter->v, hflag)) {
2263                         return true;
2264                 }
2265         } while ((l_iter = l_iter->next) != l_first);
2266         return false;
2267 }
2268
2269 bool BM_face_is_any_edge_flag_test(const BMFace *f, const char hflag)
2270 {
2271         BMLoop *l_iter;
2272         BMLoop *l_first;
2273
2274         l_iter = l_first = BM_FACE_FIRST_LOOP(f);
2275         do {
2276                 if (BM_elem_flag_test(l_iter->e, hflag)) {
2277                         return true;
2278                 }
2279         } while ((l_iter = l_iter->next) != l_first);
2280         return false;
2281 }
2282
2283 /**
2284  * Use within assert's to check normals are valid.
2285  */
2286 bool BM_face_is_normal_valid(const BMFace *f)
2287 {
2288         const float eps = 0.0001f;
2289         float no[3];
2290
2291         BM_face_calc_normal(f, no);
2292         return len_squared_v3v3(no, f->no) < (eps * eps);
2293 }
2294
2295 static void bm_mesh_calc_volume_face(const BMFace *f, float *r_vol)
2296 {
2297         const int tottri = f->len - 2;
2298         BMLoop **loops = BLI_array_alloca(loops, f->len);
2299         unsigned int (*index)[3] = BLI_array_alloca(index, tottri);
2300         int j;
2301
2302         BM_face_calc_tessellation(f, false, loops, index);
2303
2304         for (j = 0; j < tottri; j++) {
2305                 const float *p1 = loops[index[j][0]]->v->co;
2306                 const float *p2 = loops[index[j][1]]->v->co;
2307                 const float *p3 = loops[index[j][2]]->v->co;
2308
2309                 /* co1.dot(co2.cross(co3)) / 6.0 */
2310                 float cross[3];
2311                 cross_v3_v3v3(cross, p2, p3);
2312                 *r_vol += (1.0f / 6.0f) * dot_v3v3(p1, cross);
2313         }
2314 }
2315 float BM_mesh_calc_volume(BMesh *bm, bool is_signed)
2316 {
2317         /* warning, calls own tessellation function, may be slow */
2318         float vol = 0.0f;
2319         BMFace *f;
2320         BMIter fiter;
2321
2322         BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
2323                 bm_mesh_calc_volume_face(f, &vol);
2324         }
2325
2326         if (is_signed == false) {
2327                 vol = fabsf(vol);
2328         }
2329
2330         return vol;
2331 }
2332
2333 /* note, almost duplicate of BM_mesh_calc_edge_groups, keep in sync */
2334 /**
2335  * Calculate isolated groups of faces with optional filtering.
2336  *
2337  * \param bm  the BMesh.
2338  * \param r_groups_array  Array of ints to fill in, length of bm->totface
2339  *        (or when hflag_test is set, the number of flagged faces).
2340  * \param r_group_index  index, length pairs into \a r_groups_array, size of return value
2341  *        int pairs: (array_start, array_length).
2342  * \param filter_fn  Filter the edge-loops or vert-loops we step over (depends on \a htype_step).
2343  * \param user_data  Optional user data for \a filter_fn, can be NULL.
2344  * \param hflag_test  Optional flag to test faces,
2345  *        use to exclude faces from the calculation, 0 for all faces.
2346  * \param htype_step  BM_VERT to walk over face-verts, BM_EDGE to walk over faces edges
2347  *        (having both set is supported too).
2348  * \return The number of groups found.
2349  */
2350 int BM_mesh_calc_face_groups(
2351         BMesh *bm, int *r_groups_array, int (**r_group_index)[2],
2352         BMLoopFilterFunc filter_fn, void *user_data,
2353         const char hflag_test, const char htype_step)
2354 {
2355 #ifdef DEBUG
2356         int group_index_len = 1;
2357 #else
2358         int group_index_len = 32;
2359 #endif
2360
2361         int (*group_index)[2] = MEM_mallocN(sizeof(*group_index) * group_index_len, __func__);
2362
2363         int *group_array = r_groups_array;
2364         STACK_DECLARE(group_array);
2365
2366         int group_curr = 0;
2367
2368         unsigned int tot_faces = 0;
2369         unsigned int tot_touch = 0;
2370
2371         BMFace **stack;
2372         STACK_DECLARE(stack);
2373
2374         BMIter iter;
2375         BMFace *f;
2376         int i;
2377
2378         STACK_INIT(group_array, bm->totface);
2379
2380         BLI_assert(((htype_step & ~(BM_VERT | BM_EDGE)) == 0) && (htype_step != 0));
2381
2382         /* init the array */
2383         BM_ITER_MESH_INDEX (f, &iter, bm, BM_FACES_OF_MESH, i) {
2384                 if ((hflag_test == 0) || BM_elem_flag_test(f, hflag_test)) {
2385                         tot_faces++;
2386                         BM_elem_flag_disable(f, BM_ELEM_TAG);
2387                 }
2388                 else {
2389                         /* never walk over tagged */
2390                         BM_elem_flag_enable(f, BM_ELEM_TAG);
2391                 }
2392
2393                 BM_elem_index_set(f, i); /* set_inline */
2394         }
2395         bm->elem_index_dirty &= ~BM_FACE;
2396
2397         /* detect groups */
2398         stack = MEM_mallocN(sizeof(*stack) * tot_faces, __func__);
2399
2400         while (tot_touch != tot_faces) {
2401                 int *group_item;
2402                 bool ok = false;
2403
2404                 BLI_assert(tot_touch < tot_faces);
2405
2406                 STACK_INIT(stack, tot_faces);
2407
2408                 BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
2409                         if (BM_elem_flag_test(f, BM_ELEM_TAG) == false) {
2410                                 BM_elem_flag_enable(f, BM_ELEM_TAG);
2411                                 STACK_PUSH(stack, f);
2412                                 ok = true;
2413                                 break;
2414                         }
2415                 }
2416
2417                 BLI_assert(ok == true);
2418                 UNUSED_VARS_NDEBUG(ok);
2419
2420                 /* manage arrays */
2421                 if (group_index_len == group_curr) {
2422                         group_index_len *= 2;
2423                         group_index = MEM_reallocN(group_index, sizeof(*group_index) * group_index_len);
2424                 }
2425
2426                 group_item = group_index[group_curr];
2427                 group_item[0] = STACK_SIZE(group_array);
2428                 group_item[1] = 0;
2429
2430                 while ((f = STACK_POP(stack))) {
2431                         BMLoop *l_iter, *l_first;
2432
2433                         /* add face */
2434                         STACK_PUSH(group_array, BM_elem_index_get(f));
2435                         tot_touch++;
2436                         group_item[1]++;
2437                         /* done */
2438
2439                         if (htype_step & BM_EDGE) {
2440                                 /* search for other faces */
2441                                 l_iter = l_first = BM_FACE_FIRST_LOOP(f);
2442                                 do {
2443                                         BMLoop *l_radial_iter = l_iter->radial_next;
2444                                         if ((l_radial_iter != l_iter) &&
2445                                             ((filter_fn == NULL) || filter_fn(l_iter, user_data)))
2446                                         {
2447                                                 do {
2448                                                         BMFace *f_other = l_radial_iter->f;
2449                                                         if (BM_elem_flag_test(f_other, BM_ELEM_TAG) == false) {
2450                                                                 BM_elem_flag_enable(f_other, BM_ELEM_TAG);
2451                                                                 STACK_PUSH(stack, f_other);
2452                                                         }
2453                                                 } while ((l_radial_iter = l_radial_iter->radial_next) != l_iter);
2454                                         }
2455                                 } while ((l_iter = l_iter->next) != l_first);
2456                         }
2457
2458                         if (htype_step & BM_VERT) {
2459                                 BMIter liter;
2460                                 /* search for other faces */
2461                                 l_iter = l_first = BM_FACE_FIRST_LOOP(f);
2462                                 do {
2463                                         if ((filter_fn == NULL) || filter_fn(l_iter, user_data)) {
2464                                                 BMLoop *l_other;
2465                                                 BM_ITER_ELEM (l_other, &liter, l_iter, BM_LOOPS_OF_LOOP) {
2466                                                         BMFace *f_other = l_other->f;
2467                                                         if (BM_elem_flag_test(f_other, BM_ELEM_TAG) == false) {
2468                                                                 BM_elem_flag_enable(f_other, BM_ELEM_TAG);
2469                                                                 STACK_PUSH(stack, f_other);
2470                                                         }
2471                                                 }
2472                                         }
2473                                 } while ((l_iter = l_iter->next) != l_first);
2474                         }
2475                 }
2476
2477                 group_curr++;
2478         }
2479
2480         MEM_freeN(stack);
2481
2482         /* reduce alloc to required size */
2483         group_index = MEM_reallocN(group_index, sizeof(*group_index) * group_curr);
2484         *r_group_index = group_index;
2485
2486         return group_curr;
2487 }
2488
2489 /* note, almost duplicate of BM_mesh_calc_face_groups, keep in sync */
2490 /**
2491  * Calculate isolated groups of edges with optional filtering.
2492  *
2493  * \param bm  the BMesh.
2494  * \param r_groups_array  Array of ints to fill in, length of bm->totedge
2495  *        (or when hflag_test is set, the number of flagged edges).
2496  * \param r_group_index  index, length pairs into \a r_groups_array, size of return value
2497  *        int pairs: (array_start, array_length).
2498  * \param filter_fn  Filter the edges or verts we step over (depends on \a htype_step)
2499  *        as to which types we deal with.
2500  * \param user_data  Optional user data for \a filter_fn, can be NULL.
2501  * \param hflag_test  Optional flag to test edges,
2502  *        use to exclude edges from the calculation, 0 for all edges.
2503  * \return The number of groups found.
2504  *
2505  * \note Unlike #BM_mesh_calc_face_groups there is no 'htype_step' argument,
2506  *       since we always walk over verts.
2507  */
2508 int BM_mesh_calc_edge_groups(
2509         BMesh *bm, int *r_groups_array, int (**r_group_index)[2],
2510         BMVertFilterFunc filter_fn, void *user_data,
2511         const char hflag_test)
2512 {
2513 #ifdef DEBUG
2514         int group_index_len = 1;
2515 #else
2516         int group_index_len = 32;
2517 #endif
2518
2519         int (*group_index)[2] = MEM_mallocN(sizeof(*group_index) * group_index_len, __func__);
2520
2521         int *group_array = r_groups_array;
2522         STACK_DECLARE(group_array);
2523
2524         int group_curr = 0;
2525
2526         unsigned int tot_edges = 0;
2527         unsigned int tot_touch = 0;
2528
2529         BMEdge **stack;
2530         STACK_DECLARE(stack);
2531
2532         BMIter iter;
2533         BMEdge *e;
2534         int i;
2535
2536         STACK_INIT(group_array, bm->totedge);
2537
2538         /* init the array */
2539         BM_ITER_MESH_INDEX (e, &iter, bm, BM_EDGES_OF_MESH, i) {
2540                 if ((hflag_test == 0) || BM_elem_flag_test(e, hflag_test)) {
2541                         tot_edges++;
2542                         BM_elem_flag_disable(e, BM_ELEM_TAG);
2543                 }
2544                 else {
2545                         /* never walk over tagged */
2546                         BM_elem_flag_enable(e, BM_ELEM_TAG);
2547                 }
2548
2549                 BM_elem_index_set(e, i); /* set_inline */
2550         }
2551         bm->elem_index_dirty &= ~BM_EDGE;
2552
2553         /* detect groups */
2554         stack = MEM_mallocN(sizeof(*stack) * tot_edges, __func__);
2555
2556         while (tot_touch != tot_edges) {
2557                 int *group_item;
2558                 bool ok = false;
2559
2560                 BLI_assert(tot_touch < tot_edges);
2561
2562                 STACK_INIT(stack, tot_edges);
2563
2564                 BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
2565                         if (BM_elem_flag_test(e, BM_ELEM_TAG) == false) {
2566                                 BM_elem_flag_enable(e, BM_ELEM_TAG);
2567                                 STACK_PUSH(stack, e);
2568                                 ok = true;
2569                                 break;
2570                         }
2571                 }
2572
2573                 BLI_assert(ok == true);
2574                 UNUSED_VARS_NDEBUG(ok);
2575
2576                 /* manage arrays */
2577                 if (group_index_len == group_curr) {
2578                         group_index_len *= 2;
2579                         group_index = MEM_reallocN(group_index, sizeof(*group_index) * group_index_len);
2580                 }
2581
2582                 group_item = group_index[group_curr];
2583                 group_item[0] = STACK_SIZE(group_array);
2584                 group_item[1] = 0;
2585
2586                 while ((e = STACK_POP(stack))) {
2587                         BMIter viter;
2588                         BMIter eiter;
2589                         BMVert *v;
2590
2591                         /* add edge */
2592                         STACK_PUSH(group_array, BM_elem_index_get(e));
2593                         tot_touch++;
2594                         group_item[1]++;
2595                         /* done */
2596
2597                         /* search for other edges */
2598                         BM_ITER_ELEM (v, &viter, e, BM_VERTS_OF_EDGE) {
2599                                 if ((filter_fn == NULL) || filter_fn(v, user_data)) {
2600                                         BMEdge *e_other;
2601                                         BM_ITER_ELEM (e_other, &eiter, v, BM_EDGES_OF_VERT) {
2602                                                 if (BM_elem_flag_test(e_other, BM_ELEM_TAG) == false) {
2603                                                         BM_elem_flag_enable(e_other, BM_ELEM_TAG);
2604                                                         STACK_PUSH(stack, e_other);
2605                                                 }
2606                                         }
2607                                 }
2608                         }
2609                 }
2610
2611                 group_curr++;
2612         }
2613
2614         MEM_freeN(stack);
2615
2616         /* reduce alloc to required size */
2617         group_index = MEM_reallocN(group_index, sizeof(*group_index) * group_curr);
2618         *r_group_index = group_index;
2619
2620         return group_curr;
2621 }
2622
2623 float bmesh_subd_falloff_calc(const int falloff, float val)
2624 {
2625         switch (falloff) {
2626                 case SUBD_FALLOFF_SMOOTH:
2627                         val = 3.0f * val * val - 2.0f * val * val * val;
2628                         break;
2629                 case SUBD_FALLOFF_SPHERE:
2630                         val = sqrtf(2.0f * val - val * val);
2631                         break;
2632                 case SUBD_FALLOFF_ROOT:
2633                         val = sqrtf(val);
2634                         break;
2635                 case SUBD_FALLOFF_SHARP:
2636                         val = val * val;
2637                         break;
2638                 case SUBD_FALLOFF_LIN:
2639                         break;
2640                 case SUBD_FALLOFF_INVSQUARE:
2641                         val = val * (2.0f - val);
2642                         break;
2643                 default:
2644                         BLI_assert(0);
2645                         break;
2646         }
2647
2648         return val;
2649 }