Fix T65330: Blender crash when double click on face
[blender.git] / source / blender / editors / mesh / editmesh_select.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2004 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup edmesh
22  */
23
24 #include "MEM_guardedalloc.h"
25
26 #include "BLI_bitmap.h"
27 #include "BLI_bitmap_draw_2d.h"
28 #include "BLI_listbase.h"
29 #include "BLI_linklist.h"
30 #include "BLI_linklist_stack.h"
31 #include "BLI_math.h"
32 #include "BLI_math_bits.h"
33 #include "BLI_rand.h"
34 #include "BLI_array.h"
35
36 #include "BKE_context.h"
37 #include "BKE_report.h"
38 #include "BKE_paint.h"
39 #include "BKE_editmesh.h"
40 #include "BKE_layer.h"
41
42 #include "IMB_imbuf_types.h"
43 #include "IMB_imbuf.h"
44
45 #include "WM_api.h"
46 #include "WM_types.h"
47
48 #include "RNA_access.h"
49 #include "RNA_define.h"
50 #include "RNA_enum_types.h"
51
52 #include "ED_object.h"
53 #include "ED_mesh.h"
54 #include "ED_screen.h"
55 #include "ED_transform.h"
56 #include "ED_select_buffer_utils.h"
57 #include "ED_select_utils.h"
58 #include "ED_view3d.h"
59
60 #include "DNA_mesh_types.h"
61 #include "DNA_meshdata_types.h"
62 #include "DNA_object_types.h"
63
64 #include "UI_resources.h"
65
66 #include "bmesh_tools.h"
67
68 #include "DEG_depsgraph.h"
69 #include "DEG_depsgraph_query.h"
70
71 #include "DRW_engine.h"
72
73 #include "mesh_intern.h" /* own include */
74
75 /* use bmesh operator flags for a few operators */
76 #define BMO_ELE_TAG 1
77
78 /* -------------------------------------------------------------------- */
79 /** \name Select Mirror
80  * \{ */
81
82 void EDBM_select_mirrored(
83     BMEditMesh *em, const int axis, const bool extend, int *r_totmirr, int *r_totfail)
84 {
85   Mesh *me = (Mesh *)em->ob->data;
86   BMesh *bm = em->bm;
87   BMIter iter;
88   int totmirr = 0;
89   int totfail = 0;
90   bool use_topology = (me && (me->editflag & ME_EDIT_MIRROR_TOPO));
91
92   *r_totmirr = *r_totfail = 0;
93
94   /* select -> tag */
95   if (bm->selectmode & SCE_SELECT_VERTEX) {
96     BMVert *v;
97     BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
98       BM_elem_flag_set(v, BM_ELEM_TAG, BM_elem_flag_test(v, BM_ELEM_SELECT));
99     }
100   }
101   else if (em->selectmode & SCE_SELECT_EDGE) {
102     BMEdge *e;
103     BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
104       BM_elem_flag_set(e, BM_ELEM_TAG, BM_elem_flag_test(e, BM_ELEM_SELECT));
105     }
106   }
107   else {
108     BMFace *f;
109     BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
110       BM_elem_flag_set(f, BM_ELEM_TAG, BM_elem_flag_test(f, BM_ELEM_SELECT));
111     }
112   }
113
114   EDBM_verts_mirror_cache_begin(em, axis, true, true, use_topology);
115
116   if (!extend) {
117     EDBM_flag_disable_all(em, BM_ELEM_SELECT);
118   }
119
120   if (bm->selectmode & SCE_SELECT_VERTEX) {
121     BMVert *v;
122     BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
123       if (!BM_elem_flag_test(v, BM_ELEM_HIDDEN) && BM_elem_flag_test(v, BM_ELEM_TAG)) {
124         BMVert *v_mirr = EDBM_verts_mirror_get(em, v);
125         if (v_mirr && !BM_elem_flag_test(v_mirr, BM_ELEM_HIDDEN)) {
126           BM_vert_select_set(bm, v_mirr, true);
127           totmirr++;
128         }
129         else {
130           totfail++;
131         }
132       }
133     }
134   }
135   else if (em->selectmode & SCE_SELECT_EDGE) {
136     BMEdge *e;
137     BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
138       if (!BM_elem_flag_test(e, BM_ELEM_HIDDEN) && BM_elem_flag_test(e, BM_ELEM_TAG)) {
139         BMEdge *e_mirr = EDBM_verts_mirror_get_edge(em, e);
140         if (e_mirr && !BM_elem_flag_test(e_mirr, BM_ELEM_HIDDEN)) {
141           BM_edge_select_set(bm, e_mirr, true);
142           totmirr++;
143         }
144         else {
145           totfail++;
146         }
147       }
148     }
149   }
150   else {
151     BMFace *f;
152     BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
153       if (!BM_elem_flag_test(f, BM_ELEM_HIDDEN) && BM_elem_flag_test(f, BM_ELEM_TAG)) {
154         BMFace *f_mirr = EDBM_verts_mirror_get_face(em, f);
155         if (f_mirr && !BM_elem_flag_test(f_mirr, BM_ELEM_HIDDEN)) {
156           BM_face_select_set(bm, f_mirr, true);
157           totmirr++;
158         }
159         else {
160           totfail++;
161         }
162       }
163     }
164   }
165
166   EDBM_verts_mirror_cache_end(em);
167
168   *r_totmirr = totmirr;
169   *r_totfail = totfail;
170 }
171
172 /** \} */
173
174 /* -------------------------------------------------------------------- */
175 /** \name Select Auto-Merge
176  *
177  * Used after transform operations.
178  * \{ */
179
180 void EDBM_automerge(Scene *scene, Object *obedit, bool update, const char hflag)
181 {
182   bool ok;
183   BMEditMesh *em = BKE_editmesh_from_object(obedit);
184
185   ok = BMO_op_callf(em->bm,
186                     BMO_FLAG_DEFAULTS,
187                     "automerge verts=%hv dist=%f",
188                     hflag,
189                     scene->toolsettings->doublimit);
190
191   if (LIKELY(ok) && update) {
192     EDBM_update_generic(em, true, true);
193   }
194 }
195
196 /** \} */
197
198 /* -------------------------------------------------------------------- */
199 /** \name Back-Buffer OpenGL Selection
200  * \{ */
201
202 struct EDBMBaseOffset {
203   /* For convenience only. */
204   union {
205     uint offset;
206     uint face_start;
207   };
208   union {
209     uint face;
210     uint edge_start;
211   };
212   union {
213     uint edge;
214     uint vert_start;
215   };
216   uint vert;
217 };
218
219 struct EDBMSelectID_Context {
220   struct EDBMBaseOffset *base_array_index_offsets;
221   /** Borrow from caller (not freed). */
222   struct Base **bases;
223   uint bases_len;
224   /** Total number of items `base_array_index_offsets[bases_len - 1].vert`. */
225   uint base_array_index_len;
226 };
227
228 static bool check_ob_drawface_dot(short select_mode, const View3D *v3d, char dt)
229 {
230   if (select_mode & SCE_SELECT_FACE) {
231     if ((dt < OB_SOLID) || XRAY_FLAG_ENABLED(v3d)) {
232       return true;
233     }
234     if (v3d->overlay.edit_flag & V3D_OVERLAY_EDIT_FACE_DOT) {
235       return true;
236     }
237     if ((v3d->overlay.edit_flag & V3D_OVERLAY_EDIT_EDGES) == 0) {
238       /* Since we can't deduce face selection when edges aren't visible - show dots. */
239       return true;
240     }
241   }
242   return false;
243 }
244
245 static void edbm_select_pick_draw_bases(struct EDBMSelectID_Context *sel_id_ctx,
246                                         ViewContext *vc,
247                                         short select_mode)
248 {
249   Scene *scene_eval = (Scene *)DEG_get_evaluated_id(vc->depsgraph, &vc->scene->id);
250   DRW_framebuffer_select_id_setup(vc->ar, true);
251
252   uint offset = 1;
253   for (uint base_index = 0; base_index < sel_id_ctx->bases_len; base_index++) {
254     Object *ob_eval = DEG_get_evaluated_object(vc->depsgraph,
255                                                sel_id_ctx->bases[base_index]->object);
256
257     struct EDBMBaseOffset *base_ofs = &sel_id_ctx->base_array_index_offsets[base_index];
258     bool draw_facedot = check_ob_drawface_dot(select_mode, vc->v3d, ob_eval->dt);
259
260     DRW_draw_select_id_object(scene_eval,
261                               vc->rv3d,
262                               ob_eval,
263                               select_mode,
264                               draw_facedot,
265                               offset,
266                               &base_ofs->vert,
267                               &base_ofs->edge,
268                               &base_ofs->face);
269
270     base_ofs->offset = offset;
271     offset = base_ofs->vert;
272   }
273
274   sel_id_ctx->base_array_index_len = offset;
275
276   DRW_framebuffer_select_id_release(vc->ar);
277 }
278
279 BMElem *EDBM_select_id_bm_elem_get(struct EDBMSelectID_Context *sel_id_ctx,
280                                    const uint sel_id,
281                                    uint *r_base_index)
282 {
283   char elem_type = 0;
284   uint elem_id;
285   uint base_index = 0;
286   for (; base_index < sel_id_ctx->bases_len; base_index++) {
287     struct EDBMBaseOffset *base_ofs = &sel_id_ctx->base_array_index_offsets[base_index];
288     if (base_ofs->face > sel_id) {
289       elem_id = sel_id - base_ofs->face_start;
290       elem_type = BM_FACE;
291       break;
292     }
293     if (base_ofs->edge > sel_id) {
294       elem_id = sel_id - base_ofs->edge_start;
295       elem_type = BM_EDGE;
296       break;
297     }
298     if (base_ofs->vert > sel_id) {
299       elem_id = sel_id - base_ofs->vert_start;
300       elem_type = BM_VERT;
301       break;
302     }
303   }
304
305   if (base_index >= sel_id_ctx->bases_len) {
306     BLI_assert(0);
307     return NULL;
308   }
309
310   if (r_base_index) {
311     *r_base_index = base_index;
312   }
313
314   Object *obedit = sel_id_ctx->bases[base_index]->object;
315   BMEditMesh *em = BKE_editmesh_from_object(obedit);
316
317   switch (elem_type) {
318     case BM_FACE:
319       return (BMElem *)BM_face_at_index_find_or_table(em->bm, elem_id);
320     case BM_EDGE:
321       return (BMElem *)BM_edge_at_index_find_or_table(em->bm, elem_id);
322     case BM_VERT:
323       return (BMElem *)BM_vert_at_index_find_or_table(em->bm, elem_id);
324     default:
325       BLI_assert(0);
326       return NULL;
327   }
328 }
329
330 uint EDBM_select_id_context_offset_for_object_elem(const struct EDBMSelectID_Context *sel_id_ctx,
331                                                    int base_index,
332                                                    char htype)
333 {
334   struct EDBMBaseOffset *base_ofs = &sel_id_ctx->base_array_index_offsets[base_index];
335   if (htype == BM_VERT) {
336     return base_ofs->vert_start - 1;
337   }
338   if (htype == BM_EDGE) {
339     return base_ofs->edge_start - 1;
340   }
341   if (htype == BM_FACE) {
342     return base_ofs->face_start - 1;
343   }
344   BLI_assert(0);
345   return 0;
346 }
347
348 uint EDBM_select_id_context_elem_len(const struct EDBMSelectID_Context *sel_id_ctx)
349 {
350   return sel_id_ctx->base_array_index_len;
351 }
352
353 struct EDBMSelectID_Context *EDBM_select_id_context_create(ViewContext *vc,
354                                                            Base **bases,
355                                                            const uint bases_len,
356                                                            short select_mode)
357 {
358   struct EDBMSelectID_Context *sel_id_ctx = MEM_mallocN(sizeof(*sel_id_ctx), __func__);
359   sel_id_ctx->base_array_index_offsets = MEM_mallocN(sizeof(struct EDBMBaseOffset) * bases_len,
360                                                      __func__);
361   sel_id_ctx->bases = bases;
362   sel_id_ctx->bases_len = bases_len;
363
364   edbm_select_pick_draw_bases(sel_id_ctx, vc, select_mode);
365
366   return sel_id_ctx;
367 }
368
369 void EDBM_select_id_context_destroy(struct EDBMSelectID_Context *sel_id_ctx)
370 {
371   MEM_freeN(sel_id_ctx->base_array_index_offsets);
372   MEM_freeN(sel_id_ctx);
373 }
374
375 /** \} */
376
377 /* -------------------------------------------------------------------- */
378 /** \name Find Nearest Vert/Edge/Face
379  *
380  * \note Screen-space manhatten distances are used here,
381  * since its faster and good enough for the purpose of selection.
382  *
383  * \note \a dist_bias is used so we can bias against selected items.
384  * when choosing between elements of a single type, but return the real distance
385  * to avoid the bias interfering with distance comparisons when mixing types.
386  * \{ */
387
388 #define FAKE_SELECT_MODE_BEGIN(vc, fake_select_mode, select_mode, select_mode_required) \
389   short select_mode = select_mode_required; \
390   bool fake_select_mode = (select_mode & (vc)->scene->toolsettings->selectmode) == 0; \
391   if (fake_select_mode) { \
392     (vc)->v3d->flag |= V3D_INVALID_BACKBUF; \
393   } \
394   ((void)0)
395
396 #define FAKE_SELECT_MODE_END(vc, fake_select_mode) \
397   if (fake_select_mode) { \
398     (vc)->v3d->flag |= V3D_INVALID_BACKBUF; \
399   } \
400   ((void)0)
401
402 #define FIND_NEAR_SELECT_BIAS 5
403 #define FIND_NEAR_CYCLE_THRESHOLD_MIN 3
404
405 struct NearestVertUserData_Hit {
406   float dist;
407   float dist_bias;
408   int index;
409   BMVert *vert;
410 };
411
412 struct NearestVertUserData {
413   float mval_fl[2];
414   bool use_select_bias;
415   bool use_cycle;
416   int cycle_index_prev;
417
418   struct NearestVertUserData_Hit hit;
419   struct NearestVertUserData_Hit hit_cycle;
420 };
421
422 static void findnearestvert__doClosest(void *userData,
423                                        BMVert *eve,
424                                        const float screen_co[2],
425                                        int index)
426 {
427   struct NearestVertUserData *data = userData;
428   float dist_test, dist_test_bias;
429
430   dist_test = dist_test_bias = len_manhattan_v2v2(data->mval_fl, screen_co);
431
432   if (data->use_select_bias && BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
433     dist_test_bias += FIND_NEAR_SELECT_BIAS;
434   }
435
436   if (dist_test_bias < data->hit.dist_bias) {
437     data->hit.dist_bias = dist_test_bias;
438     data->hit.dist = dist_test;
439     data->hit.index = index;
440     data->hit.vert = eve;
441   }
442
443   if (data->use_cycle) {
444     if ((data->hit_cycle.vert == NULL) && (index > data->cycle_index_prev) &&
445         (dist_test_bias < FIND_NEAR_CYCLE_THRESHOLD_MIN)) {
446       data->hit_cycle.dist_bias = dist_test_bias;
447       data->hit_cycle.dist = dist_test;
448       data->hit_cycle.index = index;
449       data->hit_cycle.vert = eve;
450     }
451   }
452 }
453
454 /**
455  * Nearest vertex under the cursor.
456  *
457  * \param r_dist: (in/out), minimal distance to the nearest and at the end, actual distance
458  * \param use_select_bias:
459  * - When true, selected vertices are given a 5 pixel bias
460  *   to make them further than unselect verts.
461  * - When false, unselected vertices are given the bias.
462  * \param use_cycle: Cycle over elements within #FIND_NEAR_CYCLE_THRESHOLD_MIN in order of index.
463  */
464 BMVert *EDBM_vert_find_nearest_ex(ViewContext *vc,
465                                   float *r_dist,
466                                   const bool use_select_bias,
467                                   bool use_cycle,
468                                   Base **bases,
469                                   uint bases_len,
470                                   uint *r_base_index)
471 {
472   uint base_index = 0;
473
474   if (!XRAY_FLAG_ENABLED(vc->v3d)) {
475     uint dist_px = (uint)ED_view3d_backbuf_sample_size_clamp(vc->ar, *r_dist);
476     uint index;
477     BMVert *eve;
478
479     /* No afterqueue (yet), so we check it now, otherwise the bm_xxxofs indices are bad. */
480     {
481       FAKE_SELECT_MODE_BEGIN(vc, fake_select_mode, select_mode, SCE_SELECT_VERTEX);
482
483       struct EDBMSelectID_Context *sel_id_ctx = EDBM_select_id_context_create(
484           vc, bases, bases_len, select_mode);
485
486       index = ED_select_buffer_find_nearest_to_point(vc->mval, 1, UINT_MAX, &dist_px);
487
488       if (index) {
489         eve = (BMVert *)EDBM_select_id_bm_elem_get(sel_id_ctx, index, &base_index);
490       }
491       else {
492         eve = NULL;
493       }
494
495       EDBM_select_id_context_destroy(sel_id_ctx);
496
497       FAKE_SELECT_MODE_END(vc, fake_select_mode);
498     }
499
500     if (eve) {
501       if (dist_px < *r_dist) {
502         if (r_base_index) {
503           *r_base_index = base_index;
504         }
505         *r_dist = dist_px;
506         return eve;
507       }
508     }
509     return NULL;
510   }
511   else {
512     struct NearestVertUserData data = {{0}};
513     const struct NearestVertUserData_Hit *hit = NULL;
514     const eV3DProjTest clip_flag = V3D_PROJ_TEST_CLIP_DEFAULT;
515     BMesh *prev_select_bm = NULL;
516
517     static struct {
518       int index;
519       const BMVert *elem;
520       const BMesh *bm;
521     } prev_select = {0};
522
523     data.mval_fl[0] = vc->mval[0];
524     data.mval_fl[1] = vc->mval[1];
525     data.use_select_bias = use_select_bias;
526     data.use_cycle = use_cycle;
527
528     for (; base_index < bases_len; base_index++) {
529       Base *base_iter = bases[base_index];
530       ED_view3d_viewcontext_init_object(vc, base_iter->object);
531       if (use_cycle && prev_select.bm == vc->em->bm &&
532           prev_select.elem == BM_vert_at_index_find_or_table(vc->em->bm, prev_select.index)) {
533         data.cycle_index_prev = prev_select.index;
534         /* No need to compare in the rest of the loop. */
535         use_cycle = false;
536       }
537       else {
538         data.cycle_index_prev = 0;
539       }
540
541       data.hit.dist = data.hit_cycle.dist = data.hit.dist_bias = data.hit_cycle.dist_bias =
542           *r_dist;
543
544       ED_view3d_init_mats_rv3d(vc->obedit, vc->rv3d);
545       mesh_foreachScreenVert(vc, findnearestvert__doClosest, &data, clip_flag);
546
547       hit = (data.use_cycle && data.hit_cycle.vert) ? &data.hit_cycle : &data.hit;
548
549       if (hit->dist < *r_dist) {
550         if (r_base_index) {
551           *r_base_index = base_index;
552         }
553         *r_dist = hit->dist;
554         prev_select_bm = vc->em->bm;
555       }
556     }
557
558     if (hit == NULL) {
559       return NULL;
560     }
561
562     prev_select.index = hit->index;
563     prev_select.elem = hit->vert;
564     prev_select.bm = prev_select_bm;
565
566     return hit->vert;
567   }
568 }
569
570 BMVert *EDBM_vert_find_nearest(ViewContext *vc, float *r_dist)
571 {
572   Base *base = BKE_view_layer_base_find(vc->view_layer, vc->obact);
573   return EDBM_vert_find_nearest_ex(vc, r_dist, false, false, &base, 1, NULL);
574 }
575
576 /* find the distance to the edge we already have */
577 struct NearestEdgeUserData_ZBuf {
578   float mval_fl[2];
579   float dist;
580   const BMEdge *edge_test;
581 };
582
583 static void find_nearest_edge_center__doZBuf(void *userData,
584                                              BMEdge *eed,
585                                              const float screen_co_a[2],
586                                              const float screen_co_b[2],
587                                              int UNUSED(index))
588 {
589   struct NearestEdgeUserData_ZBuf *data = userData;
590
591   if (eed == data->edge_test) {
592     float dist_test;
593     float screen_co_mid[2];
594
595     mid_v2_v2v2(screen_co_mid, screen_co_a, screen_co_b);
596     dist_test = len_manhattan_v2v2(data->mval_fl, screen_co_mid);
597
598     if (dist_test < data->dist) {
599       data->dist = dist_test;
600     }
601   }
602 }
603
604 struct NearestEdgeUserData_Hit {
605   float dist;
606   float dist_bias;
607   int index;
608   BMEdge *edge;
609
610   /* edges only, un-biased manhatten distance to which ever edge we pick
611    * (not used for choosing) */
612   float dist_center;
613 };
614
615 struct NearestEdgeUserData {
616   ViewContext vc;
617   float mval_fl[2];
618   bool use_select_bias;
619   bool use_cycle;
620   int cycle_index_prev;
621
622   struct NearestEdgeUserData_Hit hit;
623   struct NearestEdgeUserData_Hit hit_cycle;
624 };
625
626 /* note; uses v3d, so needs active 3d window */
627 static void find_nearest_edge__doClosest(
628     void *userData, BMEdge *eed, const float screen_co_a[2], const float screen_co_b[2], int index)
629 {
630   struct NearestEdgeUserData *data = userData;
631   float dist_test, dist_test_bias;
632
633   float fac = line_point_factor_v2(data->mval_fl, screen_co_a, screen_co_b);
634   float screen_co[2];
635
636   if (fac <= 0.0f) {
637     fac = 0.0f;
638     copy_v2_v2(screen_co, screen_co_a);
639   }
640   else if (fac >= 1.0f) {
641     fac = 1.0f;
642     copy_v2_v2(screen_co, screen_co_b);
643   }
644   else {
645     interp_v2_v2v2(screen_co, screen_co_a, screen_co_b, fac);
646   }
647
648   dist_test = dist_test_bias = len_manhattan_v2v2(data->mval_fl, screen_co);
649
650   if (data->use_select_bias && BM_elem_flag_test(eed, BM_ELEM_SELECT)) {
651     dist_test_bias += FIND_NEAR_SELECT_BIAS;
652   }
653
654   if (data->vc.rv3d->rflag & RV3D_CLIPPING) {
655     float vec[3];
656
657     interp_v3_v3v3(vec, eed->v1->co, eed->v2->co, fac);
658     if (ED_view3d_clipping_test(data->vc.rv3d, vec, true)) {
659       return;
660     }
661   }
662
663   if (dist_test_bias < data->hit.dist_bias) {
664     float screen_co_mid[2];
665
666     data->hit.dist_bias = dist_test_bias;
667     data->hit.dist = dist_test;
668     data->hit.index = index;
669     data->hit.edge = eed;
670
671     mid_v2_v2v2(screen_co_mid, screen_co_a, screen_co_b);
672     data->hit.dist_center = len_manhattan_v2v2(data->mval_fl, screen_co_mid);
673   }
674
675   if (data->use_cycle) {
676     if ((data->hit_cycle.edge == NULL) && (index > data->cycle_index_prev) &&
677         (dist_test_bias < FIND_NEAR_CYCLE_THRESHOLD_MIN)) {
678       float screen_co_mid[2];
679
680       data->hit_cycle.dist_bias = dist_test_bias;
681       data->hit_cycle.dist = dist_test;
682       data->hit_cycle.index = index;
683       data->hit_cycle.edge = eed;
684
685       mid_v2_v2v2(screen_co_mid, screen_co_a, screen_co_b);
686       data->hit_cycle.dist_center = len_manhattan_v2v2(data->mval_fl, screen_co_mid);
687     }
688   }
689 }
690
691 BMEdge *EDBM_edge_find_nearest_ex(ViewContext *vc,
692                                   float *r_dist,
693                                   float *r_dist_center,
694                                   const bool use_select_bias,
695                                   bool use_cycle,
696                                   BMEdge **r_eed_zbuf,
697                                   Base **bases,
698                                   uint bases_len,
699                                   uint *r_base_index)
700 {
701   uint base_index = 0;
702
703   if (!XRAY_FLAG_ENABLED(vc->v3d)) {
704     uint dist_px = (uint)ED_view3d_backbuf_sample_size_clamp(vc->ar, *r_dist);
705     uint index;
706     BMEdge *eed;
707
708     /* No afterqueue (yet), so we check it now, otherwise the bm_xxxofs indices are bad. */
709     {
710       FAKE_SELECT_MODE_BEGIN(vc, fake_select_mode, select_mode, SCE_SELECT_EDGE);
711
712       struct EDBMSelectID_Context *sel_id_ctx = EDBM_select_id_context_create(
713           vc, bases, bases_len, select_mode);
714
715       index = ED_select_buffer_find_nearest_to_point(vc->mval, 1, UINT_MAX, &dist_px);
716
717       if (index) {
718         eed = (BMEdge *)EDBM_select_id_bm_elem_get(sel_id_ctx, index, &base_index);
719       }
720       else {
721         eed = NULL;
722       }
723
724       EDBM_select_id_context_destroy(sel_id_ctx);
725
726       FAKE_SELECT_MODE_END(vc, fake_select_mode);
727     }
728
729     if (r_eed_zbuf) {
730       *r_eed_zbuf = eed;
731     }
732
733     /* exception for faces (verts don't need this) */
734     if (r_dist_center && eed) {
735       struct NearestEdgeUserData_ZBuf data;
736
737       data.mval_fl[0] = vc->mval[0];
738       data.mval_fl[1] = vc->mval[1];
739       data.dist = FLT_MAX;
740       data.edge_test = eed;
741
742       ED_view3d_init_mats_rv3d(vc->obedit, vc->rv3d);
743
744       mesh_foreachScreenEdge(
745           vc, find_nearest_edge_center__doZBuf, &data, V3D_PROJ_TEST_CLIP_DEFAULT);
746
747       *r_dist_center = data.dist;
748     }
749     /* end exception */
750
751     if (eed) {
752       if (dist_px < *r_dist) {
753         if (r_base_index) {
754           *r_base_index = base_index;
755         }
756         *r_dist = dist_px;
757         return eed;
758       }
759     }
760     return NULL;
761   }
762   else {
763     struct NearestEdgeUserData data = {{0}};
764     const struct NearestEdgeUserData_Hit *hit = NULL;
765     /* interpolate along the edge before doing a clipping plane test */
766     const eV3DProjTest clip_flag = V3D_PROJ_TEST_CLIP_DEFAULT & ~V3D_PROJ_TEST_CLIP_BB;
767     BMesh *prev_select_bm = NULL;
768
769     static struct {
770       int index;
771       const BMEdge *elem;
772       const BMesh *bm;
773     } prev_select = {0};
774
775     data.vc = *vc;
776     data.mval_fl[0] = vc->mval[0];
777     data.mval_fl[1] = vc->mval[1];
778     data.use_select_bias = use_select_bias;
779     data.use_cycle = use_cycle;
780
781     for (; base_index < bases_len; base_index++) {
782       Base *base_iter = bases[base_index];
783       ED_view3d_viewcontext_init_object(vc, base_iter->object);
784       if (use_cycle && prev_select.bm == vc->em->bm &&
785           prev_select.elem == BM_edge_at_index_find_or_table(vc->em->bm, prev_select.index)) {
786         data.cycle_index_prev = prev_select.index;
787         /* No need to compare in the rest of the loop. */
788         use_cycle = false;
789       }
790       else {
791         data.cycle_index_prev = 0;
792       }
793
794       data.hit.dist = data.hit_cycle.dist = data.hit.dist_bias = data.hit_cycle.dist_bias =
795           *r_dist;
796
797       ED_view3d_init_mats_rv3d(vc->obedit, vc->rv3d);
798       mesh_foreachScreenEdge(vc, find_nearest_edge__doClosest, &data, clip_flag);
799
800       hit = (data.use_cycle && data.hit_cycle.edge) ? &data.hit_cycle : &data.hit;
801
802       if (hit->dist < *r_dist) {
803         if (r_base_index) {
804           *r_base_index = base_index;
805         }
806         *r_dist = hit->dist;
807         prev_select_bm = vc->em->bm;
808       }
809     }
810
811     if (hit == NULL) {
812       return NULL;
813     }
814
815     if (r_dist_center) {
816       *r_dist_center = hit->dist_center;
817     }
818
819     prev_select.index = hit->index;
820     prev_select.elem = hit->edge;
821     prev_select.bm = prev_select_bm;
822
823     return hit->edge;
824   }
825 }
826
827 BMEdge *EDBM_edge_find_nearest(ViewContext *vc, float *r_dist)
828 {
829   Base *base = BKE_view_layer_base_find(vc->view_layer, vc->obact);
830   return EDBM_edge_find_nearest_ex(vc, r_dist, NULL, false, false, NULL, &base, 1, NULL);
831 }
832
833 /* find the distance to the face we already have */
834 struct NearestFaceUserData_ZBuf {
835   float mval_fl[2];
836   float dist;
837   const BMFace *face_test;
838 };
839
840 static void find_nearest_face_center__doZBuf(void *userData,
841                                              BMFace *efa,
842                                              const float screen_co[2],
843                                              int UNUSED(index))
844 {
845   struct NearestFaceUserData_ZBuf *data = userData;
846
847   if (efa == data->face_test) {
848     const float dist_test = len_manhattan_v2v2(data->mval_fl, screen_co);
849
850     if (dist_test < data->dist) {
851       data->dist = dist_test;
852     }
853   }
854 }
855
856 struct NearestFaceUserData_Hit {
857   float dist;
858   float dist_bias;
859   int index;
860   BMFace *face;
861 };
862
863 struct NearestFaceUserData {
864   float mval_fl[2];
865   bool use_select_bias;
866   bool use_cycle;
867   int cycle_index_prev;
868
869   struct NearestFaceUserData_Hit hit;
870   struct NearestFaceUserData_Hit hit_cycle;
871 };
872
873 static void findnearestface__doClosest(void *userData,
874                                        BMFace *efa,
875                                        const float screen_co[2],
876                                        int index)
877 {
878   struct NearestFaceUserData *data = userData;
879   float dist_test, dist_test_bias;
880
881   dist_test = dist_test_bias = len_manhattan_v2v2(data->mval_fl, screen_co);
882
883   if (data->use_select_bias && BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
884     dist_test_bias += FIND_NEAR_SELECT_BIAS;
885   }
886
887   if (dist_test_bias < data->hit.dist_bias) {
888     data->hit.dist_bias = dist_test_bias;
889     data->hit.dist = dist_test;
890     data->hit.index = index;
891     data->hit.face = efa;
892   }
893
894   if (data->use_cycle) {
895     if ((data->hit_cycle.face == NULL) && (index > data->cycle_index_prev) &&
896         (dist_test_bias < FIND_NEAR_CYCLE_THRESHOLD_MIN)) {
897       data->hit_cycle.dist_bias = dist_test_bias;
898       data->hit_cycle.dist = dist_test;
899       data->hit_cycle.index = index;
900       data->hit_cycle.face = efa;
901     }
902   }
903 }
904
905 BMFace *EDBM_face_find_nearest_ex(ViewContext *vc,
906                                   float *r_dist,
907                                   float *r_dist_center,
908                                   const bool use_select_bias,
909                                   bool use_cycle,
910                                   BMFace **r_efa_zbuf,
911                                   Base **bases,
912                                   uint bases_len,
913                                   uint *r_base_index)
914 {
915   uint base_index = 0;
916
917   if (!XRAY_FLAG_ENABLED(vc->v3d)) {
918     float dist_test = 0.0f;
919     uint index;
920     BMFace *efa;
921
922     {
923       FAKE_SELECT_MODE_BEGIN(vc, fake_select_mode, select_mode, SCE_SELECT_FACE);
924
925       struct EDBMSelectID_Context *sel_id_ctx = EDBM_select_id_context_create(
926           vc, bases, bases_len, select_mode);
927
928       index = ED_select_buffer_sample_point(vc->mval);
929
930       if (index) {
931         efa = (BMFace *)EDBM_select_id_bm_elem_get(sel_id_ctx, index, &base_index);
932       }
933       else {
934         efa = NULL;
935       }
936
937       EDBM_select_id_context_destroy(sel_id_ctx);
938
939       FAKE_SELECT_MODE_END(vc, fake_select_mode);
940     }
941
942     if (r_efa_zbuf) {
943       *r_efa_zbuf = efa;
944     }
945
946     /* exception for faces (verts don't need this) */
947     if (r_dist_center && efa) {
948       struct NearestFaceUserData_ZBuf data;
949
950       data.mval_fl[0] = vc->mval[0];
951       data.mval_fl[1] = vc->mval[1];
952       data.dist = FLT_MAX;
953       data.face_test = efa;
954
955       ED_view3d_init_mats_rv3d(vc->obedit, vc->rv3d);
956
957       mesh_foreachScreenFace(
958           vc, find_nearest_face_center__doZBuf, &data, V3D_PROJ_TEST_CLIP_DEFAULT);
959
960       *r_dist_center = data.dist;
961     }
962     /* end exception */
963
964     if (efa) {
965       if (dist_test < *r_dist) {
966         if (r_base_index) {
967           *r_base_index = base_index;
968         }
969         *r_dist = dist_test;
970         return efa;
971       }
972     }
973     return NULL;
974   }
975   else {
976     struct NearestFaceUserData data = {{0}};
977     const struct NearestFaceUserData_Hit *hit = NULL;
978     const eV3DProjTest clip_flag = V3D_PROJ_TEST_CLIP_DEFAULT;
979     BMesh *prev_select_bm = NULL;
980
981     static struct {
982       int index;
983       const BMFace *elem;
984       const BMesh *bm;
985     } prev_select = {0};
986
987     data.mval_fl[0] = vc->mval[0];
988     data.mval_fl[1] = vc->mval[1];
989     data.use_select_bias = use_select_bias;
990     data.use_cycle = use_cycle;
991
992     for (; base_index < bases_len; base_index++) {
993       Base *base_iter = bases[base_index];
994       ED_view3d_viewcontext_init_object(vc, base_iter->object);
995       if (use_cycle && prev_select.bm == vc->em->bm &&
996           prev_select.elem == BM_face_at_index_find_or_table(vc->em->bm, prev_select.index)) {
997         data.cycle_index_prev = prev_select.index;
998         /* No need to compare in the rest of the loop. */
999         use_cycle = false;
1000       }
1001       else {
1002         data.cycle_index_prev = 0;
1003       }
1004
1005       data.hit.dist = data.hit_cycle.dist = data.hit.dist_bias = data.hit_cycle.dist_bias =
1006           *r_dist;
1007
1008       ED_view3d_init_mats_rv3d(vc->obedit, vc->rv3d);
1009       mesh_foreachScreenFace(vc, findnearestface__doClosest, &data, clip_flag);
1010
1011       hit = (data.use_cycle && data.hit_cycle.face) ? &data.hit_cycle : &data.hit;
1012
1013       if (hit->dist < *r_dist) {
1014         if (r_base_index) {
1015           *r_base_index = base_index;
1016         }
1017         *r_dist = hit->dist;
1018         prev_select_bm = vc->em->bm;
1019       }
1020     }
1021
1022     if (hit == NULL) {
1023       return NULL;
1024     }
1025
1026     if (r_dist_center) {
1027       *r_dist_center = hit->dist;
1028     }
1029
1030     prev_select.index = hit->index;
1031     prev_select.elem = hit->face;
1032     prev_select.bm = prev_select_bm;
1033
1034     return hit->face;
1035   }
1036 }
1037
1038 BMFace *EDBM_face_find_nearest(ViewContext *vc, float *r_dist)
1039 {
1040   Base *base = BKE_view_layer_base_find(vc->view_layer, vc->obact);
1041   return EDBM_face_find_nearest_ex(vc, r_dist, NULL, false, false, NULL, &base, 1, NULL);
1042 }
1043
1044 #undef FIND_NEAR_SELECT_BIAS
1045 #undef FIND_NEAR_CYCLE_THRESHOLD_MIN
1046
1047 /* best distance based on screen coords.
1048  * use em->selectmode to define how to use
1049  * selected vertices and edges get disadvantage
1050  * return 1 if found one
1051  */
1052 static bool unified_findnearest(ViewContext *vc,
1053                                 Base **bases,
1054                                 const uint bases_len,
1055                                 int *r_base_index,
1056                                 BMVert **r_eve,
1057                                 BMEdge **r_eed,
1058                                 BMFace **r_efa)
1059 {
1060   BMEditMesh *em = vc->em;
1061   static short mval_prev[2] = {-1, -1};
1062   /* only cycle while the mouse remains still */
1063   const bool use_cycle = ((mval_prev[0] == vc->mval[0]) && (mval_prev[1] == vc->mval[1]));
1064   const float dist_init = ED_view3d_select_dist_px();
1065   /* since edges select lines, we give dots advantage of ~20 pix */
1066   const float dist_margin = (dist_init / 2);
1067   float dist = dist_init;
1068
1069   struct {
1070     struct {
1071       BMVert *ele;
1072       int base_index;
1073     } v;
1074     struct {
1075       BMEdge *ele;
1076       int base_index;
1077     } e, e_zbuf;
1078     struct {
1079       BMFace *ele;
1080       int base_index;
1081     } f, f_zbuf;
1082   } hit = {{NULL}};
1083
1084   /* no afterqueue (yet), so we check it now, otherwise the em_xxxofs indices are bad */
1085
1086   if ((dist > 0.0f) && (em->selectmode & SCE_SELECT_FACE)) {
1087     float dist_center = 0.0f;
1088     float *dist_center_p = (em->selectmode & (SCE_SELECT_EDGE | SCE_SELECT_VERTEX)) ?
1089                                &dist_center :
1090                                NULL;
1091
1092     uint base_index = 0;
1093     BMFace *efa_zbuf = NULL;
1094     BMFace *efa_test = EDBM_face_find_nearest_ex(
1095         vc, &dist, dist_center_p, true, use_cycle, &efa_zbuf, bases, bases_len, &base_index);
1096
1097     if (efa_test && dist_center_p) {
1098       dist = min_ff(dist_margin, dist_center);
1099     }
1100     if (efa_test) {
1101       hit.f.base_index = base_index;
1102       hit.f.ele = efa_test;
1103     }
1104     if (efa_zbuf) {
1105       hit.f_zbuf.base_index = base_index;
1106       hit.f_zbuf.ele = efa_zbuf;
1107     }
1108   }
1109
1110   if ((dist > 0.0f) && (em->selectmode & SCE_SELECT_EDGE)) {
1111     float dist_center = 0.0f;
1112     float *dist_center_p = (em->selectmode & SCE_SELECT_VERTEX) ? &dist_center : NULL;
1113
1114     uint base_index = 0;
1115     BMEdge *eed_zbuf = NULL;
1116     BMEdge *eed_test = EDBM_edge_find_nearest_ex(
1117         vc, &dist, dist_center_p, true, use_cycle, &eed_zbuf, bases, bases_len, &base_index);
1118
1119     if (eed_test && dist_center_p) {
1120       dist = min_ff(dist_margin, dist_center);
1121     }
1122     if (eed_test) {
1123       hit.e.base_index = base_index;
1124       hit.e.ele = eed_test;
1125     }
1126     if (eed_zbuf) {
1127       hit.e_zbuf.base_index = base_index;
1128       hit.e_zbuf.ele = eed_zbuf;
1129     }
1130   }
1131
1132   if ((dist > 0.0f) && (em->selectmode & SCE_SELECT_VERTEX)) {
1133     uint base_index = 0;
1134     BMVert *eve_test = EDBM_vert_find_nearest_ex(
1135         vc, &dist, true, use_cycle, bases, bases_len, &base_index);
1136
1137     if (eve_test) {
1138       hit.v.base_index = base_index;
1139       hit.v.ele = eve_test;
1140     }
1141   }
1142
1143   /* return only one of 3 pointers, for frontbuffer redraws */
1144   if (hit.v.ele) {
1145     hit.f.ele = NULL;
1146     hit.e.ele = NULL;
1147   }
1148   else if (hit.e.ele) {
1149     hit.f.ele = NULL;
1150   }
1151
1152   /* there may be a face under the cursor, who's center if too far away
1153    * use this if all else fails, it makes sense to select this */
1154   if ((hit.v.ele || hit.e.ele || hit.f.ele) == 0) {
1155     if (hit.e_zbuf.ele) {
1156       hit.e.base_index = hit.e_zbuf.base_index;
1157       hit.e.ele = hit.e_zbuf.ele;
1158     }
1159     else if (hit.f_zbuf.ele) {
1160       hit.f.base_index = hit.f_zbuf.base_index;
1161       hit.f.ele = hit.f_zbuf.ele;
1162     }
1163   }
1164
1165   mval_prev[0] = vc->mval[0];
1166   mval_prev[1] = vc->mval[1];
1167
1168   /* Only one element type will be non-null. */
1169   BLI_assert(((hit.v.ele != NULL) + (hit.e.ele != NULL) + (hit.f.ele != NULL)) <= 1);
1170
1171   if (hit.v.ele) {
1172     *r_base_index = hit.v.base_index;
1173   }
1174   if (hit.e.ele) {
1175     *r_base_index = hit.e.base_index;
1176   }
1177   if (hit.f.ele) {
1178     *r_base_index = hit.f.base_index;
1179   }
1180
1181   *r_eve = hit.v.ele;
1182   *r_eed = hit.e.ele;
1183   *r_efa = hit.f.ele;
1184
1185   return (hit.v.ele || hit.e.ele || hit.f.ele);
1186 }
1187
1188 #undef FAKE_SELECT_MODE_BEGIN
1189 #undef FAKE_SELECT_MODE_END
1190
1191 bool EDBM_unified_findnearest(ViewContext *vc,
1192                               Base **bases,
1193                               const uint bases_len,
1194                               int *r_base_index,
1195                               BMVert **r_eve,
1196                               BMEdge **r_eed,
1197                               BMFace **r_efa)
1198 {
1199   return unified_findnearest(vc, bases, bases_len, r_base_index, r_eve, r_eed, r_efa);
1200 }
1201
1202 /** \} */
1203
1204 /* -------------------------------------------------------------------- */
1205 /** \name Alternate Find Nearest Vert/Edge (optional boundary)
1206  *
1207  * \note This uses ray-cast method instead of backbuffer,
1208  * currently used for poly-build.
1209  * \{ */
1210
1211 bool EDBM_unified_findnearest_from_raycast(ViewContext *vc,
1212                                            Base **bases,
1213                                            const uint bases_len,
1214                                            bool use_boundary,
1215                                            int *r_base_index,
1216                                            struct BMVert **r_eve,
1217                                            struct BMEdge **r_eed,
1218                                            struct BMFace **r_efa)
1219 {
1220
1221   const float mval_fl[2] = {UNPACK2(vc->mval)};
1222   float ray_origin[3], ray_direction[3];
1223
1224   struct {
1225     uint base_index;
1226     BMElem *ele;
1227   } best = {0, NULL};
1228
1229   if (ED_view3d_win_to_ray_clipped(
1230           vc->depsgraph, vc->ar, vc->v3d, mval_fl, ray_origin, ray_direction, true)) {
1231     float dist_sq_best = FLT_MAX;
1232
1233     const bool use_vert = (r_eve != NULL);
1234     const bool use_edge = (r_eed != NULL);
1235     const bool use_face = (r_efa != NULL);
1236
1237     for (uint base_index = 0; base_index < bases_len; base_index++) {
1238       Base *base_iter = bases[base_index];
1239       Object *obedit = base_iter->object;
1240
1241       BMEditMesh *em = BKE_editmesh_from_object(obedit);
1242       BMesh *bm = em->bm;
1243       float imat3[3][3];
1244
1245       ED_view3d_viewcontext_init_object(vc, obedit);
1246       copy_m3_m4(imat3, obedit->obmat);
1247       invert_m3(imat3);
1248
1249       const float(*coords)[3] = NULL;
1250       {
1251         Mesh *me_eval = (Mesh *)DEG_get_evaluated_id(vc->depsgraph, obedit->data);
1252         if (me_eval->runtime.edit_data) {
1253           coords = me_eval->runtime.edit_data->vertexCos;
1254         }
1255       }
1256
1257       if (coords != NULL) {
1258         BM_mesh_elem_index_ensure(bm, BM_VERT);
1259       }
1260
1261       if (use_boundary && (use_vert || use_edge)) {
1262         BMEdge *e;
1263         BMIter eiter;
1264         BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) {
1265           if ((BM_elem_flag_test(e, BM_ELEM_HIDDEN) == false) && (BM_edge_is_boundary(e))) {
1266             if (use_vert) {
1267               for (uint j = 0; j < 2; j++) {
1268                 BMVert *v = *((&e->v1) + j);
1269                 float point[3];
1270                 mul_v3_m4v3(point, obedit->obmat, coords ? coords[BM_elem_index_get(v)] : v->co);
1271                 const float dist_sq_test = dist_squared_to_ray_v3_normalized(
1272                     ray_origin, ray_direction, point);
1273                 if (dist_sq_test < dist_sq_best) {
1274                   dist_sq_best = dist_sq_test;
1275                   best.base_index = base_index;
1276                   best.ele = (BMElem *)v;
1277                 }
1278               }
1279             }
1280
1281             if (use_edge) {
1282               float point[3];
1283 #if 0
1284               const float dist_sq_test = dist_squared_ray_to_seg_v3(
1285                   ray_origin, ray_direction, e->v1->co, e->v2->co, point, &depth);
1286 #else
1287               if (coords) {
1288                 mid_v3_v3v3(
1289                     point, coords[BM_elem_index_get(e->v1)], coords[BM_elem_index_get(e->v2)]);
1290               }
1291               else {
1292                 mid_v3_v3v3(point, e->v1->co, e->v2->co);
1293               }
1294               mul_m4_v3(obedit->obmat, point);
1295               const float dist_sq_test = dist_squared_to_ray_v3_normalized(
1296                   ray_origin, ray_direction, point);
1297               if (dist_sq_test < dist_sq_best) {
1298                 dist_sq_best = dist_sq_test;
1299                 best.base_index = base_index;
1300                 best.ele = (BMElem *)e;
1301               }
1302 #endif
1303             }
1304           }
1305         }
1306       }
1307       else {
1308         /* Non boundary case. */
1309         if (use_vert) {
1310           BMVert *v;
1311           BMIter viter;
1312           BM_ITER_MESH (v, &viter, bm, BM_VERTS_OF_MESH) {
1313             if (BM_elem_flag_test(v, BM_ELEM_HIDDEN) == false) {
1314               float point[3];
1315               mul_v3_m4v3(point, obedit->obmat, v->co);
1316               const float dist_sq_test = dist_squared_to_ray_v3_normalized(
1317                   ray_origin, ray_direction, v->co);
1318               if (dist_sq_test < dist_sq_best) {
1319                 dist_sq_best = dist_sq_test;
1320                 best.base_index = base_index;
1321                 best.ele = (BMElem *)v;
1322               }
1323             }
1324           }
1325         }
1326         if (use_edge) {
1327           BMEdge *e;
1328           BMIter eiter;
1329           BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) {
1330             if (BM_elem_flag_test(e, BM_ELEM_HIDDEN) == false) {
1331               float point[3];
1332               if (coords) {
1333                 mid_v3_v3v3(
1334                     point, coords[BM_elem_index_get(e->v1)], coords[BM_elem_index_get(e->v2)]);
1335               }
1336               else {
1337                 mid_v3_v3v3(point, e->v1->co, e->v2->co);
1338               }
1339               mul_m4_v3(obedit->obmat, point);
1340               const float dist_sq_test = dist_squared_to_ray_v3_normalized(
1341                   ray_origin, ray_direction, point);
1342               if (dist_sq_test < dist_sq_best) {
1343                 dist_sq_best = dist_sq_test;
1344                 best.base_index = base_index;
1345                 best.ele = (BMElem *)e;
1346               }
1347             }
1348           }
1349         }
1350       }
1351
1352       if (use_face) {
1353         BMFace *f;
1354         BMIter fiter;
1355         BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
1356           if (BM_elem_flag_test(f, BM_ELEM_HIDDEN) == false) {
1357             float point[3];
1358             if (coords) {
1359               BM_face_calc_center_median_vcos(bm, f, point, coords);
1360             }
1361             else {
1362               BM_face_calc_center_median(f, point);
1363             }
1364             mul_m4_v3(obedit->obmat, point);
1365             const float dist_sq_test = dist_squared_to_ray_v3_normalized(
1366                 ray_origin, ray_direction, point);
1367             if (dist_sq_test < dist_sq_best) {
1368               dist_sq_best = dist_sq_test;
1369               best.base_index = base_index;
1370               best.ele = (BMElem *)f;
1371             }
1372           }
1373         }
1374       }
1375     }
1376   }
1377
1378   *r_base_index = best.base_index;
1379   if (r_eve) {
1380     *r_eve = NULL;
1381   }
1382   if (r_eed) {
1383     *r_eed = NULL;
1384   }
1385   if (r_efa) {
1386     *r_efa = NULL;
1387   }
1388
1389   if (best.ele) {
1390     switch (best.ele->head.htype) {
1391       case BM_VERT:
1392         *r_eve = (BMVert *)best.ele;
1393         break;
1394       case BM_EDGE:
1395         *r_eed = (BMEdge *)best.ele;
1396         break;
1397       case BM_FACE:
1398         *r_efa = (BMFace *)best.ele;
1399         break;
1400       default:
1401         BLI_assert(0);
1402     }
1403   }
1404   return (best.ele != NULL);
1405 }
1406
1407 /** \} */
1408
1409 /* -------------------------------------------------------------------- */
1410 /** \name Select Similar Region Operator
1411  * \{ */
1412
1413 static int edbm_select_similar_region_exec(bContext *C, wmOperator *op)
1414 {
1415   Object *obedit = CTX_data_edit_object(C);
1416   BMEditMesh *em = BKE_editmesh_from_object(obedit);
1417   BMesh *bm = em->bm;
1418   bool changed = false;
1419
1420   /* group vars */
1421   int *groups_array;
1422   int(*group_index)[2];
1423   int group_tot;
1424   int i;
1425
1426   if (bm->totfacesel < 2) {
1427     BKE_report(op->reports, RPT_ERROR, "No face regions selected");
1428     return OPERATOR_CANCELLED;
1429   }
1430
1431   groups_array = MEM_mallocN(sizeof(*groups_array) * bm->totfacesel, __func__);
1432   group_tot = BM_mesh_calc_face_groups(
1433       bm, groups_array, &group_index, NULL, NULL, BM_ELEM_SELECT, BM_VERT);
1434
1435   BM_mesh_elem_table_ensure(bm, BM_FACE);
1436
1437   for (i = 0; i < group_tot; i++) {
1438     ListBase faces_regions;
1439     int tot;
1440
1441     const int fg_sta = group_index[i][0];
1442     const int fg_len = group_index[i][1];
1443     int j;
1444     BMFace **fg = MEM_mallocN(sizeof(*fg) * fg_len, __func__);
1445
1446     for (j = 0; j < fg_len; j++) {
1447       fg[j] = BM_face_at_index(bm, groups_array[fg_sta + j]);
1448     }
1449
1450     tot = BM_mesh_region_match(bm, fg, fg_len, &faces_regions);
1451
1452     MEM_freeN(fg);
1453
1454     if (tot) {
1455       LinkData *link;
1456       while ((link = BLI_pophead(&faces_regions))) {
1457         BMFace *f, **faces = link->data;
1458         while ((f = *(faces++))) {
1459           BM_face_select_set(bm, f, true);
1460         }
1461         MEM_freeN(link->data);
1462         MEM_freeN(link);
1463
1464         changed = true;
1465       }
1466     }
1467   }
1468
1469   MEM_freeN(groups_array);
1470   MEM_freeN(group_index);
1471
1472   if (changed) {
1473     DEG_id_tag_update(obedit->data, ID_RECALC_SELECT);
1474     WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit->data);
1475   }
1476   else {
1477     BKE_report(op->reports, RPT_WARNING, "No matching face regions found");
1478   }
1479
1480   return OPERATOR_FINISHED;
1481 }
1482
1483 void MESH_OT_select_similar_region(wmOperatorType *ot)
1484 {
1485   /* identifiers */
1486   ot->name = "Select Similar Regions";
1487   ot->idname = "MESH_OT_select_similar_region";
1488   ot->description = "Select similar face regions to the current selection";
1489
1490   /* api callbacks */
1491   ot->exec = edbm_select_similar_region_exec;
1492   ot->poll = ED_operator_editmesh;
1493
1494   /* flags */
1495   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1496 }
1497
1498 /** \} */
1499
1500 /* -------------------------------------------------------------------- */
1501 /** \name Select Mode Vert/Edge/Face Operator
1502  * \{ */
1503
1504 static int edbm_select_mode_exec(bContext *C, wmOperator *op)
1505 {
1506   const int type = RNA_enum_get(op->ptr, "type");
1507   const int action = RNA_enum_get(op->ptr, "action");
1508   const bool use_extend = RNA_boolean_get(op->ptr, "use_extend");
1509   const bool use_expand = RNA_boolean_get(op->ptr, "use_expand");
1510
1511   if (EDBM_selectmode_toggle(C, type, action, use_extend, use_expand)) {
1512     return OPERATOR_FINISHED;
1513   }
1514   else {
1515     return OPERATOR_CANCELLED;
1516   }
1517 }
1518
1519 static int edbm_select_mode_invoke(bContext *C, wmOperator *op, const wmEvent *event)
1520 {
1521   /* Bypass when in UV non sync-select mode, fall through to keymap that edits. */
1522   if (CTX_wm_space_image(C)) {
1523     ToolSettings *ts = CTX_data_tool_settings(C);
1524     if ((ts->uv_flag & UV_SYNC_SELECTION) == 0) {
1525       return OPERATOR_PASS_THROUGH;
1526     }
1527     /* Bypass when no action is needed. */
1528     if (!RNA_struct_property_is_set(op->ptr, "type")) {
1529       return OPERATOR_CANCELLED;
1530     }
1531   }
1532
1533   /* detecting these options based on shift/ctrl here is weak, but it's done
1534    * to make this work when clicking buttons or menus */
1535   if (!RNA_struct_property_is_set(op->ptr, "use_extend")) {
1536     RNA_boolean_set(op->ptr, "use_extend", event->shift);
1537   }
1538   if (!RNA_struct_property_is_set(op->ptr, "use_expand")) {
1539     RNA_boolean_set(op->ptr, "use_expand", event->ctrl);
1540   }
1541
1542   return edbm_select_mode_exec(C, op);
1543 }
1544
1545 void MESH_OT_select_mode(wmOperatorType *ot)
1546 {
1547   PropertyRNA *prop;
1548
1549   static const EnumPropertyItem elem_items[] = {
1550       {SCE_SELECT_VERTEX, "VERT", ICON_VERTEXSEL, "Vertices", ""},
1551       {SCE_SELECT_EDGE, "EDGE", ICON_EDGESEL, "Edges", ""},
1552       {SCE_SELECT_FACE, "FACE", ICON_FACESEL, "Faces", ""},
1553       {0, NULL, 0, NULL, NULL},
1554   };
1555
1556   static const EnumPropertyItem actions_items[] = {
1557       {0, "DISABLE", 0, "Disable", "Disable selected markers"},
1558       {1, "ENABLE", 0, "Enable", "Enable selected markers"},
1559       {2, "TOGGLE", 0, "Toggle", "Toggle disabled flag for selected markers"},
1560       {0, NULL, 0, NULL, NULL},
1561   };
1562
1563   /* identifiers */
1564   ot->name = "Select Mode";
1565   ot->idname = "MESH_OT_select_mode";
1566   ot->description = "Change selection mode";
1567
1568   /* api callbacks */
1569   ot->invoke = edbm_select_mode_invoke;
1570   ot->exec = edbm_select_mode_exec;
1571   ot->poll = ED_operator_editmesh;
1572
1573   /* flags */
1574   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1575
1576   /* properties */
1577   /* Hide all, not to show redo panel. */
1578   prop = RNA_def_boolean(ot->srna, "use_extend", false, "Extend", "");
1579   RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
1580   prop = RNA_def_boolean(ot->srna, "use_expand", false, "Expand", "");
1581   RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
1582   ot->prop = prop = RNA_def_enum(ot->srna, "type", elem_items, 0, "Type", "");
1583   RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
1584
1585   prop = RNA_def_enum(
1586       ot->srna, "action", actions_items, 2, "Action", "Selection action to execute");
1587   RNA_def_property_flag(prop, PROP_HIDDEN);
1588 }
1589
1590 /** \} */
1591
1592 /* -------------------------------------------------------------------- */
1593 /** \name Select Loop (Non Modal) Operator
1594  * \{ */
1595
1596 static void walker_select_count(BMEditMesh *em,
1597                                 int walkercode,
1598                                 void *start,
1599                                 const bool select,
1600                                 const bool select_mix,
1601                                 int *r_totsel,
1602                                 int *r_totunsel)
1603 {
1604   BMesh *bm = em->bm;
1605   BMElem *ele;
1606   BMWalker walker;
1607   int tot[2] = {0, 0};
1608
1609   BMW_init(&walker,
1610            bm,
1611            walkercode,
1612            BMW_MASK_NOP,
1613            BMW_MASK_NOP,
1614            BMW_MASK_NOP,
1615            BMW_FLAG_TEST_HIDDEN,
1616            BMW_NIL_LAY);
1617
1618   for (ele = BMW_begin(&walker, start); ele; ele = BMW_step(&walker)) {
1619     tot[(BM_elem_flag_test_bool(ele, BM_ELEM_SELECT) != select)] += 1;
1620
1621     if (!select_mix && tot[0] && tot[1]) {
1622       tot[0] = tot[1] = -1;
1623       break;
1624     }
1625   }
1626
1627   *r_totsel = tot[0];
1628   *r_totunsel = tot[1];
1629
1630   BMW_end(&walker);
1631 }
1632
1633 static void walker_select(BMEditMesh *em, int walkercode, void *start, const bool select)
1634 {
1635   BMesh *bm = em->bm;
1636   BMElem *ele;
1637   BMWalker walker;
1638
1639   BMW_init(&walker,
1640            bm,
1641            walkercode,
1642            BMW_MASK_NOP,
1643            BMW_MASK_NOP,
1644            BMW_MASK_NOP,
1645            BMW_FLAG_TEST_HIDDEN,
1646            BMW_NIL_LAY);
1647
1648   for (ele = BMW_begin(&walker, start); ele; ele = BMW_step(&walker)) {
1649     if (!select) {
1650       BM_select_history_remove(bm, ele);
1651     }
1652     BM_elem_select_set(bm, ele, select);
1653   }
1654   BMW_end(&walker);
1655 }
1656
1657 static int edbm_loop_multiselect_exec(bContext *C, wmOperator *op)
1658 {
1659   const bool is_ring = RNA_boolean_get(op->ptr, "ring");
1660   ViewLayer *view_layer = CTX_data_view_layer(C);
1661   uint objects_len = 0;
1662   Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(
1663       view_layer, CTX_wm_view3d(C), &objects_len);
1664   for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
1665     Object *obedit = objects[ob_index];
1666     BMEditMesh *em = BKE_editmesh_from_object(obedit);
1667
1668     if (em->bm->totedgesel == 0) {
1669       continue;
1670     }
1671
1672     BMEdge *eed;
1673     BMEdge **edarray;
1674     int edindex;
1675     BMIter iter;
1676     int totedgesel = 0;
1677
1678     BM_ITER_MESH (eed, &iter, em->bm, BM_EDGES_OF_MESH) {
1679       if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) {
1680         totedgesel++;
1681       }
1682     }
1683
1684     edarray = MEM_mallocN(sizeof(BMEdge *) * totedgesel, "edge array");
1685     edindex = 0;
1686
1687     BM_ITER_MESH (eed, &iter, em->bm, BM_EDGES_OF_MESH) {
1688       if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) {
1689         edarray[edindex] = eed;
1690         edindex++;
1691       }
1692     }
1693
1694     if (is_ring) {
1695       for (edindex = 0; edindex < totedgesel; edindex += 1) {
1696         eed = edarray[edindex];
1697         walker_select(em, BMW_EDGERING, eed, true);
1698       }
1699       EDBM_selectmode_flush(em);
1700     }
1701     else {
1702       for (edindex = 0; edindex < totedgesel; edindex += 1) {
1703         eed = edarray[edindex];
1704         walker_select(em, BMW_EDGELOOP, eed, true);
1705       }
1706       EDBM_selectmode_flush(em);
1707     }
1708     MEM_freeN(edarray);
1709     //  if (EM_texFaceCheck())
1710
1711     DEG_id_tag_update(obedit->data, ID_RECALC_SELECT);
1712     WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit->data);
1713   }
1714   MEM_freeN(objects);
1715
1716   return OPERATOR_FINISHED;
1717 }
1718
1719 void MESH_OT_loop_multi_select(wmOperatorType *ot)
1720 {
1721   /* identifiers */
1722   ot->name = "Multi Select Loops";
1723   ot->idname = "MESH_OT_loop_multi_select";
1724   ot->description = "Select a loop of connected edges by connection type";
1725
1726   /* api callbacks */
1727   ot->exec = edbm_loop_multiselect_exec;
1728   ot->poll = ED_operator_editmesh;
1729
1730   /* flags */
1731   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1732
1733   /* properties */
1734   RNA_def_boolean(ot->srna, "ring", 0, "Ring", "");
1735 }
1736
1737 /** \} */
1738
1739 /* -------------------------------------------------------------------- */
1740 /** \name Select Loop (Cursor Pick) Operator
1741  * \{ */
1742
1743 static void mouse_mesh_loop_face(BMEditMesh *em, BMEdge *eed, bool select, bool select_clear)
1744 {
1745   if (select_clear) {
1746     EDBM_flag_disable_all(em, BM_ELEM_SELECT);
1747   }
1748
1749   walker_select(em, BMW_FACELOOP, eed, select);
1750 }
1751
1752 static void mouse_mesh_loop_edge_ring(BMEditMesh *em, BMEdge *eed, bool select, bool select_clear)
1753 {
1754   if (select_clear) {
1755     EDBM_flag_disable_all(em, BM_ELEM_SELECT);
1756   }
1757
1758   walker_select(em, BMW_EDGERING, eed, select);
1759 }
1760
1761 static void mouse_mesh_loop_edge(
1762     BMEditMesh *em, BMEdge *eed, bool select, bool select_clear, bool select_cycle)
1763 {
1764   bool edge_boundary = false;
1765
1766   /* cycle between BMW_EDGELOOP / BMW_EDGEBOUNDARY  */
1767   if (select_cycle && BM_edge_is_boundary(eed)) {
1768     int tot[2];
1769
1770     /* if the loops selected toggle the boundaries */
1771     walker_select_count(em, BMW_EDGELOOP, eed, select, false, &tot[0], &tot[1]);
1772     if (tot[select] == 0) {
1773       edge_boundary = true;
1774
1775       /* if the boundaries selected, toggle back to the loop */
1776       walker_select_count(em, BMW_EDGEBOUNDARY, eed, select, false, &tot[0], &tot[1]);
1777       if (tot[select] == 0) {
1778         edge_boundary = false;
1779       }
1780     }
1781   }
1782
1783   if (select_clear) {
1784     EDBM_flag_disable_all(em, BM_ELEM_SELECT);
1785   }
1786
1787   if (edge_boundary) {
1788     walker_select(em, BMW_EDGEBOUNDARY, eed, select);
1789   }
1790   else {
1791     walker_select(em, BMW_EDGELOOP, eed, select);
1792   }
1793 }
1794
1795 static bool mouse_mesh_loop(
1796     bContext *C, const int mval[2], bool extend, bool deselect, bool toggle, bool ring)
1797 {
1798   Base *basact = NULL;
1799   BMVert *eve = NULL;
1800   BMEdge *eed = NULL;
1801   BMFace *efa = NULL;
1802
1803   ViewContext vc;
1804   BMEditMesh *em;
1805   bool select = true;
1806   bool select_clear = false;
1807   bool select_cycle = true;
1808   float mvalf[2];
1809
1810   em_setup_viewcontext(C, &vc);
1811   mvalf[0] = (float)(vc.mval[0] = mval[0]);
1812   mvalf[1] = (float)(vc.mval[1] = mval[1]);
1813
1814   BMEditMesh *em_original = vc.em;
1815   const short selectmode = em_original->selectmode;
1816   em_original->selectmode = SCE_SELECT_EDGE;
1817
1818   uint bases_len;
1819   Base **bases = BKE_view_layer_array_from_bases_in_edit_mode(vc.view_layer, vc.v3d, &bases_len);
1820
1821   {
1822     int base_index = -1;
1823     if (EDBM_unified_findnearest(&vc, bases, bases_len, &base_index, &eve, &eed, &efa)) {
1824       basact = bases[base_index];
1825       ED_view3d_viewcontext_init_object(&vc, basact->object);
1826       em = vc.em;
1827     }
1828     else {
1829       em = NULL;
1830     }
1831   }
1832
1833   em_original->selectmode = selectmode;
1834
1835   if (em == NULL || eed == NULL) {
1836     MEM_freeN(bases);
1837     return false;
1838   }
1839
1840   if (extend == false && deselect == false && toggle == false) {
1841     select_clear = true;
1842   }
1843
1844   if (extend) {
1845     select = true;
1846   }
1847   else if (deselect) {
1848     select = false;
1849   }
1850   else if (select_clear || (BM_elem_flag_test(eed, BM_ELEM_SELECT) == 0)) {
1851     select = true;
1852   }
1853   else if (toggle) {
1854     select = false;
1855     select_cycle = false;
1856   }
1857
1858   if (select_clear) {
1859     for (uint base_index = 0; base_index < bases_len; base_index++) {
1860       Base *base_iter = bases[base_index];
1861       Object *ob_iter = base_iter->object;
1862       BMEditMesh *em_iter = BKE_editmesh_from_object(ob_iter);
1863
1864       if (em_iter->bm->totvertsel == 0) {
1865         continue;
1866       }
1867
1868       if (em_iter == em) {
1869         continue;
1870       }
1871
1872       EDBM_flag_disable_all(em_iter, BM_ELEM_SELECT);
1873       DEG_id_tag_update(ob_iter->data, ID_RECALC_SELECT);
1874     }
1875   }
1876
1877   if (em->selectmode & SCE_SELECT_FACE) {
1878     mouse_mesh_loop_face(em, eed, select, select_clear);
1879   }
1880   else {
1881     if (ring) {
1882       mouse_mesh_loop_edge_ring(em, eed, select, select_clear);
1883     }
1884     else {
1885       mouse_mesh_loop_edge(em, eed, select, select_clear, select_cycle);
1886     }
1887   }
1888
1889   EDBM_selectmode_flush(em);
1890
1891   /* sets as active, useful for other tools */
1892   if (select) {
1893     if (em->selectmode & SCE_SELECT_VERTEX) {
1894       /* Find nearest vert from mouse
1895        * (initialize to large values in case only one vertex can be projected) */
1896       float v1_co[2], v2_co[2];
1897       float length_1 = FLT_MAX;
1898       float length_2 = FLT_MAX;
1899
1900       /* We can't be sure this has already been set... */
1901       ED_view3d_init_mats_rv3d(vc.obedit, vc.rv3d);
1902
1903       if (ED_view3d_project_float_object(vc.ar, eed->v1->co, v1_co, V3D_PROJ_TEST_CLIP_NEAR) ==
1904           V3D_PROJ_RET_OK) {
1905         length_1 = len_squared_v2v2(mvalf, v1_co);
1906       }
1907
1908       if (ED_view3d_project_float_object(vc.ar, eed->v2->co, v2_co, V3D_PROJ_TEST_CLIP_NEAR) ==
1909           V3D_PROJ_RET_OK) {
1910         length_2 = len_squared_v2v2(mvalf, v2_co);
1911       }
1912 #if 0
1913       printf("mouse to v1: %f\nmouse to v2: %f\n",
1914              len_squared_v2v2(mvalf, v1_co),
1915              len_squared_v2v2(mvalf, v2_co));
1916 #endif
1917       BM_select_history_store(em->bm, (length_1 < length_2) ? eed->v1 : eed->v2);
1918     }
1919     else if (em->selectmode & SCE_SELECT_EDGE) {
1920       BM_select_history_store(em->bm, eed);
1921     }
1922     else if (em->selectmode & SCE_SELECT_FACE) {
1923       /* Select the face of eed which is the nearest of mouse. */
1924       BMFace *f;
1925       BMIter iterf;
1926       float best_dist = FLT_MAX;
1927       efa = NULL;
1928
1929       /* We can't be sure this has already been set... */
1930       ED_view3d_init_mats_rv3d(vc.obedit, vc.rv3d);
1931
1932       BM_ITER_ELEM (f, &iterf, eed, BM_FACES_OF_EDGE) {
1933         if (BM_elem_flag_test(f, BM_ELEM_SELECT)) {
1934           float cent[3];
1935           float co[2], tdist;
1936
1937           BM_face_calc_center_median(f, cent);
1938           if (ED_view3d_project_float_object(vc.ar, cent, co, V3D_PROJ_TEST_CLIP_NEAR) ==
1939               V3D_PROJ_RET_OK) {
1940             tdist = len_squared_v2v2(mvalf, co);
1941             if (tdist < best_dist) {
1942               /*                          printf("Best face: %p (%f)\n", f, tdist);*/
1943               best_dist = tdist;
1944               efa = f;
1945             }
1946           }
1947         }
1948       }
1949       if (efa) {
1950         BM_mesh_active_face_set(em->bm, efa);
1951         BM_select_history_store(em->bm, efa);
1952       }
1953     }
1954   }
1955
1956   MEM_freeN(bases);
1957
1958   DEG_id_tag_update(vc.obedit->data, ID_RECALC_SELECT);
1959   WM_event_add_notifier(C, NC_GEOM | ND_SELECT, vc.obedit->data);
1960
1961   return true;
1962 }
1963
1964 static int edbm_select_loop_invoke(bContext *C, wmOperator *op, const wmEvent *event)
1965 {
1966
1967   view3d_operator_needs_opengl(C);
1968
1969   if (mouse_mesh_loop(C,
1970                       event->mval,
1971                       RNA_boolean_get(op->ptr, "extend"),
1972                       RNA_boolean_get(op->ptr, "deselect"),
1973                       RNA_boolean_get(op->ptr, "toggle"),
1974                       RNA_boolean_get(op->ptr, "ring"))) {
1975     return OPERATOR_FINISHED;
1976   }
1977   else {
1978     return OPERATOR_CANCELLED;
1979   }
1980 }
1981
1982 void MESH_OT_loop_select(wmOperatorType *ot)
1983 {
1984   /* identifiers */
1985   ot->name = "Loop Select";
1986   ot->idname = "MESH_OT_loop_select";
1987   ot->description = "Select a loop of connected edges";
1988
1989   /* api callbacks */
1990   ot->invoke = edbm_select_loop_invoke;
1991   ot->poll = ED_operator_editmesh_region_view3d;
1992
1993   /* flags */
1994   ot->flag = OPTYPE_UNDO;
1995
1996   /* properties */
1997   RNA_def_boolean(ot->srna, "extend", 0, "Extend Select", "Extend the selection");
1998   RNA_def_boolean(ot->srna, "deselect", 0, "Deselect", "Remove from the selection");
1999   RNA_def_boolean(ot->srna, "toggle", 0, "Toggle Select", "Toggle the selection");
2000   RNA_def_boolean(ot->srna, "ring", 0, "Select Ring", "Select ring");
2001 }
2002
2003 void MESH_OT_edgering_select(wmOperatorType *ot)
2004 {
2005   /* description */
2006   ot->name = "Edge Ring Select";
2007   ot->idname = "MESH_OT_edgering_select";
2008   ot->description = "Select an edge ring";
2009
2010   /* callbacks */
2011   ot->invoke = edbm_select_loop_invoke;
2012   ot->poll = ED_operator_editmesh_region_view3d;
2013
2014   /* flags */
2015   ot->flag = OPTYPE_UNDO;
2016
2017   RNA_def_boolean(ot->srna, "extend", 0, "Extend", "Extend the selection");
2018   RNA_def_boolean(ot->srna, "deselect", 0, "Deselect", "Remove from the selection");
2019   RNA_def_boolean(ot->srna, "toggle", 0, "Toggle Select", "Toggle the selection");
2020   RNA_def_boolean(ot->srna, "ring", 1, "Select Ring", "Select ring");
2021 }
2022
2023 /** \} */
2024
2025 /* -------------------------------------------------------------------- */
2026 /** \name (De)Select All Operator
2027  * \{ */
2028
2029 static int edbm_select_all_exec(bContext *C, wmOperator *op)
2030 {
2031   ViewLayer *view_layer = CTX_data_view_layer(C);
2032   int action = RNA_enum_get(op->ptr, "action");
2033
2034   uint objects_len = 0;
2035   Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(
2036       view_layer, CTX_wm_view3d(C), &objects_len);
2037
2038   if (action == SEL_TOGGLE) {
2039     action = SEL_SELECT;
2040     for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
2041       Object *obedit = objects[ob_index];
2042       BMEditMesh *em = BKE_editmesh_from_object(obedit);
2043       if (em->bm->totvertsel || em->bm->totedgesel || em->bm->totfacesel) {
2044         action = SEL_DESELECT;
2045         break;
2046       }
2047     }
2048   }
2049
2050   for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
2051     Object *obedit = objects[ob_index];
2052     BMEditMesh *em = BKE_editmesh_from_object(obedit);
2053     switch (action) {
2054       case SEL_SELECT:
2055         EDBM_flag_enable_all(em, BM_ELEM_SELECT);
2056         break;
2057       case SEL_DESELECT:
2058         EDBM_flag_disable_all(em, BM_ELEM_SELECT);
2059         break;
2060       case SEL_INVERT:
2061         EDBM_select_swap(em);
2062         EDBM_selectmode_flush(em);
2063         break;
2064     }
2065     DEG_id_tag_update(obedit->data, ID_RECALC_SELECT);
2066     WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit->data);
2067   }
2068
2069   MEM_freeN(objects);
2070
2071   return OPERATOR_FINISHED;
2072 }
2073
2074 void MESH_OT_select_all(wmOperatorType *ot)
2075 {
2076   /* identifiers */
2077   ot->name = "(De)select All";
2078   ot->idname = "MESH_OT_select_all";
2079   ot->description = "(De)select all vertices, edges or faces";
2080
2081   /* api callbacks */
2082   ot->exec = edbm_select_all_exec;
2083   ot->poll = ED_operator_editmesh;
2084
2085   /* flags */
2086   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2087
2088   WM_operator_properties_select_all(ot);
2089 }
2090
2091 /** \} */
2092
2093 /* -------------------------------------------------------------------- */
2094 /** \name Select Interior Faces Operator
2095  * \{ */
2096
2097 static int edbm_faces_select_interior_exec(bContext *C, wmOperator *UNUSED(op))
2098 {
2099   ViewLayer *view_layer = CTX_data_view_layer(C);
2100   uint objects_len = 0;
2101   Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(
2102       view_layer, CTX_wm_view3d(C), &objects_len);
2103
2104   for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
2105     Object *obedit = objects[ob_index];
2106     BMEditMesh *em = BKE_editmesh_from_object(obedit);
2107
2108     if (!EDBM_select_interior_faces(em)) {
2109       continue;
2110     }
2111
2112     DEG_id_tag_update(obedit->data, ID_RECALC_SELECT);
2113     WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit->data);
2114   }
2115   MEM_freeN(objects);
2116
2117   return OPERATOR_FINISHED;
2118 }
2119
2120 void MESH_OT_select_interior_faces(wmOperatorType *ot)
2121 {
2122   /* identifiers */
2123   ot->name = "Select Interior Faces";
2124   ot->idname = "MESH_OT_select_interior_faces";
2125   ot->description = "Select faces where all edges have more than 2 face users";
2126
2127   /* api callbacks */
2128   ot->exec = edbm_faces_select_interior_exec;
2129   ot->poll = ED_operator_editmesh;
2130
2131   /* flags */
2132   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2133 }
2134
2135 /** \} */
2136
2137 /* -------------------------------------------------------------------- */
2138 /** \name Select Picking API
2139  *
2140  * Here actual select happens,
2141  * Gets called via generic mouse select operator.
2142  * \{ */
2143
2144 bool EDBM_select_pick(bContext *C, const int mval[2], bool extend, bool deselect, bool toggle)
2145 {
2146   ViewContext vc;
2147
2148   int base_index_active = -1;
2149   BMVert *eve = NULL;
2150   BMEdge *eed = NULL;
2151   BMFace *efa = NULL;
2152
2153   /* setup view context for argument to callbacks */
2154   em_setup_viewcontext(C, &vc);
2155   vc.mval[0] = mval[0];
2156   vc.mval[1] = mval[1];
2157
2158   uint bases_len = 0;
2159   Base **bases = BKE_view_layer_array_from_bases_in_edit_mode(vc.view_layer, vc.v3d, &bases_len);
2160
2161   bool ok = false;
2162
2163   if (unified_findnearest(&vc, bases, bases_len, &base_index_active, &eve, &eed, &efa)) {
2164     Base *basact = bases[base_index_active];
2165     ED_view3d_viewcontext_init_object(&vc, basact->object);
2166
2167     /* Deselect everything */
2168     if (extend == false && deselect == false && toggle == false) {
2169       for (uint base_index = 0; base_index < bases_len; base_index++) {
2170         Base *base_iter = bases[base_index];
2171         Object *ob_iter = base_iter->object;
2172         EDBM_flag_disable_all(BKE_editmesh_from_object(ob_iter), BM_ELEM_SELECT);
2173         if (basact->object != ob_iter) {
2174           DEG_id_tag_update(ob_iter->data, ID_RECALC_SELECT);
2175           WM_event_add_notifier(C, NC_GEOM | ND_SELECT, ob_iter->data);
2176         }
2177       }
2178     }
2179
2180     if (efa) {
2181       if (extend) {
2182         /* set the last selected face */
2183         BM_mesh_active_face_set(vc.em->bm, efa);
2184
2185         /* Work-around: deselect first, so we can guarantee it will */
2186         /* be active even if it was already selected */
2187         BM_select_history_remove(vc.em->bm, efa);
2188         BM_face_select_set(vc.em->bm, efa, false);
2189         BM_select_history_store(vc.em->bm, efa);
2190         BM_face_select_set(vc.em->bm, efa, true);
2191       }
2192       else if (deselect) {
2193         BM_select_history_remove(vc.em->bm, efa);
2194         BM_face_select_set(vc.em->bm, efa, false);
2195       }
2196       else {
2197         /* set the last selected face */
2198         BM_mesh_active_face_set(vc.em->bm, efa);
2199
2200         if (!BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
2201           BM_select_history_store(vc.em->bm, efa);
2202           BM_face_select_set(vc.em->bm, efa, true);
2203         }
2204         else if (toggle) {
2205           BM_select_history_remove(vc.em->bm, efa);
2206           BM_face_select_set(vc.em->bm, efa, false);
2207         }
2208       }
2209     }
2210     else if (eed) {
2211       if (extend) {
2212         /* Work-around: deselect first, so we can guarantee it will */
2213         /* be active even if it was already selected */
2214         BM_select_history_remove(vc.em->bm, eed);
2215         BM_edge_select_set(vc.em->bm, eed, false);
2216         BM_select_history_store(vc.em->bm, eed);
2217         BM_edge_select_set(vc.em->bm, eed, true);
2218       }
2219       else if (deselect) {
2220         BM_select_history_remove(vc.em->bm, eed);
2221         BM_edge_select_set(vc.em->bm, eed, false);
2222       }
2223       else {
2224         if (!BM_elem_flag_test(eed, BM_ELEM_SELECT)) {
2225           BM_select_history_store(vc.em->bm, eed);
2226           BM_edge_select_set(vc.em->bm, eed, true);
2227         }
2228         else if (toggle) {
2229           BM_select_history_remove(vc.em->bm, eed);
2230           BM_edge_select_set(vc.em->bm, eed, false);
2231         }
2232       }
2233     }
2234     else if (eve) {
2235       if (extend) {
2236         /* Work-around: deselect first, so we can guarantee it will */
2237         /* be active even if it was already selected */
2238         BM_select_history_remove(vc.em->bm, eve);
2239         BM_vert_select_set(vc.em->bm, eve, false);
2240         BM_select_history_store(vc.em->bm, eve);
2241         BM_vert_select_set(vc.em->bm, eve, true);
2242       }
2243       else if (deselect) {
2244         BM_select_history_remove(vc.em->bm, eve);
2245         BM_vert_select_set(vc.em->bm, eve, false);
2246       }
2247       else {
2248         if (!BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
2249           BM_select_history_store(vc.em->bm, eve);
2250           BM_vert_select_set(vc.em->bm, eve, true);
2251         }
2252         else if (toggle) {
2253           BM_select_history_remove(vc.em->bm, eve);
2254           BM_vert_select_set(vc.em->bm, eve, false);
2255         }
2256       }
2257     }
2258
2259     EDBM_selectmode_flush(vc.em);
2260
2261     if (efa) {
2262       /* Change active material on object. */
2263       if (efa->mat_nr != vc.obedit->actcol - 1) {
2264         vc.obedit->actcol = efa->mat_nr + 1;
2265         vc.em->mat_nr = efa->mat_nr;
2266         WM_event_add_notifier(C, NC_MATERIAL | ND_SHADING_LINKS, NULL);
2267       }
2268
2269       /* Change active face-map on object. */
2270       if (!BLI_listbase_is_empty(&vc.obedit->fmaps)) {
2271         const int cd_fmap_offset = CustomData_get_offset(&vc.em->bm->pdata, CD_FACEMAP);
2272         if (cd_fmap_offset != -1) {
2273           int map = *((int *)BM_ELEM_CD_GET_VOID_P(efa, cd_fmap_offset));
2274           if ((map < -1) || (map > BLI_listbase_count_at_most(&vc.obedit->fmaps, map))) {
2275             map = -1;
2276           }
2277           map += 1;
2278           if (map != vc.obedit->actfmap) {
2279             /* We may want to add notifiers later,
2280              * currently select update handles redraw. */
2281             vc.obedit->actfmap = map;
2282           }
2283         }
2284       }
2285     }
2286
2287     /* Changing active object is handy since it allows us to
2288      * switch UV layers, vgroups for eg. */
2289     if (vc.view_layer->basact != basact) {
2290       ED_object_base_activate(C, basact);
2291     }
2292
2293     DEG_id_tag_update(vc.obedit->data, ID_RECALC_SELECT);
2294     WM_event_add_notifier(C, NC_GEOM | ND_SELECT, vc.obedit->data);
2295
2296     ok = true;
2297   }
2298
2299   MEM_freeN(bases);
2300
2301   return ok;
2302 }
2303
2304 /** \} */
2305
2306 /* -------------------------------------------------------------------- */
2307 /** \name Select Mode Utilities
2308  * \{ */
2309
2310 static void edbm_strip_selections(BMEditMesh *em)
2311 {
2312   BMEditSelection *ese, *nextese;
2313
2314   if (!(em->selectmode & SCE_SELECT_VERTEX)) {
2315     ese = em->bm->selected.first;
2316     while (ese) {
2317       nextese = ese->next;
2318       if (ese->htype == BM_VERT) {
2319         BLI_freelinkN(&(em->bm->selected), ese);
2320       }
2321       ese = nextese;
2322     }
2323   }
2324   if (!(em->selectmode & SCE_SELECT_EDGE)) {
2325     ese = em->bm->selected.first;
2326     while (ese) {
2327       nextese = ese->next;
2328       if (ese->htype == BM_EDGE) {
2329         BLI_freelinkN(&(em->bm->selected), ese);
2330       }
2331       ese = nextese;
2332     }
2333   }
2334   if (!(em->selectmode & SCE_SELECT_FACE)) {
2335     ese = em->bm->selected.first;
2336     while (ese) {
2337       nextese = ese->next;
2338       if (ese->htype == BM_FACE) {
2339         BLI_freelinkN(&(em->bm->selected), ese);
2340       }
2341       ese = nextese;
2342     }
2343   }
2344 }
2345
2346 /* when switching select mode, makes sure selection is consistent for editing */
2347 /* also for paranoia checks to make sure edge or face mode works */
2348 void EDBM_selectmode_set(BMEditMesh *em)
2349 {
2350   BMVert *eve;
2351   BMEdge *eed;
2352   BMFace *efa;
2353   BMIter iter;
2354
2355   em->bm->selectmode = em->selectmode;
2356
2357   /* strip BMEditSelections from em->selected that are not relevant to new mode */
2358   edbm_strip_selections(em);
2359
2360   if (em->bm->totvertsel == 0 && em->bm->totedgesel == 0 && em->bm->totfacesel == 0) {
2361     return;
2362   }
2363
2364   if (em->selectmode & SCE_SELECT_VERTEX) {
2365     if (em->bm->totvertsel) {
2366       EDBM_select_flush(em);
2367     }
2368   }
2369   else if (em->selectmode & SCE_SELECT_EDGE) {
2370     /* deselect vertices, and select again based on edge select */
2371     BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
2372       BM_vert_select_set(em->bm, eve, false);
2373     }
2374
2375     if (em->bm->totedgesel) {
2376       BM_ITER_MESH (eed, &iter, em->bm, BM_EDGES_OF_MESH) {
2377         if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) {
2378           BM_edge_select_set(em->bm, eed, true);
2379         }
2380       }
2381
2382       /* selects faces based on edge status */
2383       EDBM_selectmode_flush(em);
2384     }
2385   }
2386   else if (em->selectmode & SCE_SELECT_FACE) {
2387     /* deselect eges, and select again based on face select */
2388     BM_ITER_MESH (eed, &iter, em->bm, BM_EDGES_OF_MESH) {
2389       BM_edge_select_set(em->bm, eed, false);
2390     }
2391
2392     if (em->bm->totfacesel) {
2393       BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
2394         if (BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
2395           BM_face_select_set(em->bm, efa, true);
2396         }
2397       }
2398     }
2399   }
2400 }
2401
2402 /**
2403  * Expand & Contract the Selection
2404  * (used when changing modes and Ctrl key held)
2405  *
2406  * Flush the selection up:
2407  * - vert -> edge
2408  * - vert -> face
2409  * - edge -> face
2410  *
2411  * Flush the selection down:
2412  * - face -> edge
2413  * - face -> vert
2414  * - edge -> vert
2415  */
2416 void EDBM_selectmode_convert(BMEditMesh *em,
2417                              const short selectmode_old,
2418                              const short selectmode_new)
2419 {
2420   BMesh *bm = em->bm;
2421
2422   BMVert *eve;
2423   BMEdge *eed;
2424   BMFace *efa;
2425   BMIter iter;
2426
2427   /* first tag-to-select, then select --- this avoids a feedback loop */
2428
2429   /* have to find out what the selectionmode was previously */
2430   if (selectmode_old == SCE_SELECT_VERTEX) {
2431     if (bm->totvertsel == 0) {
2432       /* pass */
2433     }
2434     else if (selectmode_new == SCE_SELECT_EDGE) {
2435       /* flush up (vert -> edge) */
2436
2437       /* select all edges associated with every selected vert */
2438       BM_ITER_MESH (eed, &iter, bm, BM_EDGES_OF_MESH) {
2439         BM_elem_flag_set(eed, BM_ELEM_TAG, BM_edge_is_any_vert_flag_test(eed, BM_ELEM_SELECT));
2440       }
2441
2442       BM_ITER_MESH (eed, &iter, bm, BM_EDGES_OF_MESH) {
2443         if (BM_elem_flag_test(eed, BM_ELEM_TAG)) {
2444           BM_edge_select_set(bm, eed, true);
2445         }
2446       }
2447     }
2448     else if (selectmode_new == SCE_SELECT_FACE) {
2449       /* flush up (vert -> face) */
2450
2451       /* select all faces associated with every selected vert */
2452       BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
2453         BM_elem_flag_set(efa, BM_ELEM_TAG, BM_face_is_any_vert_flag_test(efa, BM_ELEM_SELECT));
2454       }
2455
2456       BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
2457         if (BM_elem_flag_test(efa, BM_ELEM_TAG)) {
2458           BM_face_select_set(bm, efa, true);
2459         }
2460       }
2461     }
2462   }
2463   else if (selectmode_old == SCE_SELECT_EDGE) {
2464     if (bm->totedgesel == 0) {
2465       /* pass */
2466     }
2467     else if (selectmode_new == SCE_SELECT_FACE) {
2468       /* flush up (edge -> face) */
2469
2470       /* select all faces associated with every selected edge */
2471       BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
2472         BM_elem_flag_set(efa, BM_ELEM_TAG, BM_face_is_any_edge_flag_test(efa, BM_ELEM_SELECT));
2473       }
2474
2475       BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
2476         if (BM_elem_flag_test(efa, BM_ELEM_TAG)) {
2477           BM_face_select_set(bm, efa, true);
2478         }
2479       }
2480     }
2481     else if (selectmode_new == SCE_SELECT_VERTEX) {
2482       /* flush down (edge -> vert) */
2483
2484       BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
2485         if (!BM_vert_is_all_edge_flag_test(eve, BM_ELEM_SELECT, true)) {
2486           BM_vert_select_set(bm, eve, false);
2487         }
2488       }
2489       /* deselect edges without both verts selected */
2490       BM_mesh_deselect_flush(bm);
2491     }
2492   }
2493   else if (selectmode_old == SCE_SELECT_FACE) {
2494     if (bm->totfacesel == 0) {
2495       /* pass */
2496     }
2497     else if (selectmode_new == SCE_SELECT_EDGE) {
2498       /* flush down (face -> edge) */
2499
2500       BM_ITER_MESH (eed, &iter, bm, BM_EDGES_OF_MESH) {
2501         if (!BM_edge_is_all_face_flag_test(eed, BM_ELEM_SELECT, true)) {
2502           BM_edge_select_set(bm, eed, false);
2503         }
2504       }
2505     }
2506     else if (selectmode_new == SCE_SELECT_VERTEX) {
2507       /* flush down (face -> vert) */
2508
2509       BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
2510         if (!BM_vert_is_all_face_flag_test(eve, BM_ELEM_SELECT, true)) {
2511           BM_vert_select_set(bm, eve, false);
2512         }
2513       }
2514       /* deselect faces without verts selected */
2515       BM_mesh_deselect_flush(bm);
2516     }
2517   }
2518 }
2519
2520 /* user facing function, does notification */
2521 bool EDBM_selectmode_toggle(bContext *C,
2522                             const short selectmode_new,
2523                             const int action,
2524                             const bool use_extend,
2525                             const bool use_expand)
2526 {
2527   Scene *scene = CTX_data_scene(C);
2528   ViewLayer *view_layer = CTX_data_view_layer(C);
2529   ToolSettings *ts = CTX_data_tool_settings(C);
2530   Object *obedit = CTX_data_edit_object(C);
2531   BMEditMesh *em = NULL;
2532   bool ret = false;
2533
2534   if (obedit && obedit->type == OB_MESH) {
2535     em = BKE_editmesh_from_object(obedit);
2536   }
2537
2538   if (em == NULL) {
2539     return ret;
2540   }
2541
2542   bool only_update = false;
2543   switch (action) {
2544     case -1:
2545       /* already set */
2546       break;
2547     case 0: /* disable */
2548       /* check we have something to do */
2549       if ((em->selectmode & selectmode_new) == 0) {
2550         only_update = true;
2551         break;
2552       }
2553       em->selectmode &= ~selectmode_new;
2554       break;
2555     case 1: /* enable */
2556       /* check we have something to do */
2557       if ((em->selectmode & selectmode_new) != 0) {
2558         only_update = true;
2559         break;
2560       }
2561       em->selectmode |= selectmode_new;
2562       break;
2563     case 2: /* toggle */
2564       /* can't disable this flag if its the only one set */
2565       if (em->selectmode == selectmode_new) {
2566         only_update = true;
2567         break;
2568       }
2569       em->selectmode ^= selectmode_new;
2570       break;
2571     default:
2572       BLI_assert(0);
2573       break;
2574   }
2575
2576   uint objects_len = 0;
2577   Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(
2578       view_layer, CTX_wm_view3d(C), &objects_len);
2579
2580   for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
2581     Object *ob_iter = objects[ob_index];
2582     BMEditMesh *em_iter = BKE_editmesh_from_object(ob_iter);
2583     if (em_iter != em) {
2584       em_iter->selectmode = em->selectmode;
2585     }
2586   }
2587
2588   if (only_update) {
2589     MEM_freeN(objects);
2590     return false;
2591   }
2592
2593   if (use_extend == 0 || em->selectmode == 0) {
2594     if (use_expand) {
2595       const short selmode_max = highest_order_bit_s(ts->selectmode);
2596       for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
2597         Object *ob_iter = objects[ob_index];
2598         BMEditMesh *em_iter = BKE_editmesh_from_object(ob_iter);
2599         EDBM_selectmode_convert(em_iter, selmode_max, selectmode_new);
2600       }
2601     }
2602   }
2603
2604   switch (selectmode_new) {
2605     case SCE_SELECT_VERTEX:
2606       if (use_extend == 0 || em->selectmode == 0) {
2607         em->selectmode = SCE_SELECT_VERTEX;
2608       }
2609       ret = true;
2610       break;
2611     case SCE_SELECT_EDGE:
2612       if (use_extend == 0 || em->selectmode == 0) {
2613         em->selectmode = SCE_SELECT_EDGE;
2614       }
2615       ret = true;
2616       break;
2617     case SCE_SELECT_FACE:
2618       if (use_extend == 0 || em->selectmode == 0) {
2619         em->selectmode = SCE_SELECT_FACE;
2620       }
2621       ret = true;
2622       break;
2623     default:
2624       BLI_assert(0);
2625       break;
2626   }
2627
2628   if (ret == true) {
2629     ts->selectmode = em->selectmode;
2630     em = NULL;
2631     for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
2632       Object *ob_iter = objects[ob_index];
2633       BMEditMesh *em_iter = BKE_editmesh_from_object(ob_iter);
2634       em_iter->selectmode = ts->selectmode;
2635       EDBM_selectmode_set(em_iter);
2636       DEG_id_tag_update(ob_iter->data, ID_RECALC_COPY_ON_WRITE | ID_RECALC_SELECT);
2637       WM_event_add_notifier(C, NC_GEOM | ND_SELECT, ob_iter->data);
2638     }
2639     WM_main_add_notifier(NC_SCENE | ND_TOOLSETTINGS, NULL);
2640     DEG_id_tag_update(&scene->id, ID_RECALC_COPY_ON_WRITE);
2641   }
2642
2643   MEM_freeN(objects);
2644   return ret;
2645 }
2646
2647 /**
2648  * Use to disable a selectmode if its enabled, Using another mode as a fallback
2649  * if the disabled mode is the only mode set.
2650  *
2651  * \return true if the mode is changed.
2652  */
2653 bool EDBM_selectmode_disable(Scene *scene,
2654                              BMEditMesh *em,
2655                              const short selectmode_disable,
2656                              const short selectmode_fallback)
2657 {
2658   /* note essential, but switch out of vertex mode since the
2659    * selected regions wont be nicely isolated after flushing */
2660   if (em->selectmode & selectmode_disable) {
2661     if (em->selectmode == selectmode_disable) {
2662       em->selectmode = selectmode_fallback;
2663     }
2664     else {
2665       em->selectmode &= ~selectmode_disable;
2666     }
2667     scene->toolsettings->selectmode = em->selectmode;
2668     EDBM_selectmode_set(em);
2669
2670     WM_main_add_notifier(NC_SCENE | ND_TOOLSETTINGS, scene);
2671
2672     return true;
2673   }
2674   else {
2675     return false;
2676   }
2677 }
2678
2679 /** \} */
2680
2681 /* -------------------------------------------------------------------- */
2682 /** \name Select Toggle
2683  * \{ */
2684
2685 bool EDBM_deselect_by_material(BMEditMesh *em, const short index, const bool select)
2686 {
2687   BMIter iter;
2688   BMFace *efa;
2689   bool changed = false;
2690
2691   BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
2692     if (BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
2693       continue;
2694     }
2695     if (efa->mat_nr == index) {
2696       changed = true;
2697       BM_face_select_set(em->bm, efa, select);
2698     }
2699   }
2700   return changed;
2701 }
2702
2703 void EDBM_select_toggle_all(BMEditMesh *em) /* exported for UV */
2704 {
2705   if (em->bm->totvertsel || em->bm->totedgesel || em->bm->totfacesel) {
2706     EDBM_flag_disable_all(em, BM_ELEM_SELECT);
2707   }
2708   else {
2709     EDBM_flag_enable_all(em, BM_ELEM_SELECT);
2710   }
2711 }
2712
2713 void EDBM_select_swap(BMEditMesh *em) /* exported for UV */
2714 {
2715   BMIter iter;
2716   BMVert *eve;
2717   BMEdge *eed;
2718   BMFace *efa;
2719
2720   if (em->bm->selectmode & SCE_SELECT_VERTEX) {
2721     BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
2722       if (BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) {
2723         continue;
2724       }
2725       BM_vert_select_set(em->bm, eve, !BM_elem_flag_test(eve, BM_ELEM_SELECT));
2726     }
2727   }
2728   else if (em->selectmode & SCE_SELECT_EDGE) {
2729     BM_ITER_MESH (eed, &iter, em->bm, BM_EDGES_OF_MESH) {
2730       if (BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
2731         continue;
2732       }
2733       BM_edge_select_set(em->bm, eed, !BM_elem_flag_test(eed, BM_ELEM_SELECT));
2734     }
2735   }
2736   else {
2737     BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
2738       if (BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
2739         continue;
2740       }
2741       BM_face_select_set(em->bm, efa, !BM_elem_flag_test(efa, BM_ELEM_SELECT));
2742     }
2743   }
2744 }
2745
2746 bool EDBM_mesh_deselect_all_multi_ex(struct Base **bases, const uint bases_len)
2747 {
2748   bool changed_multi = false;
2749   for (uint base_index = 0; base_index < bases_len; base_index++) {
2750     Base *base_iter = bases[base_index];
2751     Object *ob_iter = base_iter->object;
2752     BMEditMesh *em_iter = BKE_editmesh_from_object(ob_iter);
2753
2754     if (em_iter->bm->totvertsel == 0) {
2755       continue;
2756     }
2757
2758     EDBM_flag_disable_all(em_iter, BM_ELEM_SELECT);
2759     DEG_id_tag_update(ob_iter->data, ID_RECALC_SELECT);
2760     changed_multi = true;
2761   }
2762   return changed_multi;
2763 }
2764
2765 bool EDBM_mesh_deselect_all_multi(struct bContext *C)
2766 {
2767   ViewContext vc;
2768   ED_view3d_viewcontext_init(C, &vc);
2769   uint bases_len = 0;
2770   Base **bases = BKE_view_layer_array_from_bases_in_edit_mode_unique_data(
2771       vc.view_layer, vc.v3d, &bases_len);
2772   bool changed_multi = EDBM_mesh_deselect_all_multi_ex(bases, bases_len);
2773   MEM_freeN(bases);
2774   return changed_multi;
2775 }
2776
2777 /** \} */
2778
2779 /* -------------------------------------------------------------------- */
2780 /** \name Select Interior Faces
2781  *
2782  * \note This algorithm is limited to single faces and could be improved, see:
2783  * https://blender.stackexchange.com/questions/18916
2784  * \{ */
2785
2786 bool EDBM_select_interior_faces(BMEditMesh *em)
2787 {
2788   BMesh *bm = em->bm;
2789   BMIter iter;
2790   BMIter eiter;
2791   BMFace *efa;
2792   BMEdge *eed;
2793   bool ok;
2794   bool changed = false;
2795
2796   BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
2797     if (BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
2798       continue;
2799     }
2800
2801     ok = true;
2802     BM_ITER_ELEM (eed, &eiter, efa, BM_EDGES_OF_FACE) {
2803       if (!BM_edge_face_count_is_over(eed, 2)) {
2804         ok = false;
2805         break;
2806       }
2807     }
2808
2809     if (ok) {
2810       BM_face_select_set(bm, efa, true);
2811       changed = true;
2812     }
2813   }
2814
2815   return changed;
2816 }
2817
2818 /** \} */
2819
2820 /* -------------------------------------------------------------------- */
2821 /** \name Select Linked Operator
2822  *
2823  * Support delimiting on different edge properties.
2824  * \{ */
2825
2826 /* so we can have last-used default depend on selection mode (rare exception!) */
2827 #define USE_LINKED_SELECT_DEFAULT_HACK
2828
2829 struct DelimitData {
2830   int cd_loop_type;
2831   int cd_loop_offset;
2832 };
2833
2834 static bool select_linked_delimit_test(BMEdge *e,
2835                                        int delimit,
2836                                        const struct DelimitData *delimit_data)
2837 {
2838   BLI_assert(delimit);
2839
2840   if (delimit & BMO_DELIM_SEAM) {
2841     if (BM_elem_flag_test(e, BM_ELEM_SEAM)) {
2842       return true;
2843     }
2844   }
2845
2846   if (delimit & BMO_DELIM_SHARP) {
2847     if (BM_elem_flag_test(e, BM_ELEM_SMOOTH) == 0) {
2848       return true;
2849     }
2850   }
2851
2852   if (delimit & BMO_DELIM_NORMAL) {
2853     if (!BM_edge_is_contiguous(e)) {
2854       return true;
2855     }
2856   }
2857
2858   if (delimit & BMO_DELIM_MATERIAL) {
2859     if (e->l && e->l->radial_next != e->l) {
2860       const short mat_nr = e->l->f->mat_nr;
2861       BMLoop *l_iter = e->l->radial_next;
2862       do {
2863         if (l_iter->f->mat_nr != mat_nr) {
2864           return true;
2865         }
2866       } while ((l_iter = l_iter->radial_next) != e->l);
2867     }
2868   }
2869
2870   if (delimit & BMO_DELIM_UV) {
2871     if (BM_edge_is_contiguous_loop_cd(
2872             e, delimit_data->cd_loop_type, delimit_data->cd_loop_offset) == 0) {
2873       return true;
2874     }
2875   }
2876
2877   return false;
2878 }
2879
2880 #ifdef USE_LINKED_SELECT_DEFAULT_HACK
2881 /**
2882  * Gets the default from the operator fallback to own last-used value
2883  * (selected based on mode)
2884  */
2885 static int select_linked_delimit_default_from_op(wmOperator *op, const int select_mode)
2886 {
2887   static char delimit_last_store[2] = {0, BMO_DELIM_SEAM};
2888   int delimit_last_index = (select_mode & (SCE_SELECT_VERTEX | SCE_SELECT_EDGE)) == 0;
2889   char *delimit_last = &delimit_last_store[delimit_last_index];
2890   PropertyRNA *prop_delimit = RNA_struct_find_property(op->ptr, "delimit");
2891   int delimit;
2892
2893   if (RNA_property_is_set(op->ptr, prop_delimit)) {
2894     delimit = RNA_property_enum_get(op->ptr, prop_delimit);
2895     *delimit_last = delimit;
2896   }
2897   else {
2898     delimit = *delimit_last;
2899     RNA_property_enum_set(op->ptr, prop_delimit, delimit);
2900   }
2901   return delimit;
2902 }
2903 #endif
2904
2905 static void select_linked_delimit_validate(BMesh *bm, int *delimit)
2906 {
2907   if ((*delimit) & BMO_DELIM_UV) {
2908     if (!CustomData_has_layer(&bm->ldata, CD_MLOOPUV)) {
2909       (*delimit) &= ~BMO_DELIM_UV;
2910     }
2911   }
2912 }
2913
2914 static void select_linked_delimit_begin(BMesh *bm, int delimit)
2915 {
2916   struct DelimitData delimit_data = {0};
2917
2918   if (delimit & BMO_DELIM_UV) {
2919     delimit_data.cd_loop_type = CD_MLOOPUV;
2920     delimit_data.cd_loop_offset = CustomData_get_offset(&bm->ldata, delimit_data.cd_loop_type);
2921     if (delimit_data.cd_loop_offset == -1) {
2922       delimit &= ~BMO_DELIM_UV;
2923     }
2924   }
2925
2926   /* grr, shouldn't need to alloc BMO flags here */
2927   BM_mesh_elem_toolflags_ensure(bm);
2928
2929   {
2930     BMIter iter;
2931     BMEdge *e;
2932
2933     BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
2934       const bool is_walk_ok = ((select_linked_delimit_test(e, delimit, &delimit_data) == false));
2935
2936       BMO_edge_flag_set(bm, e, BMO_ELE_TAG, is_walk_ok);
2937     }
2938   }
2939 }
2940
2941 static void select_linked_delimit_end(BMEditMesh *em)
2942 {
2943   BMesh *bm = em->bm;
2944
2945   BM_mesh_elem_toolflags_clear(bm);
2946 }
2947
2948 static int edbm_select_linked_exec(bContext *C, wmOperator *op)
2949 {
2950   Scene *scene = CTX_data_scene(C);
2951   ViewLayer *view_layer = CTX_data_view_layer(C);
2952
2953 #ifdef USE_LINKED_SELECT_DEFAULT_HACK
2954   const int delimit_init = select_linked_delimit_default_from_op(op,
2955                                                                  scene->toolsettings->selectmode);
2956 #else
2957   const int delimit_init = RNA_enum_get(op->ptr, "delimit");
2958 #endif
2959
2960   uint objects_len = 0;
2961   Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(
2962       view_layer, CTX_wm_view3d(C), &objects_len);
2963
2964   for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
2965     Object *obedit = objects[ob_index];
2966
2967     BMEditMesh *em = BKE_editmesh_from_object(obedit);
2968     BMesh *bm = em->bm;
2969     BMIter iter;
2970     BMWalker walker;
2971
2972     int delimit = delimit_init;
2973
2974     select_linked_delimit_validate(bm, &delimit);
2975
2976     if (delimit) {
2977       select_linked_delimit_begin(em->bm, delimit);
2978     }
2979
2980     if (em->selectmode & SCE_SELECT_VERTEX) {
2981       BMVert *v;
2982
2983       BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
2984         BM_elem_flag_set(v, BM_ELEM_TAG, BM_elem_flag_test(v, BM_ELEM_SELECT));
2985       }
2986
2987       /* exclude all delimited verts */
2988       if (delimit) {
2989         BMEdge *e;
2990         BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
2991           if (!BMO_edge_flag_test(bm, e, BMO_ELE_TAG)) {
2992             BM_elem_flag_disable(e->v1, BM_ELEM_TAG);
2993             BM_elem_flag_disable(e->v2, BM_ELEM_TAG);
2994           }
2995         }
2996       }
2997
2998       BMW_init(&walker,
2999                em->bm,
3000                delimit ? BMW_LOOP_SHELL_WIRE : BMW_VERT_SHELL,
3001                BMW_MASK_NOP,
3002                delimit ? BMO_ELE_TAG : BMW_MASK_NOP,
3003                BMW_MASK_NOP,
3004                BMW_FLAG_TEST_HIDDEN,
3005                BMW_NIL_LAY);
3006
3007       if (delimit) {
3008         BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
3009           if (BM_elem_flag_test(v, BM_ELEM_TAG)) {
3010             BMElem *ele_walk;
3011             BMW_ITER (ele_walk, &walker, v) {
3012               if (ele_walk->head.htype == BM_LOOP) {
3013                 BMVert *v_step = ((BMLoop *)ele_walk)->v;
3014                 BM_vert_select_set(em->bm, v_step, true);
3015                 BM_elem_flag_disable(v_step, BM_ELEM_TAG);
3016               }
3017               else {
3018                 BMEdge *e_step = (BMEdge *)ele_walk;
3019                 BLI_assert(ele_walk->head.htype == BM_EDGE);
3020                 BM_edge_select_set(em->bm, e_step, true);
3021                 BM_elem_flag_disable(e_step->v1, BM_ELEM_TAG);
3022                 BM_elem_flag_disable(e_step->v2, BM_ELEM_TAG);
3023               }
3024             }
3025           }
3026         }
3027       }
3028       else {
3029         BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
3030           if (BM_elem_flag_test(v, BM_ELEM_TAG)) {
3031             BMEdge *e_walk;
3032             BMW_ITER (e_walk, &walker, v) {
3033               BM_edge_select_set(em->bm, e_walk, true);
3034               BM_elem_flag_disable(e_walk, BM_ELEM_TAG);
3035             }
3036           }
3037         }
3038       }
3039
3040       BMW_end(&walker);
3041
3042       EDBM_selectmode_flush(em);
3043     }
3044     else if (em->selectmode & SCE_SELECT_EDGE) {
3045       BMEdge *e;
3046
3047       if (delimit) {
3048         BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
3049           BM_elem_flag_set(
3050               e,
3051               BM_ELEM_TAG,
3052               (BM_elem_flag_test(e, BM_ELEM_SELECT) && BMO_edge_flag_test(bm, e, BMO_ELE_TAG)));
3053         }
3054       }
3055       else {
3056         BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
3057           BM_elem_flag_set(e, BM_ELEM_TAG, BM_elem_flag_test(e, BM_ELEM_SELECT));
3058         }
3059       }
3060
3061       BMW_init(&walker,
3062                em->bm,
3063                delimit ? BMW_LOOP_SHELL_WIRE : BMW_VERT_SHELL,
3064                BMW_MASK_NOP,
3065                delimit ? BMO_ELE_TAG : BMW_MASK_NOP,
3066                BMW_MASK_NOP,
3067                BMW_FLAG_TEST_HIDDEN,
3068                BMW_NIL_LAY);
3069
3070       if (delimit) {
3071         BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
3072           if (BM_elem_flag_test(e, BM_ELEM_TAG)) {
3073             BMElem *ele_walk;
3074             BMW_ITER (ele_walk, &walker, e) {
3075               if (ele_walk->head.htype == BM_LOOP) {
3076                 BMLoop *l_step = (BMLoop *)ele_walk;
3077                 BM_edge_select_set(em->bm, l_step->e, true);
3078                 BM_edge_select_set(em->bm, l_step->prev->e, true);
3079                 BM_elem_flag_disable(l_step->e, BM_ELEM_TAG);
3080               }
3081               else {
3082                 BMEdge *e_step = (BMEdge *)ele_walk;
3083                 BLI_assert(ele_walk->head.htype == BM_EDGE);
3084                 BM_edge_select_set(em->bm, e_step, true);
3085                 BM_elem_flag_disable(e_step, BM_ELEM_TAG);
3086               }
3087             }
3088           }
3089         }
3090       }
3091       else {
3092         BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
3093           if (BM_elem_flag_test(e, BM_ELEM_TAG)) {
3094             BMEdge *e_walk;
3095             BMW_ITER (e_walk, &walker, e) {
3096               BM_edge_select_set(em->bm, e_walk, true);
3097               BM_elem_flag_disable(e_walk, BM_ELEM_TAG);
3098             }
3099           }
3100         }
3101       }
3102
3103       BMW_end(&walker);
3104
3105       EDBM_selectmode_flush(em);
3106     }
3107     else {
3108       BMFace *f;
3109
3110       BM_ITER_MESH (f, &iter, em->bm, BM_FACES_OF_MESH) {
3111         BM_elem_flag_set(f, BM_ELEM_TAG, BM_elem_flag_test(f, BM_ELEM_SELECT));
3112       }
3113
3114       BMW_init(&walker,
3115                bm,
3116                BMW_ISLAND,
3117                BMW_MASK_NOP,
3118                delimit ? BMO_ELE_TAG : BMW_MASK_NOP,
3119                BMW_MASK_NOP,
3120                BMW_FLAG_TEST_HIDDEN,
3121                BMW_NIL_LAY);
3122
3123       BM_ITER_MESH (f, &iter, em->bm, BM_FACES_OF_MESH) {
3124         if (BM_elem_flag_test(f, BM_ELEM_TAG)) {
3125           BMFace *f_walk;
3126           BMW_ITER (f_walk, &walker, f) {
3127             BM_face_select_set(bm, f_walk, true);
3128             BM_elem_flag_disable(f_walk, BM_ELEM_TAG);
3129           }
3130         }
3131       }
3132
3133       BMW_end(&walker);
3134     }
3135
3136     if (delimit) {
3137       select_linked_delimit_end(em);
3138     }
3139
3140     DEG_id_tag_update(obedit->data, ID_RECALC_SELECT);
3141     WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit->data);
3142   }
3143
3144   MEM_freeN(objects);
3145
3146   return OPERATOR_FINISHED;
3147 }
3148
3149 void MESH_OT_select_linked(wmOperatorType *ot)
3150 {
3151   PropertyRNA *prop;
3152
3153   /* identifiers */
3154   ot->name = "Select Linked All";
3155   ot->idname = "MESH_OT_select_linked";
3156   ot->description = "Select all vertices connected to the current selection";
3157
3158   /* api callbacks */
3159   ot->exec = edbm_select_linked_exec;
3160   ot->poll = ED_operator_editmesh;
3161
3162   /* flags */
3163   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
3164
3165   prop = RNA_def_enum_flag(ot->srna,
3166                            "delimit",
3167                            rna_enum_mesh_delimit_mode_items,
3168                            BMO_DELIM_SEAM,
3169                            "Delimit",
3170                            "Delimit selected region");
3171 #ifdef USE_LINKED_SELECT_DEFAULT_HACK
3172   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
3173 #else
3174   UNUSED_VARS(prop);
3175 #endif
3176 }
3177
3178 /** \} */
3179
3180 /* -------------------------------------------------------------------- */
3181 /** \name Select Linked (Cursor Pick) Operator
3182  * \{ */
3183
3184 static int edbm_select_linked_pick_exec(bContext *C, wmOperator *op);
3185
3186 static void edbm_select_linked_pick_ex(BMEditMesh *em, BMElem *ele, bool sel, int delimit)
3187 {
3188   BMesh *bm = em->bm;
3189   BMWalker walker;
3190
3191   select_linked_delimit_validate(bm, &delimit);
3192
3193   if (delimit) {
3194     select_linked_delimit_begin(bm, delimit);
3195   }
3196
3197   /* Note: logic closely matches 'edbm_select_linked_exec', keep in sync */
3198
3199   if (ele->head.htype == BM_VERT) {
3200     BMVert *eve = (BMVert *)ele;
3201
3202     BMW_init(&walker,
3203              bm,
3204              delimit ? BMW_LOOP_SHELL_WIRE : BMW_VERT_SHELL,
3205              BMW_MASK_NOP,
3206              delimit ? BMO_ELE_TAG : BMW_MASK_NOP,
3207              BMW_MASK_NOP,
3208              BMW_FLAG_TEST_HIDDEN,
3209              BMW_NIL_LAY);
3210
3211     if (delimit) {
3212       BMElem *ele_walk;
3213       BMW_ITER (ele_walk, &walker, eve) {
3214         if (ele_walk->head.htype == BM_LOOP) {
3215           BMVert *v_step = ((BMLoop *)ele_walk)->v;
3216           BM_vert_select_set(bm, v_step, sel);
3217         }
3218         else {
3219           BMEdge *e_step = (BMEdge *)ele_walk;
3220           BLI_assert(ele_walk->head.htype == BM_EDGE);
3221           BM_edge_select_set(bm, e_step, sel);
3222         }
3223       }
3224     }
3225     else {
3226       BMEdge *e_walk;
3227       BMW_ITER (e_walk, &walker, eve) {
3228         BM_edge_select_set(bm, e_walk, sel);
3229       }
3230     }
3231
3232     BMW_end(&walker);
3233
3234     EDBM_selectmode_flush(em);
3235   }
3236   else if (ele->head.htype == BM_EDGE) {
3237     BMEdge *eed = (BMEdge *)ele;
3238
3239     BMW_init(&walker,
3240              bm,
3241              delimit ? BMW_LOOP_SHELL_WIRE : BMW_VERT_SHELL,
3242              BMW_MASK_NOP,
3243              delimit ? BMO_ELE_TAG : BMW_MASK_NOP,
3244              BMW_MASK_NOP,
3245              BMW_FLAG_TEST_HIDDEN,
3246              BMW_NIL_LAY);
3247
3248     if (delimit) {
3249       BMElem *ele_walk;
3250       BMW_ITER (ele_walk, &walker, eed) {
3251         if (ele_walk->head.htype == BM_LOOP) {
3252           BMEdge *e_step = ((BMLoop *)ele_walk)->e;
3253           BM_edge_select_set(bm, e_step, sel);
3254         }
3255         else {
3256           BMEdge *e_step = (BMEdge *)ele_walk;
3257           BLI_assert(ele_walk->head.htype == BM_EDGE);
3258           BM_edge_select_set(bm, e_step, sel);
3259         }
3260       }
3261     }
3262     else {
3263       BMEdge *e_walk;
3264       BMW_ITER (e_walk, &walker, eed) {
3265         BM_edge_select_set(bm, e_walk, sel);
3266       }
3267     }
3268
3269     BMW_end(&walker);
3270
3271     EDBM_selectmode_flush(em);
3272   }
3273   else if (ele->head.htype == BM_FACE) {
3274     BMFace *efa = (BMFace *)ele;
3275
3276     BMW_init(&walker,
3277              bm,
3278              BMW_ISLAND,
3279              BMW_MASK_NOP,
3280              delimit ? BMO_ELE_TAG : BMW_MASK_NOP,
3281              BMW_MASK_NOP,
3282              BMW_FLAG_TEST_HIDDEN,
3283              BMW_NIL_LAY);
3284
3285     {
3286       BMFace *f_walk;
3287       BMW_ITER (f_walk, &walker, efa) {
3288         BM_face_select_set(bm, f_walk, sel);
3289         BM_elem_flag_disable(f_walk, BM_ELEM_TAG);
3290       }
3291     }
3292
3293     BMW_end(&walker);
3294   }
3295
3296   if (delimit) {
3297     select_linked_delimit_end(em);
3298   }
3299 }
3300
3301 static int edbm_select_linked_pick_invoke(bContext *C, wmOperator *op, const wmEvent *event)
3302 {
3303   ViewContext vc;
3304   Base *basact = NULL;
3305   BMVert *eve;
3306   BMEdge *eed;
3307   BMFace *efa;
3308   const bool sel = !RNA_boolean_get(op->ptr, "deselect");
3309   int index;
3310
3311   if (RNA_struct_property_is_set(op->ptr, "index")) {
3312     return edbm_select_linked_pick_exec(C, op);
3313   }
3314
3315   /* unified_finednearest needs ogl */
3316   view3d_operator_needs_opengl(C);
3317
3318   /* setup view context for argument to callbacks */
3319   em_setup_viewcontext(C, &vc);
3320
3321   uint bases_len;
3322   Base **bases = BKE_view_layer_array_from_bases_in_edit_mode(vc.view_layer, vc.v3d, &bases_len);
3323
3324   {
3325     bool has_edges = false;
3326     for (uint base_index = 0; base_index < bases_len; base_index++) {
3327       Object *ob_iter = bases[base_index]->object;
3328       ED_view3d_viewcontext_init_object(&vc, ob_iter);
3329       if (vc.em->bm->totedge) {
3330         has_edges = true;
3331       }
3332     }
3333     if (has_edges == false) {
3334       MEM_freeN(bases);
3335       return OPERATOR_CANCELLED;
3336     }
3337   }
3338
3339   vc.mval[0] = event->mval[0];
3340   vc.mval[1] = event->mval[1];
3341
3342   /* return warning! */
3343   {
3344     int base_index = -1;
3345     const bool ok = unified_findnearest(&vc, bases, bases_len, &base_index, &eve, &eed, &efa);
3346     if (!ok) {
3347       MEM_freeN(bases);
3348       return OPERATOR_CANCELLED;
3349     }
3350     basact = bases[base_index];
3351   }
3352
3353   ED_view3d_viewcontext_init_object(&vc, basact->object);
3354   BMEditMesh *em = vc.em;
3355   BMesh *bm = em->bm;
3356
3357 #ifdef USE_LINKED_SELECT_DEFAULT_HACK
3358   int delimit = select_linked_delimit_default_from_op(op, vc.scene->toolsettings->selectmode);
3359 #else
3360   int delimit = RNA_enum_get(op->ptr, "delimit");
3361 #endif
3362
3363   BMElem *ele = EDBM_elem_from_selectmode(em, eve, eed, efa);
3364
3365   edbm_select_linked_pick_ex(em, ele, sel, delimit);
3366
3367   /* to support redo */
3368   BM_mesh_elem_index_ensure(bm, ele->head.htype);
3369   index = EDBM_elem_to_index_any(em, ele);
3370
3371   /* TODO(MULTI_EDIT), index doesn't know which object,
3372    * index selections isn't very common. */
3373   RNA_int_set(op->ptr, "index", index);
3374
3375   DEG_id_tag_update(basact->object->data, ID_RECALC_SELECT);
3376   WM_event_add_notifier(C, NC_GEOM | ND_SELECT, basact->object->data);
3377
3378   MEM_freeN(bases);
3379   return OPERATOR_FINISHED;
3380 }
3381
3382 static int edbm_select_linked_pick_exec(bContext *C, wmOperator *op)
3383 {
3384   Object *obedit = CTX_data_edit_object(C);
3385   BMEditMesh *em = BKE_editmesh_from_object(obedit);
3386   BMesh *bm = em->bm;
3387   int index;
3388   const bool sel = !RNA_boolean_get(op->ptr, "deselect");
3389
3390   index = RNA_int_get(op->ptr, "index");
3391   if (index < 0 || index >= (bm->totvert + bm->totedge + bm->totface)) {
3392     return OPERATOR_CANCELLED;
3393   }
3394
3395   BMElem *ele = EDBM_elem_from_index_any(em, index);
3396
3397 #ifdef USE_LINKED_SELECT_DEFAULT_HACK
3398   int delimit = select_linked_delimit_default_from_op(op, em->selectmode);
3399 #else
3400   int delimit = RNA_enum_get(op->ptr, "delimit");
3401 #endif
3402
3403   edbm_select_linked_pick_ex(em, ele, sel, delimit);
3404
3405   DEG_id_tag_update(obedit->data, ID_RECALC_SELECT);
3406   WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit->data);
3407
3408   return OPERATOR_FINISHED;
3409 }
3410
3411 void MESH_OT_select_linked_pick(wmOperatorType *ot)
3412 {
3413   PropertyRNA *prop;
3414
3415   /* identifiers */
3416   ot->name = "Select Linked";
3417   ot->idname = "MESH_OT_select_linked_pick";
3418   ot->description = "(De)select all vertices linked to the edge under the mouse cursor";
3419
3420   /* api callbacks */
3421   ot->invoke = edbm_select_linked_pick_invoke;
3422   ot->exec = edbm_select_linked_pick_exec;
3423   ot->poll = ED_operator_editmesh;
3424
3425   /* flags */
3426   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
3427
3428   RNA_def_boolean(ot->srna, "deselect", 0, "Deselect", "");
3429   prop = RNA_def_enum_flag(ot->srna,
3430                            "delimit",
3431                            rna_enum_mesh_delimit_mode_items,
3432                            BMO_DELIM_SEAM,
3433                            "Delimit",
3434                            "Delimit selected region");
3435 #ifdef USE_LINKED_SELECT_DEFAULT_HACK
3436   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
3437 #endif
3438
3439   /* use for redo */
3440   prop = RNA_def_int(ot->srna, "index", -1, -1, INT_MAX, "", "", 0, INT_MAX);
3441   RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
3442 }
3443
3444 /** \} */
3445
3446 /* -------------------------------------------------------------------- */
3447 /** \name Select Face by Sides Operator
3448  * \{ */
3449
3450 static int edbm_select_face_by_sides_exec(bContext *C, wmOperator *op)
3451 {
3452   ViewLayer *view_layer = CTX_data_view_layer(C);
3453   uint objects_len = 0;
3454   const bool extend = RNA_boolean_get(op->ptr, "extend");
3455   const int numverts = RNA_int_get(op->ptr, "number");
3456   const int type = RNA_enum_get(op->ptr, "type");
3457   Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(
3458       view_layer, CTX_wm_view3d(C), &objects_len);
3459
3460   for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
3461     Object *obedit = objects[ob_index];
3462     BMEditMesh *em = BKE_editmesh_from_object(obedit);
3463     BMFace *efa;
3464     BMIter iter;
3465
3466     if (!extend) {
3467       EDBM_flag_disable_all(em, BM_ELEM_SELECT);
3468     }
3469
3470     BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
3471       bool select;
3472
3473       switch (type) {
3474         case 0:
3475           select = (efa->len < numverts);
3476           break;
3477         case 1:
3478           select = (efa->len == numverts);
3479           break;
3480         case 2:
3481           select = (efa->len > numverts);
3482           break;
3483         case 3:
3484           select = (efa->len != numverts);
3485           break;
3486         default:
3487           BLI_assert(0);
3488           select = false;
3489           break;
3490       }
3491
3492       if (select) {
3493         BM_face_select_set(em->bm, efa, true);
3494       }
3495     }
3496
3497     EDBM_selectmode_flush(em);
3498
3499     DEG_id_tag_update(obedit->data, ID_RECALC_SELECT);
3500     WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit->data);
3501   }
3502
3503   MEM_freeN(objects);
3504   return OPERATOR_FINISHED;
3505 }
3506
3507 void MESH_OT_select_face_by_sides(wmOperatorType *ot)
3508 {
3509   static const EnumPropertyItem type_items[] = {
3510       {0, "LESS", 0, "Less Than", ""},
3511       {1, "EQUAL", 0, "Equal To", ""},
3512       {2, "GREATER", 0, "Greater Than", ""},
3513       {3, "NOTEQUAL", 0, "Not Equal To", ""},
3514       {0, NULL, 0, NULL, NULL},
3515   };
3516
3517   /* identifiers */
3518   ot->name = "Select Faces by Sides";
3519   ot->description = "Select vertices or faces by the number of polygon sides";
3520   ot->idname = "MESH_OT_select_face_by_sides";
3521
3522   /* api callbacks */
3523   ot->exec = edbm_select_face_by_sides_exec;
3524   ot->poll = ED_operator_editmesh;
3525
3526   /* flags */
3527   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
3528
3529   /* properties */
3530   RNA_def_int(ot->srna, "number", 4, 3, INT_MAX, "Number of Vertices", "", 3, INT_MAX);
3531   RNA_def_enum(ot->srna, "type", type_items, 1, "Type", "Type of comparison to make");
3532   RNA_def_boolean(ot->srna, "extend", true, "Extend", "Extend the selection");
3533 }
3534
3535 /** \} */
3536
3537 /* -------------------------------------------------------------------- */
3538 /** \name Select Loose Operator
3539  * \{ */
3540
3541 static int edbm_select_loose_exec(bContext *C, wmOperator *op)
3542 {
3543   ViewLayer *view_layer = CTX_data_view_layer(C);
3544   const bool extend = RNA_boolean_get(op->ptr, "extend");
3545
3546   uint objects_len = 0;
3547   Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(
3548       view_layer, CTX_wm_view3d(C), &objects_len);
3549
3550   for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
3551     Object *obedit = objects[ob_index];
3552     BMEditMesh *em = BKE_editmesh_from_object(obedit);
3553     BMesh *bm = em->bm;
3554     BMIter iter;
3555
3556     if (!extend) {
3557       EDBM_flag_disable_all(em, BM_ELEM_SELECT);
3558     }
3559
3560     if (em->selectmode & SCE_SELECT_VERTEX) {
3561       BMVert *eve;
3562       BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
3563         if (!eve->e) {
3564           BM_vert_select_set(bm, eve, true);
3565         }
3566       }
3567     }
3568
3569     if (em->selectmode & SCE_SELECT_EDGE) {
3570       BMEdge *eed;
3571       BM_ITER_MESH (eed, &iter, bm, BM_EDGES_OF_MESH) {
3572         if (BM_edge_is_wire(eed)) {
3573           BM_edge_select_set(bm, eed, true);
3574         }
3575       }
3576     }
3577
3578     if (em->selectmode & SCE_SELECT_FACE) {
3579       BMFace *efa;
3580       BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
3581         BMIter liter;
3582         BMLoop *l;
3583         bool is_loose = true;
3584         BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
3585           if (!BM_edge_is_boundary(l->e)) {
3586             is_loose = false;
3587             break;
3588           }
3589         }
3590         if (is_loose) {
3591           BM_face_select_set(bm, efa, true);
3592         }
3593       }
3594     }
3595
3596     EDBM_selectmode_flush(em);
3597
3598     DEG_id_tag_update(obedit->data, ID_RECALC_SELECT);
3599     WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit->data);
3600   }
3601
3602   MEM_freeN(objects);
3603
3604   return OPERATOR_FINISHED;
3605 }
3606
3607 void MESH_OT_select_loose(wmOperatorType *ot)
3608 {
3609   /* identifiers */
3610   ot->name = "Select Loose Geometry";
3611   ot->description = "Select loose geometry based on the selection mode";
3612   ot->idname = "MESH_OT_select_loose";
3613
3614   /* api callbacks */
3615   ot->exec = edbm_select_loose_exec;
3616   ot->poll = ED_operator_editmesh;
3617
3618   /* flags */
3619   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
3620
3621   /* props */
3622   RNA_def_boolean(ot->srna, "extend", false, "Extend", "Extend the selection");
3623 }
3624
3625 /** \} */
3626
3627 /* -------------------------------------------------------------------- */
3628 /** \name Select Mirror Operator
3629  * \{ */
3630
3631 static int edbm_select_mirror_exec(bContext *C, wmOperator *op)
3632 {
3633   ViewLayer *view_layer = CTX_data_view_layer(C);
3634   const int axis_flag = RNA_enum_get(op->ptr, "axis");
3635   const bool extend = RNA_boolean_get(op->ptr, "extend");
3636   Object *obedit_active = CTX_data_edit_object(C);
3637   BMEditMesh *em_active = BKE_editmesh_from_object(obedit_active);
3638   const int select_mode = em_active->bm->selectmode;
3639   int tot_mirr = 0, tot_fail = 0;
3640
3641   uint objects_len = 0;
3642   Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(
3643       view_layer, CTX_wm_view3d(C), &objects_len);
3644
3645   for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
3646     Object *obedit = objects[ob_index];
3647     BMEditMesh *em = BKE_editmesh_from_object(obedit);
3648
3649     if (em->bm->totvertsel == 0) {
3650       continue;
3651     }
3652
3653     int tot_mirr_iter = 0, tot_fail_iter = 0;
3654
3655     for (int axis = 0; axis < 3; axis++) {
3656       if ((1 << axis) & axis_flag) {
3657         EDBM_select_mirrored(em, axis, extend, &tot_mirr_iter, &tot_fail_iter);
3658       }
3659     }
3660
3661     if (tot_mirr_iter) {
3662       EDBM_selectmode_flush(em);
3663
3664       DEG_id_tag_update(obedit->data, ID_RECALC_SELECT);
3665       WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit->data);
3666     }
3667
3668     tot_fail += tot_fail_iter;
3669     tot_mirr += tot_mirr_iter;
3670   }
3671   MEM_freeN(objects);
3672
3673   if (tot_mirr || tot_fail) {
3674     ED_mesh_report_mirror_ex(op, tot_mirr, tot_fail, select_mode);
3675   }
3676   return OPERATOR_FINISHED;
3677 }
3678
3679 void MESH_OT_select_mirror(wmOperatorType *ot)
3680 {
3681   /* identifiers */
3682   ot->name = "Select Mirror";
3683   ot->description = "Select mesh items at mirrored locations";
3684   ot->idname = "MESH_OT_select_mirror";