Merge branch 'master' into blender2.8
[blender.git] / source / blender / editors / sculpt_paint / paint_mask.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  * The Original Code is Copyright (C) 2012 by Nicholas Bishop
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s):
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  *
27  */
28
29 /** \file blender/editors/sculpt_paint/paint_mask.c
30  *  \ingroup edsculpt
31  */
32
33 #include "MEM_guardedalloc.h"
34
35 #include "DNA_meshdata_types.h"
36 #include "DNA_object_types.h"
37
38 #include "BLI_bitmap_draw_2d.h"
39 #include "BLI_math_matrix.h"
40 #include "BLI_math_geom.h"
41 #include "BLI_utildefines.h"
42 #include "BLI_lasso_2d.h"
43 #include "BLI_task.h"
44
45 #include "BKE_pbvh.h"
46 #include "BKE_ccg.h"
47 #include "BKE_context.h"
48 #include "BKE_DerivedMesh.h"
49 #include "BKE_multires.h"
50 #include "BKE_paint.h"
51 #include "BKE_subsurf.h"
52
53 #include "DEG_depsgraph.h"
54
55 #include "RNA_access.h"
56 #include "RNA_define.h"
57
58 #include "WM_api.h"
59 #include "WM_types.h"
60
61 #include "ED_screen.h"
62 #include "ED_sculpt.h"
63 #include "ED_view3d.h"
64
65 #include "bmesh.h"
66
67 #include "paint_intern.h"
68 #include "sculpt_intern.h" /* for undo push */
69
70 #include <stdlib.h>
71
72 static const EnumPropertyItem mode_items[] = {
73         {PAINT_MASK_FLOOD_VALUE, "VALUE", 0, "Value", "Set mask to the level specified by the 'value' property"},
74         {PAINT_MASK_FLOOD_VALUE_INVERSE, "VALUE_INVERSE", 0, "Value Inverted", "Set mask to the level specified by the inverted 'value' property"},
75         {PAINT_MASK_INVERT, "INVERT", 0, "Invert", "Invert the mask"},
76         {0}};
77
78
79 static void mask_flood_fill_set_elem(float *elem,
80                                      PaintMaskFloodMode mode,
81                                      float value)
82 {
83         switch (mode) {
84                 case PAINT_MASK_FLOOD_VALUE:
85                         (*elem) = value;
86                         break;
87                 case PAINT_MASK_FLOOD_VALUE_INVERSE:
88                         (*elem) = 1.0f - value;
89                         break;
90                 case PAINT_MASK_INVERT:
91                         (*elem) = 1.0f - (*elem);
92                         break;
93         }
94 }
95
96 typedef struct MaskTaskData {
97         Object *ob;
98         PBVH *pbvh;
99         PBVHNode **nodes;
100         bool multires;
101
102         PaintMaskFloodMode mode;
103         float value;
104         float (*clip_planes_final)[4];
105 } MaskTaskData;
106
107 static void mask_flood_fill_task_cb(
108         void *__restrict userdata,
109         const int i,
110         const ParallelRangeTLS *__restrict UNUSED(tls))
111 {
112         MaskTaskData *data = userdata;
113
114         PBVHNode *node = data->nodes[i];
115
116         const PaintMaskFloodMode mode = data->mode;
117         const float value = data->value;
118
119         PBVHVertexIter vi;
120
121         sculpt_undo_push_node(data->ob, node, SCULPT_UNDO_MASK);
122
123         BKE_pbvh_vertex_iter_begin(data->pbvh, node, vi, PBVH_ITER_UNIQUE) {
124                 mask_flood_fill_set_elem(vi.mask, mode, value);
125         } BKE_pbvh_vertex_iter_end;
126
127         BKE_pbvh_node_mark_redraw(node);
128         if (data->multires)
129                 BKE_pbvh_node_mark_normals_update(node);
130 }
131
132 static int mask_flood_fill_exec(bContext *C, wmOperator *op)
133 {
134         ARegion *ar = CTX_wm_region(C);
135         struct Scene *scene = CTX_data_scene(C);
136         Object *ob = CTX_data_active_object(C);
137         Depsgraph *depsgraph = CTX_data_depsgraph(C);
138         PaintMaskFloodMode mode;
139         float value;
140         PBVH *pbvh;
141         PBVHNode **nodes;
142         int totnode;
143         bool multires;
144         Sculpt *sd = CTX_data_tool_settings(C)->sculpt;
145
146         mode = RNA_enum_get(op->ptr, "mode");
147         value = RNA_float_get(op->ptr, "value");
148
149         BKE_sculpt_update_mesh_elements(depsgraph, scene, sd, ob, false, true);
150         pbvh = ob->sculpt->pbvh;
151         multires = (BKE_pbvh_type(pbvh) == PBVH_GRIDS);
152
153         BKE_pbvh_search_gather(pbvh, NULL, NULL, &nodes, &totnode);
154
155         sculpt_undo_push_begin("Mask flood fill");
156
157         MaskTaskData data = {
158             .ob = ob, .pbvh = pbvh, .nodes = nodes, .multires = multires,
159             .mode = mode, .value = value,
160         };
161
162         ParallelRangeSettings settings;
163         BLI_parallel_range_settings_defaults(&settings);
164         settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
165         BLI_task_parallel_range(
166                     0, totnode, &data, mask_flood_fill_task_cb,
167                     &settings);
168
169         if (multires)
170                 multires_mark_as_modified(ob, MULTIRES_COORDS_MODIFIED);
171
172         sculpt_undo_push_end();
173
174         if (nodes)
175                 MEM_freeN(nodes);
176
177         ED_region_tag_redraw(ar);
178
179         WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
180
181         return OPERATOR_FINISHED;
182 }
183
184 void PAINT_OT_mask_flood_fill(struct wmOperatorType *ot)
185 {
186         /* identifiers */
187         ot->name = "Mask Flood Fill";
188         ot->idname = "PAINT_OT_mask_flood_fill";
189         ot->description = "Fill the whole mask with a given value, or invert its values";
190
191         /* api callbacks */
192         ot->exec = mask_flood_fill_exec;
193         ot->poll = sculpt_mode_poll;
194
195         ot->flag = OPTYPE_REGISTER;
196
197         /* rna */
198         RNA_def_enum(ot->srna, "mode", mode_items, PAINT_MASK_FLOOD_VALUE, "Mode", NULL);
199         RNA_def_float(ot->srna, "value", 0, 0, 1, "Value",
200                       "Mask level to use when mode is 'Value'; zero means no masking and one is fully masked", 0, 1);
201 }
202
203 /* Box select, operator is VIEW3D_OT_select_border, defined in view3d_select.c */
204
205 static bool is_effected(float planes[4][4], const float co[3])
206 {
207         return isect_point_planes_v3(planes, 4, co);
208 }
209
210 static void flip_plane(float out[4], const float in[4], const char symm)
211 {
212         if (symm & PAINT_SYMM_X)
213                 out[0] = -in[0];
214         else
215                 out[0] = in[0];
216         if (symm & PAINT_SYMM_Y)
217                 out[1] = -in[1];
218         else
219                 out[1] = in[1];
220         if (symm & PAINT_SYMM_Z)
221                 out[2] = -in[2];
222         else
223                 out[2] = in[2];
224
225         out[3] = in[3];
226 }
227
228 static void mask_box_select_task_cb(
229         void *__restrict userdata,
230         const int i,
231         const ParallelRangeTLS *__restrict UNUSED(tls))
232 {
233         MaskTaskData *data = userdata;
234
235         PBVHNode *node = data->nodes[i];
236
237         const PaintMaskFloodMode mode = data->mode;
238         const float value = data->value;
239         float (*clip_planes_final)[4] = data->clip_planes_final;
240
241         PBVHVertexIter vi;
242         bool any_masked = false;
243
244         BKE_pbvh_vertex_iter_begin(data->pbvh, node, vi, PBVH_ITER_UNIQUE) {
245                 if (is_effected(clip_planes_final, vi.co)) {
246                         if (!any_masked) {
247                                 any_masked = true;
248
249                                 sculpt_undo_push_node(data->ob, node, SCULPT_UNDO_MASK);
250
251                                 BKE_pbvh_node_mark_redraw(node);
252                                 if (data->multires)
253                                         BKE_pbvh_node_mark_normals_update(node);
254                         }
255                         mask_flood_fill_set_elem(vi.mask, mode, value);
256                 }
257         } BKE_pbvh_vertex_iter_end;
258 }
259
260 int ED_sculpt_mask_box_select(struct bContext *C, ViewContext *vc, const rcti *rect, bool select, bool UNUSED(extend))
261 {
262         Depsgraph *depsgraph = CTX_data_depsgraph(C);
263         Sculpt *sd = vc->scene->toolsettings->sculpt;
264         BoundBox bb;
265         float clip_planes[4][4];
266         float clip_planes_final[4][4];
267         ARegion *ar = vc->ar;
268         struct Scene *scene = vc->scene;
269         Object *ob = vc->obact;
270         PaintMaskFloodMode mode;
271         float value;
272         bool multires;
273         PBVH *pbvh;
274         PBVHNode **nodes;
275         int totnode, symmpass;
276         int symm = sd->paint.symmetry_flags & PAINT_SYMM_AXIS_ALL;
277
278         mode = PAINT_MASK_FLOOD_VALUE;
279         value = select ? 1.0 : 0.0;
280
281         /* transform the clip planes in object space */
282         ED_view3d_clipping_calc(&bb, clip_planes, vc->ar, vc->obact, rect);
283         negate_m4(clip_planes);
284
285         BKE_sculpt_update_mesh_elements(depsgraph, scene, sd, ob, false, true);
286         pbvh = ob->sculpt->pbvh;
287         multires = (BKE_pbvh_type(pbvh) == PBVH_GRIDS);
288
289         sculpt_undo_push_begin("Mask box fill");
290
291         for (symmpass = 0; symmpass <= symm; ++symmpass) {
292                 if (symmpass == 0 ||
293                     (symm & symmpass &&
294                      (symm != 5 || symmpass != 3) &&
295                      (symm != 6 || (symmpass != 3 && symmpass != 5))))
296                 {
297                         int j = 0;
298
299                         /* flip the planes symmetrically as needed */
300                         for (; j < 4; j++) {
301                                 flip_plane(clip_planes_final[j], clip_planes[j], symmpass);
302                         }
303
304                         BKE_pbvh_search_gather(pbvh, BKE_pbvh_node_planes_contain_AABB, clip_planes_final, &nodes, &totnode);
305
306                         MaskTaskData data = {
307                             .ob = ob, .pbvh = pbvh, .nodes = nodes, .multires = multires,
308                             .mode = mode, .value = value, .clip_planes_final = clip_planes_final,
309                         };
310
311                         ParallelRangeSettings settings;
312                         BLI_parallel_range_settings_defaults(&settings);
313                         settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
314                         BLI_task_parallel_range(
315                                     0, totnode, &data, mask_box_select_task_cb,
316                                     &settings);
317
318                         if (nodes)
319                                 MEM_freeN(nodes);
320                 }
321         }
322
323         if (multires)
324                 multires_mark_as_modified(ob, MULTIRES_COORDS_MODIFIED);
325
326         sculpt_undo_push_end();
327
328         ED_region_tag_redraw(ar);
329
330         WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
331
332         return OPERATOR_FINISHED;
333 }
334
335 typedef struct LassoMaskData {
336         struct ViewContext *vc;
337         float projviewobjmat[4][4];
338         BLI_bitmap *px;
339         int width;
340         rcti rect; /* bounding box for scanfilling */
341         int symmpass;
342
343         MaskTaskData task_data;
344 } LassoMaskData;
345
346
347 /* Lasso select. This could be defined as part of VIEW3D_OT_select_lasso, still the shortcuts conflict,
348  * so we will use a separate operator */
349
350 static bool is_effected_lasso(LassoMaskData *data, float co[3])
351 {
352         float scr_co_f[2];
353         int   scr_co_s[2];
354         float co_final[3];
355
356         flip_v3_v3(co_final, co, data->symmpass);
357         /* first project point to 2d space */
358         ED_view3d_project_float_v2_m4(data->vc->ar, co_final, scr_co_f, data->projviewobjmat);
359
360         scr_co_s[0] = scr_co_f[0];
361         scr_co_s[1] = scr_co_f[1];
362
363         /* clip against screen, because lasso is limited to screen only */
364         if ((scr_co_s[0] < data->rect.xmin) ||
365             (scr_co_s[1] < data->rect.ymin) ||
366             (scr_co_s[0] >= data->rect.xmax) ||
367             (scr_co_s[1] >= data->rect.ymax))
368         {
369                 return false;
370         }
371
372         scr_co_s[0] -= data->rect.xmin;
373         scr_co_s[1] -= data->rect.ymin;
374
375         return BLI_BITMAP_TEST_BOOL(data->px, scr_co_s[1] * data->width + scr_co_s[0]);
376 }
377
378 static void mask_lasso_px_cb(int x, int x_end, int y, void *user_data)
379 {
380         LassoMaskData *data = user_data;
381         int index     = (y * data->width) + x;
382         int index_end = (y * data->width) + x_end;
383         do {
384                 BLI_BITMAP_ENABLE(data->px, index);
385         } while (++index != index_end);
386 }
387
388 static void mask_gesture_lasso_task_cb(
389         void *__restrict userdata,
390         const int i,
391         const ParallelRangeTLS *__restrict UNUSED(tls))
392 {
393         LassoMaskData *lasso_data = userdata;
394         MaskTaskData *data = &lasso_data->task_data;
395
396         PBVHNode *node = data->nodes[i];
397
398         const PaintMaskFloodMode mode = data->mode;
399         const float value = data->value;
400
401         PBVHVertexIter vi;
402         bool any_masked = false;
403
404         BKE_pbvh_vertex_iter_begin(data->pbvh, node, vi, PBVH_ITER_UNIQUE) {
405                 if (is_effected_lasso(lasso_data, vi.co)) {
406                         if (!any_masked) {
407                                 any_masked = true;
408
409                                 sculpt_undo_push_node(data->ob, node, SCULPT_UNDO_MASK);
410
411                                 BKE_pbvh_node_mark_redraw(node);
412                                 if (data->multires)
413                                         BKE_pbvh_node_mark_normals_update(node);
414                         }
415
416                         mask_flood_fill_set_elem(vi.mask, mode, value);
417                 }
418         } BKE_pbvh_vertex_iter_end;
419 }
420
421 static int paint_mask_gesture_lasso_exec(bContext *C, wmOperator *op)
422 {
423         int mcords_tot;
424         const int (*mcords)[2] = WM_gesture_lasso_path_to_array(C, op, &mcords_tot);
425
426         if (mcords) {
427                 Depsgraph *depsgraph = CTX_data_depsgraph(C);
428                 float clip_planes[4][4], clip_planes_final[4][4];
429                 BoundBox bb;
430                 Object *ob;
431                 ViewContext vc;
432                 LassoMaskData data;
433                 struct Scene *scene = CTX_data_scene(C);
434                 Sculpt *sd = CTX_data_tool_settings(C)->sculpt;
435                 int symm = sd->paint.symmetry_flags & PAINT_SYMM_AXIS_ALL;
436                 PBVH *pbvh;
437                 PBVHNode **nodes;
438                 int totnode, symmpass;
439                 bool multires;
440                 PaintMaskFloodMode mode = RNA_enum_get(op->ptr, "mode");
441                 float value = RNA_float_get(op->ptr, "value");
442
443                 /* Calculations of individual vertices are done in 2D screen space to diminish the amount of
444                  * calculations done. Bounding box PBVH collision is not computed against enclosing rectangle
445                  * of lasso */
446                 ED_view3d_viewcontext_init(C, &vc);
447
448                 /* lasso data calculations */
449                 data.vc = &vc;
450                 ob = vc.obact;
451                 ED_view3d_ob_project_mat_get(vc.rv3d, ob, data.projviewobjmat);
452
453                 BLI_lasso_boundbox(&data.rect, mcords, mcords_tot);
454                 data.width = data.rect.xmax - data.rect.xmin;
455                 data.px = BLI_BITMAP_NEW(data.width * (data.rect.ymax - data.rect.ymin), __func__);
456
457                 BLI_bitmap_draw_2d_poly_v2i_n(
458                        data.rect.xmin, data.rect.ymin, data.rect.xmax, data.rect.ymax,
459                        mcords, mcords_tot,
460                        mask_lasso_px_cb, &data);
461
462                 ED_view3d_clipping_calc(&bb, clip_planes, vc.ar, vc.obact, &data.rect);
463                 negate_m4(clip_planes);
464
465                 BKE_sculpt_update_mesh_elements(depsgraph, scene, sd, ob, false, true);
466                 pbvh = ob->sculpt->pbvh;
467                 multires = (BKE_pbvh_type(pbvh) == PBVH_GRIDS);
468
469                 sculpt_undo_push_begin("Mask lasso fill");
470
471                 for (symmpass = 0; symmpass <= symm; ++symmpass) {
472                         if ((symmpass == 0) ||
473                             (symm & symmpass &&
474                              (symm != 5 || symmpass != 3) &&
475                              (symm != 6 || (symmpass != 3 && symmpass != 5))))
476                         {
477                                 int j = 0;
478
479                                 /* flip the planes symmetrically as needed */
480                                 for (; j < 4; j++) {
481                                         flip_plane(clip_planes_final[j], clip_planes[j], symmpass);
482                                 }
483
484                                 data.symmpass = symmpass;
485
486                                 /* gather nodes inside lasso's enclosing rectangle (should greatly help with bigger meshes) */
487                                 BKE_pbvh_search_gather(pbvh, BKE_pbvh_node_planes_contain_AABB, clip_planes_final, &nodes, &totnode);
488
489                                 data.task_data.ob = ob;
490                                 data.task_data.pbvh = pbvh;
491                                 data.task_data.nodes = nodes;
492                                 data.task_data.multires = multires;
493                                 data.task_data.mode = mode;
494                                 data.task_data.value = value;
495
496                                 ParallelRangeSettings settings;
497                                 BLI_parallel_range_settings_defaults(&settings);
498                                 settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && (totnode > SCULPT_THREADED_LIMIT));
499                                 BLI_task_parallel_range(
500                                             0, totnode, &data, mask_gesture_lasso_task_cb,
501                                             &settings);
502
503                                 if (nodes)
504                                         MEM_freeN(nodes);
505                         }
506                 }
507
508                 if (multires)
509                         multires_mark_as_modified(ob, MULTIRES_COORDS_MODIFIED);
510
511                 sculpt_undo_push_end();
512
513                 ED_region_tag_redraw(vc.ar);
514                 MEM_freeN((void *)mcords);
515                 MEM_freeN(data.px);
516
517                 WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
518
519                 return OPERATOR_FINISHED;
520         }
521         return OPERATOR_PASS_THROUGH;
522 }
523
524 void PAINT_OT_mask_lasso_gesture(wmOperatorType *ot)
525 {
526         ot->name = "Mask Lasso Gesture";
527         ot->idname = "PAINT_OT_mask_lasso_gesture";
528         ot->description = "Add mask within the lasso as you move the brush";
529
530         ot->invoke = WM_gesture_lasso_invoke;
531         ot->modal = WM_gesture_lasso_modal;
532         ot->exec = paint_mask_gesture_lasso_exec;
533
534         ot->poll = sculpt_mode_poll;
535
536         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
537
538         /* properties */
539         WM_operator_properties_gesture_lasso(ot);
540
541         RNA_def_enum(ot->srna, "mode", mode_items, PAINT_MASK_FLOOD_VALUE, "Mode", NULL);
542         RNA_def_float(ot->srna, "value", 1.0, 0, 1.0, "Value",
543                       "Mask level to use when mode is 'Value'; zero means no masking and one is fully masked", 0, 1);
544 }