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