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