Merge branch 'master' into blender2.8
[blender.git] / source / blender / editors / mesh / editface.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributor(s): Blender Foundation, Campbell Barton
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/editors/mesh/editface.c
24  *  \ingroup edmesh
25  */
26
27 #include "MEM_guardedalloc.h"
28
29 #include "BLI_blenlib.h"
30 #include "BLI_math.h"
31 #include "BLI_bitmap.h"
32
33 #include "IMB_imbuf_types.h"
34 #include "IMB_imbuf.h"
35
36 #include "DNA_meshdata_types.h"
37 #include "DNA_mesh_types.h"
38 #include "DNA_object_types.h"
39
40 #include "BKE_context.h"
41 #include "BKE_customdata.h"
42 #include "BKE_global.h"
43 #include "BKE_mesh.h"
44
45 #include "BIF_gl.h"
46
47 #include "ED_mesh.h"
48 #include "ED_screen.h"
49 #include "ED_select_utils.h"
50 #include "ED_view3d.h"
51
52 #include "WM_api.h"
53 #include "WM_types.h"
54
55 #include "GPU_draw.h"
56
57 #include "DEG_depsgraph.h"
58 #include "DEG_depsgraph_query.h"
59
60 /* own include */
61
62 /* copy the face flags, most importantly selection from the mesh to the final derived mesh,
63  * use in object mode when selecting faces (while painting) */
64 void paintface_flush_flags(struct bContext *C, Object *ob, short flag)
65 {
66         Mesh *me = BKE_mesh_from_object(ob);
67         MPoly *polys, *mp_orig;
68         const int *index_array = NULL;
69         int totpoly;
70         int i;
71
72         BLI_assert((flag & ~(SELECT | ME_HIDE)) == 0);
73
74         if (me == NULL)
75                 return;
76
77         /* note, call #BKE_mesh_flush_hidden_from_verts_ex first when changing hidden flags */
78
79         /* we could call this directly in all areas that change selection,
80          * since this could become slow for realtime updates (circle-select for eg) */
81         if (flag & SELECT) {
82                 BKE_mesh_flush_select_from_polys(me);
83         }
84
85         Depsgraph *depsgraph = CTX_data_depsgraph(C);
86         Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
87
88         if (ob_eval == NULL) {
89                 return;
90         }
91
92         Mesh *me_orig = ob_eval->runtime.mesh_orig;
93         Mesh *me_eval = ob_eval->runtime.mesh_eval;
94         bool updated = false;
95
96         if (me_orig != NULL && me_eval != NULL && me_orig->totpoly == me->totpoly) {
97                 /* Update the COW copy of the mesh. */
98                 for (i = 0; i < me->totpoly; i++) {
99                         me_orig->mpoly[i].flag = me->mpoly[i].flag;
100                 }
101
102                 /* If the mesh has only deform modifiers, the evaluated mesh shares arrays. */
103                 if (me_eval->mpoly == me_orig->mpoly) {
104                         updated = true;
105                 }
106                 /* Mesh polys => Final derived polys */
107                 else if ((index_array = CustomData_get_layer(&me_eval->pdata, CD_ORIGINDEX))) {
108                         polys = me_eval->mpoly;
109                         totpoly = me_eval->totpoly;
110
111                         /* loop over final derived polys */
112                         for (i = 0; i < totpoly; i++) {
113                                 if (index_array[i] != ORIGINDEX_NONE) {
114                                         /* Copy flags onto the final derived poly from the original mesh poly */
115                                         mp_orig = me->mpoly + index_array[i];
116                                         polys[i].flag = mp_orig->flag;
117
118                                 }
119                         }
120
121                         updated = true;
122                 }
123         }
124
125         if (updated) {
126                 if (flag & ME_HIDE) {
127                         BKE_mesh_batch_cache_dirty_tag(me_eval, BKE_MESH_BATCH_DIRTY_ALL);
128                 }
129                 else {
130                         BKE_mesh_batch_cache_dirty_tag(me_eval, BKE_MESH_BATCH_DIRTY_SELECT);
131                 }
132
133                 DEG_id_tag_update(ob->data, ID_RECALC_SELECT);
134         }
135         else {
136                 DEG_id_tag_update(ob->data, ID_RECALC_COPY_ON_WRITE | ID_RECALC_SELECT);
137         }
138
139         WM_event_add_notifier(C, NC_GEOM | ND_SELECT, ob->data);
140 }
141
142 void paintface_hide(bContext *C, Object *ob, const bool unselected)
143 {
144         Mesh *me;
145         MPoly *mpoly;
146         int a;
147
148         me = BKE_mesh_from_object(ob);
149         if (me == NULL || me->totpoly == 0) return;
150
151         mpoly = me->mpoly;
152         a = me->totpoly;
153         while (a--) {
154                 if ((mpoly->flag & ME_HIDE) == 0) {
155                         if (((mpoly->flag & ME_FACE_SEL) == 0) == unselected) {
156                                 mpoly->flag |= ME_HIDE;
157                         }
158                 }
159
160                 if (mpoly->flag & ME_HIDE) {
161                         mpoly->flag &= ~ME_FACE_SEL;
162                 }
163
164                 mpoly++;
165         }
166
167         BKE_mesh_flush_hidden_from_polys(me);
168
169         paintface_flush_flags(C, ob, SELECT | ME_HIDE);
170 }
171
172
173 void paintface_reveal(bContext *C, Object *ob, const bool select)
174 {
175         Mesh *me;
176         MPoly *mpoly;
177         int a;
178
179         me = BKE_mesh_from_object(ob);
180         if (me == NULL || me->totpoly == 0) return;
181
182         mpoly = me->mpoly;
183         a = me->totpoly;
184         while (a--) {
185                 if (mpoly->flag & ME_HIDE) {
186                         SET_FLAG_FROM_TEST(mpoly->flag, select, ME_FACE_SEL);
187                         mpoly->flag &= ~ME_HIDE;
188                 }
189                 mpoly++;
190         }
191
192         BKE_mesh_flush_hidden_from_polys(me);
193
194         paintface_flush_flags(C, ob, SELECT | ME_HIDE);
195 }
196
197 /* Set tface seams based on edge data, uses hash table to find seam edges. */
198
199 static void select_linked_tfaces_with_seams(Mesh *me, const unsigned int index, const bool select)
200 {
201         MPoly *mp;
202         MLoop *ml;
203         int a, b;
204         bool do_it = true;
205         bool mark = false;
206
207         BLI_bitmap *edge_tag = BLI_BITMAP_NEW(me->totedge, __func__);
208         BLI_bitmap *poly_tag = BLI_BITMAP_NEW(me->totpoly, __func__);
209
210         if (index != (unsigned int)-1) {
211                 /* only put face under cursor in array */
212                 mp = &me->mpoly[index];
213                 BKE_mesh_poly_edgebitmap_insert(edge_tag, mp, me->mloop + mp->loopstart);
214                 BLI_BITMAP_ENABLE(poly_tag, index);
215         }
216         else {
217                 /* fill array by selection */
218                 mp = me->mpoly;
219                 for (a = 0; a < me->totpoly; a++, mp++) {
220                         if (mp->flag & ME_HIDE) {
221                                 /* pass */
222                         }
223                         else if (mp->flag & ME_FACE_SEL) {
224                                 BKE_mesh_poly_edgebitmap_insert(edge_tag, mp, me->mloop + mp->loopstart);
225                                 BLI_BITMAP_ENABLE(poly_tag, a);
226                         }
227                 }
228         }
229
230         while (do_it) {
231                 do_it = false;
232
233                 /* expand selection */
234                 mp = me->mpoly;
235                 for (a = 0; a < me->totpoly; a++, mp++) {
236                         if (mp->flag & ME_HIDE)
237                                 continue;
238
239                         if (!BLI_BITMAP_TEST(poly_tag, a)) {
240                                 mark = false;
241
242                                 ml = me->mloop + mp->loopstart;
243                                 for (b = 0; b < mp->totloop; b++, ml++) {
244                                         if ((me->medge[ml->e].flag & ME_SEAM) == 0) {
245                                                 if (BLI_BITMAP_TEST(edge_tag, ml->e)) {
246                                                         mark = true;
247                                                         break;
248                                                 }
249                                         }
250                                 }
251
252                                 if (mark) {
253                                         BLI_BITMAP_ENABLE(poly_tag, a);
254                                         BKE_mesh_poly_edgebitmap_insert(edge_tag, mp, me->mloop + mp->loopstart);
255                                         do_it = true;
256                                 }
257                         }
258                 }
259         }
260
261         MEM_freeN(edge_tag);
262
263         for (a = 0, mp = me->mpoly; a < me->totpoly; a++, mp++) {
264                 if (BLI_BITMAP_TEST(poly_tag, a)) {
265                         SET_FLAG_FROM_TEST(mp->flag, select, ME_FACE_SEL);
266                 }
267         }
268
269         MEM_freeN(poly_tag);
270 }
271
272 void paintface_select_linked(bContext *C, Object *ob, const int mval[2], const bool select)
273 {
274         Mesh *me;
275         unsigned int index = (unsigned int)-1;
276
277         me = BKE_mesh_from_object(ob);
278         if (me == NULL || me->totpoly == 0) return;
279
280         if (mval) {
281                 if (!ED_mesh_pick_face(C, ob, mval, &index, ED_MESH_PICK_DEFAULT_FACE_SIZE)) {
282                         return;
283                 }
284         }
285
286         select_linked_tfaces_with_seams(me, index, select);
287
288         paintface_flush_flags(C, ob, SELECT);
289 }
290
291 void paintface_deselect_all_visible(bContext *C, Object *ob, int action, bool flush_flags)
292 {
293         Mesh *me;
294         MPoly *mpoly;
295         int a;
296
297         me = BKE_mesh_from_object(ob);
298         if (me == NULL) return;
299
300         if (action == SEL_TOGGLE) {
301                 action = SEL_SELECT;
302
303                 mpoly = me->mpoly;
304                 a = me->totpoly;
305                 while (a--) {
306                         if ((mpoly->flag & ME_HIDE) == 0 && mpoly->flag & ME_FACE_SEL) {
307                                 action = SEL_DESELECT;
308                                 break;
309                         }
310                         mpoly++;
311                 }
312         }
313
314         mpoly = me->mpoly;
315         a = me->totpoly;
316         while (a--) {
317                 if ((mpoly->flag & ME_HIDE) == 0) {
318                         switch (action) {
319                                 case SEL_SELECT:
320                                         mpoly->flag |= ME_FACE_SEL;
321                                         break;
322                                 case SEL_DESELECT:
323                                         mpoly->flag &= ~ME_FACE_SEL;
324                                         break;
325                                 case SEL_INVERT:
326                                         mpoly->flag ^= ME_FACE_SEL;
327                                         break;
328                         }
329                 }
330                 mpoly++;
331         }
332
333         if (flush_flags) {
334                 paintface_flush_flags(C, ob, SELECT);
335         }
336 }
337
338 bool paintface_minmax(Object *ob, float r_min[3], float r_max[3])
339 {
340         const Mesh *me;
341         const MPoly *mp;
342         const MLoop *ml;
343         const MVert *mvert;
344         int a, b;
345         bool ok = false;
346         float vec[3], bmat[3][3];
347
348         me = BKE_mesh_from_object(ob);
349         if (!me || !me->mloopuv) {
350                 return ok;
351         }
352
353         copy_m3_m4(bmat, ob->obmat);
354
355         mvert = me->mvert;
356         mp = me->mpoly;
357         for (a = me->totpoly; a > 0; a--, mp++) {
358                 if (mp->flag & ME_HIDE || !(mp->flag & ME_FACE_SEL))
359                         continue;
360
361                 ml = me->mloop + mp->totloop;
362                 for (b = 0; b < mp->totloop; b++, ml++) {
363                         mul_v3_m3v3(vec, bmat, mvert[ml->v].co);
364                         add_v3_v3v3(vec, vec, ob->obmat[3]);
365                         minmax_v3v3_v3(r_min, r_max, vec);
366                 }
367
368                 ok = true;
369         }
370
371         return ok;
372 }
373
374 bool paintface_mouse_select(struct bContext *C, Object *ob, const int mval[2], bool extend, bool deselect, bool toggle)
375 {
376         Mesh *me;
377         MPoly *mpoly, *mpoly_sel;
378         unsigned int a, index;
379
380         /* Get the face under the cursor */
381         me = BKE_mesh_from_object(ob);
382
383         if (!ED_mesh_pick_face(C, ob, mval, &index, ED_MESH_PICK_DEFAULT_FACE_SIZE))
384                 return false;
385
386         if (index >= me->totpoly)
387                 return false;
388
389         mpoly_sel = me->mpoly + index;
390         if (mpoly_sel->flag & ME_HIDE) return false;
391
392         /* clear flags */
393         mpoly = me->mpoly;
394         a = me->totpoly;
395         if (!extend && !deselect && !toggle) {
396                 while (a--) {
397                         mpoly->flag &= ~ME_FACE_SEL;
398                         mpoly++;
399                 }
400         }
401
402         me->act_face = (int)index;
403
404         if (extend) {
405                 mpoly_sel->flag |= ME_FACE_SEL;
406         }
407         else if (deselect) {
408                 mpoly_sel->flag &= ~ME_FACE_SEL;
409         }
410         else if (toggle) {
411                 if (mpoly_sel->flag & ME_FACE_SEL)
412                         mpoly_sel->flag &= ~ME_FACE_SEL;
413                 else
414                         mpoly_sel->flag |= ME_FACE_SEL;
415         }
416         else {
417                 mpoly_sel->flag |= ME_FACE_SEL;
418         }
419
420         /* image window redraw */
421
422         paintface_flush_flags(C, ob, SELECT);
423         ED_region_tag_redraw(CTX_wm_region(C)); // XXX - should redraw all 3D views
424         return true;
425 }
426
427 int do_paintface_box_select(ViewContext *vc, rcti *rect, int sel_op)
428 {
429         Object *ob = vc->obact;
430         Mesh *me;
431         MPoly *mpoly;
432         struct ImBuf *ibuf;
433         unsigned int *rt;
434         char *selar;
435         int a, index;
436         const int size[2] = {
437             BLI_rcti_size_x(rect) + 1,
438             BLI_rcti_size_y(rect) + 1};
439
440         me = BKE_mesh_from_object(ob);
441
442         if ((me == NULL) || (me->totpoly == 0) || (size[0] * size[1] <= 0)) {
443                 return OPERATOR_CANCELLED;
444         }
445
446         selar = MEM_callocN(me->totpoly + 1, "selar");
447
448         if (SEL_OP_USE_PRE_DESELECT(sel_op)) {
449                 paintface_deselect_all_visible(vc->C, vc->obact, SEL_DESELECT, false);
450         }
451
452         ED_view3d_backbuf_validate(vc);
453
454         ibuf = IMB_allocImBuf(size[0], size[1], 32, IB_rect);
455         rt = ibuf->rect;
456         view3d_opengl_read_pixels(vc->ar, rect->xmin, rect->ymin, size[0], size[1], GL_RGBA, GL_UNSIGNED_BYTE,  ibuf->rect);
457         if (ENDIAN_ORDER == B_ENDIAN) {
458                 IMB_convert_rgba_to_abgr(ibuf);
459         }
460         GPU_select_to_index_array(ibuf->rect, size[0] * size[1]);
461
462         a = size[0] * size[1];
463         while (a--) {
464                 if (*rt) {
465                         index = *rt;
466                         if (index <= me->totpoly) {
467                                 selar[index] = 1;
468                         }
469                 }
470                 rt++;
471         }
472
473         mpoly = me->mpoly;
474         for (a = 1; a <= me->totpoly; a++, mpoly++) {
475                 if ((mpoly->flag & ME_HIDE) == 0) {
476                         const bool is_select = mpoly->flag & ME_FACE_SEL;
477                         const bool is_inside = (selar[a] != 0);
478                         const int sel_op_result = ED_select_op_action_deselected(sel_op, is_select, is_inside);
479                         if (sel_op_result != -1) {
480                                 SET_FLAG_FROM_TEST(mpoly->flag, sel_op_result, ME_FACE_SEL);
481                         }
482                 }
483         }
484
485         IMB_freeImBuf(ibuf);
486         MEM_freeN(selar);
487
488 #ifdef __APPLE__
489         glReadBuffer(GL_BACK);
490 #endif
491
492         paintface_flush_flags(vc->C, vc->obact, SELECT);
493
494         return OPERATOR_FINISHED;
495 }
496
497
498 /*  (similar to void paintface_flush_flags(Object *ob))
499  * copy the vertex flags, most importantly selection from the mesh to the final derived mesh,
500  * use in object mode when selecting vertices (while painting) */
501 void paintvert_flush_flags(Object *ob)
502 {
503         Mesh *me = BKE_mesh_from_object(ob);
504         Mesh *me_eval = ob->runtime.mesh_eval;
505         MVert *mvert_eval, *mv;
506         const int *index_array = NULL;
507         int totvert;
508         int i;
509
510         if (me == NULL)
511                 return;
512
513         /* we could call this directly in all areas that change selection,
514          * since this could become slow for realtime updates (circle-select for eg) */
515         BKE_mesh_flush_select_from_verts(me);
516
517         if (me_eval == NULL)
518                 return;
519
520         index_array = CustomData_get_layer(&me_eval->vdata, CD_ORIGINDEX);
521
522         mvert_eval = me_eval->mvert;
523         totvert = me_eval->totvert;
524
525         mv = mvert_eval;
526
527         if (index_array) {
528                 int orig_index;
529                 for (i = 0; i < totvert; i++, mv++) {
530                         orig_index = index_array[i];
531                         if (orig_index != ORIGINDEX_NONE) {
532                                 mv->flag = me->mvert[index_array[i]].flag;
533                         }
534                 }
535         }
536         else {
537                 for (i = 0; i < totvert; i++, mv++) {
538                         mv->flag = me->mvert[i].flag;
539                 }
540         }
541
542         BKE_mesh_batch_cache_dirty_tag(me, BKE_MESH_BATCH_DIRTY_ALL);
543 }
544
545 void paintvert_tag_select_update(struct bContext *C, struct Object *ob)
546 {
547         DEG_id_tag_update(ob->data, ID_RECALC_COPY_ON_WRITE | ID_RECALC_SELECT);
548         WM_event_add_notifier(C, NC_GEOM | ND_SELECT, ob->data);
549 }
550
551 /*  note: if the caller passes false to flush_flags, then they will need to run paintvert_flush_flags(ob) themselves */
552 void paintvert_deselect_all_visible(Object *ob, int action, bool flush_flags)
553 {
554         Mesh *me;
555         MVert *mvert;
556         int a;
557
558         me = BKE_mesh_from_object(ob);
559         if (me == NULL) return;
560
561         if (action == SEL_TOGGLE) {
562                 action = SEL_SELECT;
563
564                 mvert = me->mvert;
565                 a = me->totvert;
566                 while (a--) {
567                         if ((mvert->flag & ME_HIDE) == 0 && mvert->flag & SELECT) {
568                                 action = SEL_DESELECT;
569                                 break;
570                         }
571                         mvert++;
572                 }
573         }
574
575         mvert = me->mvert;
576         a = me->totvert;
577         while (a--) {
578                 if ((mvert->flag & ME_HIDE) == 0) {
579                         switch (action) {
580                                 case SEL_SELECT:
581                                         mvert->flag |= SELECT;
582                                         break;
583                                 case SEL_DESELECT:
584                                         mvert->flag &= ~SELECT;
585                                         break;
586                                 case SEL_INVERT:
587                                         mvert->flag ^= SELECT;
588                                         break;
589                         }
590                 }
591                 mvert++;
592         }
593
594         /* handle mselect */
595         if (action == SEL_SELECT) {
596                 /* pass */
597         }
598         else if (ELEM(action, SEL_DESELECT, SEL_INVERT)) {
599                 BKE_mesh_mselect_clear(me);
600         }
601         else {
602                 BKE_mesh_mselect_validate(me);
603         }
604
605         if (flush_flags) {
606                 paintvert_flush_flags(ob);
607         }
608 }
609
610 void paintvert_select_ungrouped(Object *ob, bool extend, bool flush_flags)
611 {
612         Mesh *me = BKE_mesh_from_object(ob);
613         MVert *mv;
614         MDeformVert *dv;
615         int a, tot;
616
617         if (me == NULL || me->dvert == NULL) {
618                 return;
619         }
620
621         if (!extend) {
622                 paintvert_deselect_all_visible(ob, SEL_DESELECT, false);
623         }
624
625         dv = me->dvert;
626         tot = me->totvert;
627
628         for (a = 0, mv = me->mvert; a < tot; a++, mv++, dv++) {
629                 if ((mv->flag & ME_HIDE) == 0) {
630                         if (dv->dw == NULL) {
631                                 /* if null weight then not grouped */
632                                 mv->flag |= SELECT;
633                         }
634                 }
635         }
636
637         if (flush_flags) {
638                 paintvert_flush_flags(ob);
639         }
640 }