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 }