2e9efcc02b29fbfe85c32f89eee2c9d8f086db39
[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_mesh_types.h"
36 #include "DNA_meshdata_types.h"
37 #include "DNA_object_types.h"
38
39 #include "BIF_glutil.h"
40
41 #include "BLI_math_matrix.h"
42 #include "BLI_math_geom.h"
43 #include "BLI_utildefines.h"
44 #include "BLI_lasso.h"
45
46 #include "BKE_pbvh.h"
47 #include "BKE_ccg.h"
48 #include "BKE_context.h"
49 #include "BKE_DerivedMesh.h"
50 #include "BKE_multires.h"
51 #include "BKE_paint.h"
52 #include "BKE_subsurf.h"
53
54 #include "RNA_access.h"
55 #include "RNA_define.h"
56
57 #include "WM_api.h"
58 #include "WM_types.h"
59
60 #include "ED_screen.h"
61 #include "ED_sculpt.h"
62 #include "ED_view3d.h"
63
64 #include "bmesh.h"
65
66 #include "paint_intern.h"
67 #include "sculpt_intern.h" /* for undo push */
68
69 #include <stdlib.h>
70
71 static void mask_flood_fill_set_elem(float *elem,
72                                      PaintMaskFloodMode mode,
73                                      float value)
74 {
75         switch (mode) {
76                 case PAINT_MASK_FLOOD_VALUE:
77                         (*elem) = value;
78                         break;
79                 case PAINT_MASK_INVERT:
80                         (*elem) = 1.0f - (*elem);
81                         break;
82         }
83 }
84
85 static int mask_flood_fill_exec(bContext *C, wmOperator *op)
86 {
87         ARegion *ar = CTX_wm_region(C);
88         struct Scene *scene = CTX_data_scene(C);
89         Object *ob = CTX_data_active_object(C);
90         struct MultiresModifierData *mmd = sculpt_multires_active(scene, ob);
91         PaintMaskFloodMode mode;
92         float value;
93         DerivedMesh *dm;
94         PBVH *pbvh;
95         PBVHNode **nodes;
96         int totnode, i;
97
98         mode = RNA_enum_get(op->ptr, "mode");
99         value = RNA_float_get(op->ptr, "value");
100
101         ED_sculpt_mask_layers_ensure(ob, mmd);
102
103         dm = mesh_get_derived_final(scene, ob, CD_MASK_BAREMESH);
104         pbvh = dm->getPBVH(ob, dm);
105         ob->sculpt->pbvh = pbvh;
106
107         BKE_pbvh_search_gather(pbvh, NULL, NULL, &nodes, &totnode);
108
109         sculpt_undo_push_begin("Mask flood fill");
110
111         for (i = 0; i < totnode; i++) {
112                 PBVHVertexIter vi;
113
114                 sculpt_undo_push_node(ob, nodes[i], SCULPT_UNDO_MASK);
115
116                 BKE_pbvh_vertex_iter_begin(pbvh, nodes[i], vi, PBVH_ITER_UNIQUE) {
117                         mask_flood_fill_set_elem(vi.mask, mode, value);
118                 } BKE_pbvh_vertex_iter_end;
119                 
120                 BKE_pbvh_node_mark_update(nodes[i]);
121                 if (BKE_pbvh_type(pbvh) == PBVH_GRIDS)
122                         multires_mark_as_modified(ob, MULTIRES_COORDS_MODIFIED);
123         }
124         
125         sculpt_undo_push_end();
126
127         if (nodes)
128                 MEM_freeN(nodes);
129
130         ED_region_tag_redraw(ar);
131
132         return OPERATOR_FINISHED;
133 }
134
135 void PAINT_OT_mask_flood_fill(struct wmOperatorType *ot)
136 {
137         static EnumPropertyItem mode_items[] = {
138                 {PAINT_MASK_FLOOD_VALUE, "VALUE", 0, "Value", "Set mask to the level specified by the 'value' property"},
139                 {PAINT_MASK_INVERT, "INVERT", 0, "Invert", "Invert the mask"},
140                 {0}};
141
142         /* identifiers */
143         ot->name = "Mask Flood Fill";
144         ot->idname = "PAINT_OT_mask_flood_fill";
145         ot->description = "Fill the whole mask with a given value, or invert its values";
146
147         /* api callbacks */
148         ot->exec = mask_flood_fill_exec;
149         ot->poll = sculpt_mode_poll;
150
151         ot->flag = OPTYPE_REGISTER;
152
153         /* rna */
154         RNA_def_enum(ot->srna, "mode", mode_items, PAINT_MASK_FLOOD_VALUE, "Mode", NULL);
155         RNA_def_float(ot->srna, "value", 0, 0, 1, "Value",
156                       "Mask level to use when mode is 'Value'; zero means no masking and one is fully masked", 0, 1);
157 }
158
159 /* Box select, operator is VIEW3D_OT_select_border, defined in view3d_select.c */
160
161 static int is_effected(float planes[4][4], const float co[3])
162 {
163         return isect_point_planes_v3(planes, 4, co);
164 }
165
166 int do_sculpt_mask_box_select(ViewContext *vc, rcti *rect, bool select, bool UNUSED(extend))
167 {
168         Sculpt *sd = vc->scene->toolsettings->sculpt;
169         BoundBox bb;
170         bglMats mats = {{0}};
171         float clip_planes[4][4];
172         ARegion *ar = vc->ar;
173         struct Scene *scene = vc->scene;
174         Object *ob = vc->obact;
175         struct MultiresModifierData *mmd = sculpt_multires_active(scene, ob);
176         PaintMaskFloodMode mode;
177         float value;
178         DerivedMesh *dm;
179         PBVH *pbvh;
180         PBVHNode **nodes;
181         int totnode, i;
182
183         mode = PAINT_MASK_FLOOD_VALUE;
184         value = select ? 1.0 : 0.0;
185
186         /* transform the clip planes in object space */
187         view3d_get_transformation(vc->ar, vc->rv3d, vc->obact, &mats);
188         ED_view3d_clipping_calc(&bb, clip_planes, &mats, rect);
189         mul_m4_fl(clip_planes, -1.0f);
190
191         ED_sculpt_mask_layers_ensure(ob, mmd);
192
193         dm = mesh_get_derived_final(scene, ob, CD_MASK_BAREMESH);
194         pbvh = dm->getPBVH(ob, dm);
195         ob->sculpt->pbvh = pbvh;
196
197         BKE_pbvh_search_gather(pbvh, BKE_pbvh_node_planes_contain_AABB, clip_planes, &nodes, &totnode);
198
199         sculpt_undo_push_begin("Mask box fill");
200
201         #pragma omp parallel for schedule(guided) if (sd->flags & SCULPT_USE_OPENMP)
202         for (i = 0; i < totnode; i++) {
203                 PBVHVertexIter vi;
204
205                 sculpt_undo_push_node(ob, nodes[i], SCULPT_UNDO_MASK);
206
207                 BKE_pbvh_vertex_iter_begin(pbvh, nodes[i], vi, PBVH_ITER_UNIQUE) {
208                         if (is_effected(clip_planes, vi.co))
209                                 mask_flood_fill_set_elem(vi.mask, mode, value);
210                 } BKE_pbvh_vertex_iter_end;
211
212                 BKE_pbvh_node_mark_update(nodes[i]);
213                 if (BKE_pbvh_type(pbvh) == PBVH_GRIDS)
214                         multires_mark_as_modified(ob, MULTIRES_COORDS_MODIFIED);
215         }
216
217         sculpt_undo_push_end();
218
219         if (nodes)
220                 MEM_freeN(nodes);
221
222         ED_region_tag_redraw(ar);
223
224         return OPERATOR_FINISHED;
225 }
226
227 typedef struct LassoMaskData {
228         struct ViewContext *vc;
229         float projviewobjmat[4][4];
230         bool *px;
231         int width;
232         rcti rect; /* bounding box for scanfilling */
233 } LassoMaskData;
234
235
236 /* Lasso select. This could be defined as part of VIEW3D_OT_select_lasso, still the shortcuts conflict,
237  * so we will use a separate operator */
238
239 static bool is_effected_lasso(LassoMaskData *data, float co[3])
240 {
241         float scr_co_f[2];
242         short scr_co_s[2];
243
244         /* first project point to 2d space */
245         ED_view3d_project_float_v2_m4(data->vc->ar, co, scr_co_f, data->projviewobjmat);
246
247         scr_co_s[0] = scr_co_f[0];
248         scr_co_s[1] = scr_co_f[1];
249
250         /* clip against screen, because lasso is limited to screen only */
251         if (scr_co_s[0] < data->rect.xmin || scr_co_s[1] < data->rect.ymin || scr_co_s[0] >= data->rect.xmax || scr_co_s[1] >= data->rect.ymax)
252                 return false;
253
254         scr_co_s[0] -= data->rect.xmin;
255         scr_co_s[1] -= data->rect.ymin;
256
257         return data->px[scr_co_s[1] * data->width + scr_co_s[0]];
258 }
259
260 static void mask_lasso_px_cb(int x, int y, void *user_data)
261 {
262         struct LassoMaskData *data = user_data;
263         data->px[(y * data->width) + x] = true;
264 }
265
266 static int paint_mask_gesture_lasso_exec(bContext *C, wmOperator *op)
267 {
268         int mcords_tot;
269         int (*mcords)[2] = (int (*)[2])WM_gesture_lasso_path_to_array(C, op, &mcords_tot);
270
271         if (mcords) {
272                 float clip_planes[4][4];
273                 BoundBox bb;
274                 bglMats mats = {{0}};
275                 Object *ob;
276                 ViewContext vc;
277                 LassoMaskData data;
278                 Sculpt *sd = CTX_data_tool_settings(C)->sculpt;
279
280                 struct MultiresModifierData *mmd;
281                 DerivedMesh *dm;
282                 PBVH *pbvh;
283                 PBVHNode **nodes;
284                 int totnode, i;
285                 PaintMaskFloodMode mode = PAINT_MASK_FLOOD_VALUE;
286                 bool select = true; /* TODO: see how to implement deselection */
287                 float value = select ? 1.0 : 0.0;
288
289                 /* Calculations of individual vertices are done in 2D screen space to diminish the amount of
290                  * calculations done. Bounding box PBVH collision is not computed against enclosing rectangle
291                  * of lasso */
292                 view3d_set_viewcontext(C, &vc);
293                 view3d_get_transformation(vc.ar, vc.rv3d, vc.obact, &mats);
294
295                 /* lasso data calculations */
296                 data.vc = &vc;
297                 ob = vc.obact;
298                 ED_view3d_ob_project_mat_get(vc.rv3d, ob, data.projviewobjmat);
299
300                 BLI_lasso_boundbox(&data.rect, (const int (*)[2])mcords, mcords_tot);
301                 data.width = data.rect.xmax - data.rect.xmin;
302                 data.px = MEM_callocN(sizeof(*data.px) * data.width * (data.rect.ymax - data.rect.ymin), "lasso_mask_pixel_buffer");
303
304                 fill_poly_v2i_n(
305                        data.rect.xmin, data.rect.ymin, data.rect.xmax, data.rect.ymax,
306                        (const int (*)[2])mcords, mcords_tot,
307                        mask_lasso_px_cb, &data);
308
309                 ED_view3d_clipping_calc(&bb, clip_planes, &mats, &data.rect);
310                 mul_m4_fl(clip_planes, -1.0f);
311
312                 mmd = sculpt_multires_active(vc.scene, ob);
313                 ED_sculpt_mask_layers_ensure(ob, mmd);
314                 dm = mesh_get_derived_final(vc.scene, ob, CD_MASK_BAREMESH);
315                 pbvh = dm->getPBVH(ob, dm);
316                 ob->sculpt->pbvh = pbvh;
317
318                 /* gather nodes inside lasso's enclosing rectangle (should greatly help with bigger meshes) */
319                 BKE_pbvh_search_gather(pbvh, BKE_pbvh_node_planes_contain_AABB, clip_planes, &nodes, &totnode);
320
321                 sculpt_undo_push_begin("Mask lasso fill");
322
323                 #pragma omp parallel for schedule(guided) if (sd->flags & SCULPT_USE_OPENMP)
324                 for (i = 0; i < totnode; i++) {
325                         PBVHVertexIter vi;
326
327                         sculpt_undo_push_node(ob, nodes[i], SCULPT_UNDO_MASK);
328
329                         BKE_pbvh_vertex_iter_begin(pbvh, nodes[i], vi, PBVH_ITER_UNIQUE) {
330                                 if (is_effected_lasso(&data, vi.co))
331                                         mask_flood_fill_set_elem(vi.mask, mode, value);
332                         } BKE_pbvh_vertex_iter_end;
333
334                         BKE_pbvh_node_mark_update(nodes[i]);
335                         if (BKE_pbvh_type(pbvh) == PBVH_GRIDS)
336                                 multires_mark_as_modified(ob, MULTIRES_COORDS_MODIFIED);
337                 }
338
339                 sculpt_undo_push_end();
340
341                 if (nodes)
342                         MEM_freeN(nodes);
343
344                 ED_region_tag_redraw(vc.ar);
345                 MEM_freeN((void *)mcords);
346                 MEM_freeN(data.px);
347
348                 return OPERATOR_FINISHED;
349         }
350         return OPERATOR_PASS_THROUGH;
351 }
352
353 void PAINT_OT_mask_lasso_gesture(wmOperatorType *ot)
354 {
355         PropertyRNA *prop;
356
357         ot->name = "Mask Lasso Gesture";
358         ot->idname = "PAINT_OT_mask_lasso_gesture";
359         ot->description = "Add mask within the lasso as you move the pointer";
360
361         ot->invoke = WM_gesture_lasso_invoke;
362         ot->modal = WM_gesture_lasso_modal;
363         ot->exec = paint_mask_gesture_lasso_exec;
364
365         ot->poll = sculpt_mode_poll;
366
367         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
368
369         prop = RNA_def_property(ot->srna, "path", PROP_COLLECTION, PROP_NONE);
370         RNA_def_property_struct_runtime(prop, &RNA_OperatorMousePath);
371 }