Blender V5.3
paint_mask.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2012 by Nicholas Bishop. All rights reserved.
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8#include "paint_mask.hh"
9
10#include <cstdlib>
11
12#include "MEM_guardedalloc.h"
13
14#include "DNA_object_types.h"
15
16#include "BLI_array_utils.hh"
17#include "BLI_bit_span_ops.hh"
19#include "BLI_span.hh"
20#include "BLI_vector.hh"
21
22#include "BKE_attribute.hh"
23#include "BKE_brush.hh"
24#include "BKE_ccg.hh"
25#include "BKE_context.hh"
26#include "BKE_mesh.hh"
27#include "BKE_multires.hh"
28#include "BKE_object_types.hh"
29#include "BKE_paint.hh"
30#include "BKE_paint_bvh.hh"
31#include "BKE_subdiv_ccg.hh"
32
33#include "RNA_access.hh"
34#include "RNA_define.hh"
35
36#include "WM_api.hh"
37#include "WM_types.hh"
38
39#include "ED_select_utils.hh"
40
41#include "bmesh.hh"
42
43#include "../paint_intern.hh"
44#include "mesh_brush_common.hh"
45#include "sculpt_gesture.hh"
46#include "sculpt_hide.hh"
47#include "sculpt_intern.hh"
48#include "sculpt_undo.hh"
49
51
52/* -------------------------------------------------------------------- */
55
57{
58 const SculptSession &ss = *object.runtime->sculpt_session;
59 switch (bke::object::pbvh_get(object)->type()) {
61 const Mesh &mesh = *id_cast<const Mesh *>(object.data);
62 const bke::AttributeAccessor attributes = mesh.attributes();
63 const VArray mask = *attributes.lookup_or_default<float>(
64 ".sculpt_mask", bke::AttrDomain::Point, 0.0f);
65 Array<float> result(mask.size());
66 mask.materialize(result);
67 return result;
68 }
70 const SubdivCCG &subdiv_ccg = *ss.subdiv_ccg;
71 if (subdiv_ccg.masks.is_empty()) {
72 return Array<float>(subdiv_ccg.positions.size(), 0.0f);
73 }
74 return subdiv_ccg.masks;
75 }
77 BMesh &bm = *ss.bm;
78 const int offset = CustomData_get_offset_named(&bm.vdata, CD_PROP_FLOAT, ".sculpt_mask");
80 if (offset == -1) {
81 result.fill(0.0f);
82 }
83 else {
84 vert_random_access_ensure(const_cast<Object &>(object));
85 for (const int i : result.index_range()) {
87 }
88 }
89 return result;
90 }
91 }
93 return {};
94}
95
96void mix_new_masks(const Span<float> new_masks, const float factor, const MutableSpan<float> masks)
97{
98 BLI_assert(new_masks.size() == masks.size());
99
100 for (const int i : masks.index_range()) {
101 masks[i] += (new_masks[i] - masks[i]) * factor;
102 }
103}
104
105void mix_new_masks(const Span<float> new_masks,
106 const Span<float> factors,
107 const MutableSpan<float> masks)
108{
109 BLI_assert(new_masks.size() == factors.size());
110 BLI_assert(new_masks.size() == masks.size());
111
112 for (const int i : masks.index_range()) {
113 masks[i] += (new_masks[i] - masks[i]) * factors[i];
114 }
115}
116
118{
119 for (float &mask : masks) {
120 mask = std::clamp(mask, 0.0f, 1.0f);
121 }
122}
123
125{
126 for (float &mask : masks) {
127 mask = 1.0f - mask;
128 }
129}
130
132 const Set<BMVert *, 0> &verts,
133 const MutableSpan<float> r_mask)
134{
135 BLI_assert(verts.size() == r_mask.size());
136
137 /* TODO: Avoid overhead of accessing attributes for every bke::pbvh::Tree node. */
138 const int mask_offset = CustomData_get_offset_named(&bm.vdata, CD_PROP_FLOAT, ".sculpt_mask");
139 int i = 0;
140 for (const BMVert *vert : verts) {
141 r_mask[i] = (mask_offset == -1) ? 0.0f : BM_ELEM_CD_GET_FLOAT(vert, mask_offset);
142 i++;
143 }
144}
145
146void gather_mask_grids(const SubdivCCG &subdiv_ccg,
147 const Span<int> grids,
148 const MutableSpan<float> r_mask)
149{
150 if (!subdiv_ccg.masks.is_empty()) {
151 gather_data_grids(subdiv_ccg, subdiv_ccg.masks.as_span(), grids, r_mask);
152 }
153 else {
154 r_mask.fill(0.0f);
155 }
156}
157
158void scatter_mask_grids(const Span<float> mask, SubdivCCG &subdiv_ccg, const Span<int> grids)
159{
160 scatter_data_grids(subdiv_ccg, mask, grids, subdiv_ccg.masks.as_mutable_span());
161}
162
164{
165 BLI_assert(verts.size() == mask.size());
166
167 const int mask_offset = CustomData_get_offset_named(&bm.vdata, CD_PROP_FLOAT, ".sculpt_mask");
168 BLI_assert(mask_offset != -1);
169 int i = 0;
170 for (BMVert *vert : verts) {
171 BM_ELEM_CD_SET_FLOAT(vert, mask_offset, mask[i]);
172 i++;
173 }
174}
175
176static float average_masks(const int mask_offset, const Span<const BMVert *> verts)
177{
178 float sum = 0;
179 for (const BMVert *vert : verts) {
180 sum += BM_ELEM_CD_GET_FLOAT(vert, mask_offset);
181 }
182 return sum / float(verts.size());
183}
184
185void average_neighbor_mask_bmesh(const int mask_offset,
186 const Set<BMVert *, 0> &verts,
187 const MutableSpan<float> new_masks)
188{
189 BMeshNeighborVerts neighbors;
190 int i = 0;
191 for (BMVert *vert : verts) {
192 new_masks[i] = average_masks(mask_offset, vert_neighbors_get_bmesh(*vert, neighbors));
193 i++;
194 }
195}
196
197void update_mask_mesh(const Depsgraph &depsgraph,
198 Object &object,
199 const IndexMask &node_mask,
200 FunctionRef<void(MutableSpan<float>, Span<int>)> update_fn)
201{
204
205 Mesh &mesh = *id_cast<Mesh *>(object.data);
206 bke::MutableAttributeAccessor attributes = mesh.attributes_for_write();
207 const VArraySpan hide_vert = *attributes.lookup<bool>(".hide_vert", bke::AttrDomain::Point);
209 ".sculpt_mask", bke::AttrDomain::Point);
210 if (!mask) {
211 return;
212 }
213
214 struct LocalData {
215 Vector<int> visible_verts;
217 };
218
219 Array<bool> node_changed(node_mask.min_array_size(), false);
220
222 /* Even if only shared vertices of a node are updated it needs to be marked dirty, The mask
223 * values for the shared vertices are written by the thread processing the owning node, so
224 * cache the values before the main update loop to avoid nondeterministic read/write ordering.
225 */
226 Array<Vector<float>> old_masks(node_mask.min_array_size());
227 node_mask.foreach_index(
228 [&](const int i) {
229 LocalData &tls = all_tls.local();
230 const Span<int> shared_visible_verts = hide::node_visible_shared_verts(
231 nodes[i], hide_vert, tls.visible_verts);
232 old_masks[i].resize(shared_visible_verts.size());
234 mask.span.as_span(), shared_visible_verts, old_masks[i].as_mutable_span());
235 },
237
238 node_mask.foreach_index(
239 [&](const int i) {
240 LocalData &tls = all_tls.local();
241 int unique_visible_verts_num = 0;
242 const Span<int> all_visible_verts = hide::node_visible_all_verts(
243 nodes[i], hide_vert, tls.visible_verts, unique_visible_verts_num);
244 const Span<int> unique_verts = all_visible_verts.take_front(unique_visible_verts_num);
245 const Span<int> shared_verts = all_visible_verts.drop_front(unique_visible_verts_num);
246 tls.mask.resize(all_visible_verts.size());
247 gather_data_mesh(mask.span.as_span(), all_visible_verts, tls.mask.as_mutable_span());
248 update_fn(tls.mask, all_visible_verts);
250 mask.span, unique_verts, tls.mask.as_span().take_front(unique_verts.size())))
251 {
252 if (shared_verts.is_empty() ||
253 old_masks[i].as_span() == tls.mask.as_span().drop_front(unique_verts.size()))
254 {
255 return;
256 }
257 }
258 undo::push_node(depsgraph, object, &nodes[i], undo::Type::Mask);
260 tls.mask.as_span().take_front(unique_verts.size()), unique_verts, mask.span);
262 node_changed[i] = true;
263 },
265
266 IndexMaskMemory memory;
267 pbvh.tag_masks_changed(IndexMask::from_bools(node_changed, memory));
268
269 mask.finish();
270}
271
273 const CCGKey &key,
274 const Span<int> grids,
275 const Span<float> values)
276{
277 BLI_assert(grids.size() * key.grid_area == values.size());
278
279 const IndexRange range = grids.index_range();
280 return std::all_of(range.begin(), range.end(), [&](const int i) {
281 return masks.slice(bke::ccg::grid_range(key, grids[i])) ==
282 values.slice(bke::ccg::grid_range(key, i));
283 return true;
284 });
285}
286
287bool mask_equals_array_bmesh(const int mask_offset,
288 const Set<BMVert *, 0> &verts,
289 const Span<float> values)
290{
291 BLI_assert(verts.size() == values.size());
292
293 int i = 0;
294 for (const BMVert *vert : verts) {
295 if (BM_ELEM_CD_GET_FLOAT(vert, mask_offset) != values[i]) {
296 return false;
297 }
298 i++;
299 }
300 return true;
301}
302
304
305/* -------------------------------------------------------------------- */
309
310/* The gesture API doesn't write to this enum type,
311 * it writes to eSelectOp from ED_select_utils.hh.
312 * We must thus map the modes here to the desired
313 * eSelectOp modes.
314 *
315 * Fixes #102349.
316 */
322
323static const EnumPropertyItem mode_items[] = {
325 "VALUE",
326 0,
327 "Value",
328 "Set mask to the level specified by the 'value' property"},
330 "VALUE_INVERSE",
331 0,
332 "Value Inverted",
333 "Set mask to the level specified by the inverted 'value' property"},
334 {int(FloodFillMode::InverseMeshValue), "INVERT", 0, "Invert", "Invert the mask"},
335 {0}};
336
338 const Span<bool> hide_vert,
339 Vector<int> &indices)
340{
341 if (hide_vert.is_empty()) {
342 return {};
343 }
344 const Span<int> verts = node.verts();
346 return verts;
347 }
348 indices.resize(verts.size());
349 const int *end = std::copy_if(verts.begin(), verts.end(), indices.begin(), [&](const int vert) {
350 return hide_vert[vert];
351 });
352 indices.resize(end - indices.begin());
353 return indices;
354}
355
356static bool try_remove_mask_mesh(const Depsgraph &depsgraph,
357 Object &object,
358 const IndexMask &node_mask)
359{
362 Mesh &mesh = *id_cast<Mesh *>(object.data);
363 bke::MutableAttributeAccessor attributes = mesh.attributes_for_write();
364 const VArraySpan mask = *attributes.lookup<float>(".sculpt_mask", bke::AttrDomain::Point);
365 if (mask.is_empty()) {
366 return true;
367 }
368
369 /* If there are any hidden vertices that shouldn't be affected with a mask value set, the
370 * attribute cannot be removed. This could also be done by building an IndexMask in the full
371 * vertex domain. */
372 const VArraySpan hide_vert = *attributes.lookup<bool>(".hide_vert", bke::AttrDomain::Point);
374 const bool hidden_masked_verts = threading::parallel_reduce(
375 node_mask.index_range(),
376 1,
377 false,
378 [&](const IndexRange range, bool value) {
379 if (value) {
380 return value;
381 }
382 Vector<int> &index_data = all_index_data.local();
383 node_mask.slice(range).foreach_index([&](const int i) {
384 if (value) {
385 return;
386 }
387 const Span<int> verts = get_hidden_verts(nodes[i], hide_vert, index_data);
388 if (std::any_of(verts.begin(), verts.end(), [&](int i) { return mask[i] > 0.0f; })) {
389 value = true;
390 return;
391 }
392 });
393 return value;
394 },
395 std::logical_or());
396 if (hidden_masked_verts) {
397 return false;
398 }
399
400 IndexMaskMemory memory;
401 const IndexMask changed_nodes = IndexMask::from_predicate(
402 node_mask,
403 memory,
404 [&](const int i) {
405 const Span<int> verts = nodes[i].verts();
406 return std::any_of(
407 verts.begin(), verts.end(), [&](const int i) { return mask[i] != 0.0f; });
408 },
409 exec_mode::grain_size(1));
410
411 undo::push_nodes(depsgraph, object, changed_nodes, undo::Type::Mask);
412 attributes.remove(".sculpt_mask");
413 changed_nodes.foreach_index([&](const int i) {
414 BKE_pbvh_node_fully_masked_set(nodes[i], false);
415 BKE_pbvh_node_fully_unmasked_set(nodes[i], true);
416 });
417 pbvh.tag_masks_changed(changed_nodes);
418 return true;
419}
420
421static void fill_mask_mesh(const Depsgraph &depsgraph,
422 Object &object,
423 const float value,
424 const IndexMask &node_mask)
425{
428
429 Mesh &mesh = *id_cast<Mesh *>(object.data);
430 bke::MutableAttributeAccessor attributes = mesh.attributes_for_write();
431 const VArraySpan hide_vert = *attributes.lookup<bool>(".hide_vert", bke::AttrDomain::Point);
432 if (value == 0.0f) {
433 if (try_remove_mask_mesh(depsgraph, object, node_mask)) {
434 return;
435 }
436 }
437
439 ".sculpt_mask", bke::AttrDomain::Point);
440
441 Array<bool> node_changed(node_mask.min_array_size(), false);
442
443 node_mask.foreach_index(
444 [&](const int i) {
446 const Span<int> verts = hide::node_visible_verts(nodes[i], hide_vert, index_data);
447 if (std::all_of(
448 verts.begin(), verts.end(), [&](int i) { return mask.span[i] == value; })) {
449 return;
450 }
451 undo::push_node(depsgraph, object, &nodes[i], undo::Type::Mask);
452 mask.span.fill_indices(verts, value);
453 node_changed[i] = true;
454 },
456
457 IndexMaskMemory memory;
458 const IndexMask changed_nodes = IndexMask::from_bools(node_mask, node_changed, memory);
459 pbvh.tag_masks_changed(changed_nodes);
460
461 mask.finish();
462 changed_nodes.foreach_index([&](const int i) {
463 BKE_pbvh_node_fully_masked_set(nodes[i], value == 1.0f);
464 BKE_pbvh_node_fully_unmasked_set(nodes[i], value == 0.0f);
465 });
466}
467
468static void fill_mask_grids(Main &bmain,
469 const Scene &scene,
470 Depsgraph &depsgraph,
471 Object &object,
472 const float value,
473 const IndexMask &node_mask)
474{
475 SculptSession &ss = *object.runtime->sculpt_session;
476
477 if (value == 0.0f && ss.subdiv_ccg->masks.is_empty()) {
478 /* NOTE: Deleting the mask array would be possible here. */
479 return;
480 }
481
482 MultiresModifierData &mmd = *BKE_sculpt_multires_active(&scene, &object);
483 BKE_sculpt_mask_layers_ensure(&depsgraph, &bmain, &object, &mmd);
484
487 SubdivCCG &subdiv_ccg = *ss.subdiv_ccg;
488 const CCGKey key = BKE_subdiv_ccg_key_top_level(subdiv_ccg);
489
490 const BitGroupVector<> &grid_hidden = subdiv_ccg.grid_hidden;
491
492 Array<bool> node_changed(node_mask.min_array_size(), false);
493
494 MutableSpan<float> masks = subdiv_ccg.masks;
495 node_mask.foreach_index(
496 [&](const int i) {
497 const Span<int> grid_indices = nodes[i].grids();
498 if (std::all_of(
499 grid_indices.begin(),
500 grid_indices.end(),
501 [&](const int grid) {
502 const Span<float> grid_masks = masks.slice(bke::ccg::grid_range(key, grid));
503 return std::all_of(grid_masks.begin(), grid_masks.end(), [&](const float mask) {
504 return mask == value;
505 });
506 }))
507 {
508 return;
509 }
510 undo::push_node(depsgraph, object, &nodes[i], undo::Type::Mask);
511
512 if (grid_hidden.is_empty()) {
513 for (const int grid : grid_indices) {
514 masks.slice(bke::ccg::grid_range(key, grid)).fill(value);
515 }
516 }
517 else {
518 for (const int grid : grid_indices) {
519 MutableSpan<float> grid_masks = masks.slice(bke::ccg::grid_range(key, grid));
520 bits::foreach_0_index(grid_hidden[grid], [&](const int i) { grid_masks[i] = value; });
521 }
522 }
523 node_changed[i] = true;
524 },
526
527 IndexMaskMemory memory;
528 const IndexMask changed_nodes = IndexMask::from_bools(node_changed, memory);
529 if (node_changed.is_empty()) {
530 return;
531 }
532 pbvh.tag_masks_changed(changed_nodes);
534 changed_nodes.foreach_index([&](const int i) {
535 BKE_pbvh_node_fully_masked_set(nodes[i], value == 1.0f);
536 BKE_pbvh_node_fully_unmasked_set(nodes[i], value == 0.0f);
537 });
538}
539
540static void fill_mask_bmesh(const Depsgraph &depsgraph,
541 Object &object,
542 const float value,
543 const IndexMask &node_mask)
544{
545 SculptSession &ss = *object.runtime->sculpt_session;
548
549 BMesh &bm = *ss.bm;
550 const int offset = CustomData_get_offset_named(&bm.vdata, CD_PROP_FLOAT, ".sculpt_mask");
551 if (value == 0.0f && offset == -1) {
552 return;
553 }
554 if (offset == -1) {
555 /* Mask is not dynamically added or removed for dynamic topology sculpting. */
557 return;
558 }
559
560 undo::push_nodes(depsgraph, object, node_mask, undo::Type::Mask);
561
562 Array<bool> node_changed(node_mask.min_array_size(), false);
563
564 node_mask.foreach_index(
565 [&](const int i) {
566 bool changed = false;
568 if (!BM_elem_flag_test(vert, BM_ELEM_HIDDEN)) {
569 if (BM_ELEM_CD_GET_FLOAT(vert, offset) != value) {
570 BM_ELEM_CD_SET_FLOAT(vert, offset, value);
571 changed = true;
572 }
573 }
574 }
575 if (changed) {
576 node_changed[i] = true;
577 }
578 },
580 IndexMaskMemory memory;
581 const IndexMask changed_nodes = IndexMask::from_bools(node_changed, memory);
582 if (node_changed.is_empty()) {
583 return;
584 }
585 pbvh.tag_masks_changed(changed_nodes);
586 changed_nodes.foreach_index([&](const int i) {
587 BKE_pbvh_node_fully_masked_set(nodes[i], value == 1.0f);
588 BKE_pbvh_node_fully_unmasked_set(nodes[i], value == 0.0f);
589 });
590}
591
592static void fill_mask(
593 Main &bmain, const Scene &scene, Depsgraph &depsgraph, Object &object, const float value)
594{
596 IndexMaskMemory memory;
597 const IndexMask node_mask = bke::pbvh::all_leaf_nodes(pbvh, memory);
598 switch (pbvh.type()) {
600 fill_mask_mesh(depsgraph, object, value, node_mask);
601 break;
603 fill_mask_grids(bmain, scene, depsgraph, object, value, node_mask);
604 break;
606 fill_mask_bmesh(depsgraph, object, value, node_mask);
607 break;
608 }
609}
610
611static void invert_mask_grids(Main &bmain,
612 const Scene &scene,
613 Depsgraph &depsgraph,
614 Object &object,
615 const IndexMask &node_mask)
616{
617 SculptSession &ss = *object.runtime->sculpt_session;
618
619 MultiresModifierData &mmd = *BKE_sculpt_multires_active(&scene, &object);
620 BKE_sculpt_mask_layers_ensure(&depsgraph, &bmain, &object, &mmd);
621
622 undo::push_nodes(depsgraph, object, node_mask, undo::Type::Mask);
623
626 SubdivCCG &subdiv_ccg = *ss.subdiv_ccg;
627 const BitGroupVector<> &grid_hidden = subdiv_ccg.grid_hidden;
628
629 const CCGKey key = BKE_subdiv_ccg_key_top_level(subdiv_ccg);
630 MutableSpan<float> masks = subdiv_ccg.masks;
631 node_mask.foreach_index(
632 [&](const int i) {
633 const Span<int> grid_indices = nodes[i].grids();
634 if (grid_hidden.is_empty()) {
635 for (const int grid : grid_indices) {
636 for (float &value : masks.slice(bke::ccg::grid_range(key, grid))) {
637 value = 1.0f - value;
638 }
639 }
640 }
641 else {
642 for (const int grid : grid_indices) {
643 MutableSpan<float> grid_masks = masks.slice(bke::ccg::grid_range(key, grid));
644 bits::foreach_0_index(grid_hidden[grid],
645 [&](const int i) { grid_masks[i] = 1.0f - grid_masks[i]; });
646 }
647 }
649 },
651 pbvh.tag_masks_changed(node_mask);
652
654}
655
656static void invert_mask_bmesh(const Depsgraph &depsgraph,
657 Object &object,
658 const IndexMask &node_mask)
659{
662 BMesh &bm = *object.runtime->sculpt_session->bm;
663 const int offset = CustomData_get_offset_named(&bm.vdata, CD_PROP_FLOAT, ".sculpt_mask");
664 if (offset == -1) {
666 return;
667 }
668
669 undo::push_nodes(depsgraph, object, node_mask, undo::Type::Mask);
670 node_mask.foreach_index(
671 [&](const int i) {
673 if (!BM_elem_flag_test(vert, BM_ELEM_HIDDEN)) {
674 BM_ELEM_CD_SET_FLOAT(vert, offset, 1.0f - BM_ELEM_CD_GET_FLOAT(vert, offset));
675 }
676 }
678 },
680 pbvh.tag_masks_changed(node_mask);
681}
682
683static void invert_mask(Main &bmain, const Scene &scene, Depsgraph &depsgraph, Object &object)
684{
685 IndexMaskMemory memory;
686 const IndexMask node_mask = bke::pbvh::all_leaf_nodes(*bke::object::pbvh_get(object), memory);
687 switch (bke::object::pbvh_get(object)->type()) {
690 depsgraph, object, node_mask, [&](MutableSpan<float> mask, const Span<int> verts) {
691 for (const int vert : verts) {
692 mask[vert] = 1.0f - mask[vert];
693 }
694 });
695 break;
697 invert_mask_grids(bmain, scene, depsgraph, object, node_mask);
698 break;
700 invert_mask_bmesh(depsgraph, object, node_mask);
701 break;
702 }
703}
704
706{
707 Main &bmain = *CTX_data_main(C);
708 const Scene &scene = *CTX_data_scene(C);
709 Object &object = *CTX_data_active_object(C);
710 Depsgraph &depsgraph = *CTX_data_ensure_evaluated_depsgraph(C);
711
712 const FloodFillMode mode = FloodFillMode(RNA_enum_get(op->ptr, "mode"));
713 const float value = RNA_float_get(op->ptr, "value");
714
715 BKE_sculptsession_update_for_edit(&depsgraph, &object, false);
716
718
719 undo::push_begin(scene, object, op);
720 switch (mode) {
722 fill_mask(bmain, scene, depsgraph, object, value);
723 break;
725 fill_mask(bmain, scene, depsgraph, object, 1.0f - value);
726 break;
728 invert_mask(bmain, scene, depsgraph, object);
729 break;
730 }
731
732 undo::push_end(object);
733
735
736 return OPERATOR_FINISHED;
737}
738
740{
741 /* Identifiers. */
742 ot->name = "Mask Flood Fill";
743 ot->idname = "PAINT_OT_mask_flood_fill";
744 ot->description = "Fill the whole mask with a given value, or invert its values";
745
746 /* API callbacks. */
749
750 ot->flag = OPTYPE_REGISTER;
751
752 /* RNA. */
753 RNA_def_enum(ot->srna, "mode", mode_items, int(FloodFillMode::Value), "Mode", nullptr);
755 ot->srna,
756 "value",
757 0.0f,
758 0.0f,
759 1.0f,
760 "Value",
761 "Mask level to use when mode is 'Value'; zero means no masking and one is fully masked",
762 0.0f,
763 1.0f);
764}
765
767
768/* -------------------------------------------------------------------- */
772
779
780static void gesture_begin(bContext &C, wmOperator &op, gesture::GestureData &gesture_data)
781{
782 const Scene &scene = *CTX_data_scene(&C);
783 Depsgraph *depsgraph = CTX_data_depsgraph_pointer(&C);
784 BKE_sculptsession_update_for_edit(depsgraph, gesture_data.vc.obact, false);
785 undo::push_begin(scene, *gesture_data.vc.obact, &op);
786}
787
788static float mask_gesture_get_new_value(const float elem, FloodFillMode mode, float value)
789{
790 switch (mode) {
792 return value;
794 return 1.0f - value;
796 return 1.0f - elem;
797 }
799 return 0.0f;
800}
801
803{
804 const View3D *v3d = gesture_data.vc.v3d;
805 RegionView3D *rv3d = gesture_data.vc.rv3d;
806 Object &object = *gesture_data.vc.obact;
807 const bool clipping_enabled = RV3D_CLIPPING_ENABLED(v3d, rv3d);
808 if (clipping_enabled) {
809 ED_view3d_clipping_local(rv3d, object.object_to_world().ptr());
810 }
811 const IndexMask &node_mask = gesture_data.node_mask;
812 const MaskOperation &op = *reinterpret_cast<const MaskOperation *>(gesture_data.operation);
813 const Depsgraph &depsgraph = *gesture_data.vc.depsgraph;
814 switch (bke::object::pbvh_get(object)->type()) {
816 const Span<float3> positions = bke::pbvh::vert_positions_eval(depsgraph, object);
817 const Span<float3> normals = bke::pbvh::vert_normals_eval(depsgraph, object);
819 depsgraph, object, node_mask, [&](MutableSpan<float> node_mask, const Span<int> verts) {
820 for (const int i : verts.index_range()) {
821 const int vert = verts[i];
822 if (clipping_enabled && ED_view3d_clipping_test(rv3d, positions[vert], true)) {
823 continue;
824 }
825 if (gesture::is_affected(gesture_data, positions[vert], normals[vert])) {
826 node_mask[i] = mask_gesture_get_new_value(node_mask[i], op.mode, op.value);
827 }
828 }
829 });
830 break;
831 }
835 SubdivCCG &subdiv_ccg = *gesture_data.ss->subdiv_ccg;
836 const Span<float3> positions = subdiv_ccg.positions;
837 const Span<float3> normals = subdiv_ccg.normals;
838 MutableSpan<float> masks = subdiv_ccg.masks;
839 const BitGroupVector<> &grid_hidden = subdiv_ccg.grid_hidden;
840 const CCGKey key = BKE_subdiv_ccg_key_top_level(subdiv_ccg);
841
842 Array<bool> node_changed(node_mask.min_array_size(), false);
843
844 node_mask.foreach_index(
845 [&](const int node_index) {
846 bke::pbvh::GridsNode &node = nodes[node_index];
847 bool any_changed = false;
848 for (const int grid : node.grids()) {
849 const int vert_start = grid * key.grid_area;
850 BKE_subdiv_ccg_foreach_visible_grid_vert(key, grid_hidden, grid, [&](const int i) {
851 const int vert = vert_start + i;
852 if (clipping_enabled && ED_view3d_clipping_test(rv3d, positions[vert], true)) {
853 return;
854 }
855 if (gesture::is_affected(gesture_data, positions[vert], normals[vert])) {
856 float &mask = masks[vert];
857 if (!any_changed) {
858 any_changed = true;
859 undo::push_node(depsgraph, object, &node, undo::Type::Mask);
860 }
862 }
863 });
864 if (any_changed) {
866 node_changed[node_index] = true;
867 }
868 }
869 },
871
872 IndexMaskMemory memory;
873 pbvh.tag_masks_changed(IndexMask::from_bools(node_changed, memory));
874 break;
875 }
879 BMesh &bm = *gesture_data.ss->bm;
880 const int offset = CustomData_get_offset_named(&bm.vdata, CD_PROP_FLOAT, ".sculpt_mask");
881
882 Array<bool> node_changed(node_mask.min_array_size(), false);
883
884 node_mask.foreach_index(
885 [&](const int i) {
886 bool any_changed = false;
888 if (clipping_enabled && ED_view3d_clipping_test(rv3d, vert->co, true)) {
889 continue;
890 }
891 if (gesture::is_affected(gesture_data, vert->co, vert->no)) {
892 const float old_mask = BM_ELEM_CD_GET_FLOAT(vert, offset);
893 if (!any_changed) {
894 any_changed = true;
895 undo::push_node(depsgraph, object, &nodes[i], undo::Type::Mask);
896 }
897 const float new_mask = mask_gesture_get_new_value(old_mask, op.mode, op.value);
898 BM_ELEM_CD_SET_FLOAT(vert, offset, new_mask);
899 }
900 }
901 if (any_changed) {
903 node_changed[i] = true;
904 }
905 },
907
908 IndexMaskMemory memory;
909 pbvh.tag_masks_changed(IndexMask::from_bools(node_changed, memory));
910 break;
911 }
912 }
913}
914
915static void gesture_end(bContext &C, gesture::GestureData &gesture_data)
916{
917 Depsgraph *depsgraph = CTX_data_depsgraph_pointer(&C);
918 Object &object = *gesture_data.vc.obact;
919 if (bke::object::pbvh_get(object)->type() == bke::pbvh::Type::Grids) {
921 }
922 undo::push_end(object);
923}
924
925static void init_operation(bContext &C, gesture::GestureData &gesture_data, wmOperator &op)
926{
927 gesture_data.operation = reinterpret_cast<gesture::Operation *>(
929
930 MaskOperation *mask_operation = reinterpret_cast<MaskOperation *>(gesture_data.operation);
931
932 Object *object = gesture_data.vc.obact;
933 MultiresModifierData *mmd = BKE_sculpt_multires_active(gesture_data.vc.scene, object);
935 CTX_data_depsgraph_pointer(&C), CTX_data_main(&C), gesture_data.vc.obact, mmd);
936
937 mask_operation->op.begin = gesture_begin;
939 mask_operation->op.end = gesture_end;
940
941 mask_operation->mode = FloodFillMode(RNA_enum_get(op.ptr, "mode"));
942 mask_operation->value = RNA_float_get(op.ptr, "value");
943}
944
946{
947 RNA_def_enum(ot->srna, "mode", mode_items, int(FloodFillMode::Value), "Mode", nullptr);
949 ot->srna,
950 "value",
951 1.0f,
952 0.0f,
953 1.0f,
954 "Value",
955 "Mask level to use when mode is 'Value'; zero means no masking and one is fully masked",
956 0.0f,
957 1.0f);
958}
959
961{
962 std::unique_ptr<gesture::GestureData> gesture_data = gesture::init_from_box(C, op);
963 if (!gesture_data) {
964 return OPERATOR_CANCELLED;
965 }
966 init_operation(*C, *gesture_data, *op);
968 gesture::apply(*C, *gesture_data, *op);
969 return OPERATOR_FINISHED;
970}
971
973{
974 std::unique_ptr<gesture::GestureData> gesture_data = gesture::init_from_lasso(C, op);
975 if (!gesture_data) {
976 return OPERATOR_CANCELLED;
977 }
978 init_operation(*C, *gesture_data, *op);
980 gesture::apply(*C, *gesture_data, *op);
981 return OPERATOR_FINISHED;
982}
983
985{
986 std::unique_ptr<gesture::GestureData> gesture_data = gesture::init_from_line(C, op);
987 if (!gesture_data) {
988 return OPERATOR_CANCELLED;
989 }
990 init_operation(*C, *gesture_data, *op);
992 gesture::apply(*C, *gesture_data, *op);
993 return OPERATOR_FINISHED;
994}
995
997{
998 std::unique_ptr<gesture::GestureData> gesture_data = gesture::init_from_polyline(C, op);
999 if (!gesture_data) {
1000 return OPERATOR_CANCELLED;
1001 }
1002 init_operation(*C, *gesture_data, *op);
1004 gesture::apply(*C, *gesture_data, *op);
1005 return OPERATOR_FINISHED;
1006}
1007
1009{
1010 ot->name = "Mask Lasso Gesture";
1011 ot->idname = "PAINT_OT_mask_lasso_gesture";
1012 ot->description = "Mask within a shape defined by the cursor";
1013
1017
1019
1021
1024
1026}
1027
1029{
1030 ot->name = "Mask Box Gesture";
1031 ot->idname = "PAINT_OT_mask_box_gesture";
1032 ot->description = "Mask within a rectangle defined by the cursor";
1033
1036 ot->exec = gesture_box_exec;
1037
1039
1040 ot->flag = OPTYPE_REGISTER;
1041
1044
1046}
1047
1049{
1050 ot->name = "Mask Line Gesture";
1051 ot->idname = "PAINT_OT_mask_line_gesture";
1052 ot->description = "Mask to one side of a line defined by the cursor";
1053
1056 ot->exec = gesture_line_exec;
1057
1059
1060 ot->flag = OPTYPE_REGISTER;
1061
1064
1066}
1067
1069{
1070 ot->name = "Mask Polyline Gesture";
1071 ot->idname = "PAINT_OT_mask_polyline_gesture";
1072 ot->description = "Mask within a shape defined by the cursor";
1073
1077
1079
1081
1084
1086}
1087
1089
1090} // namespace blender::ed::sculpt_paint::mask
A BVH for high poly meshes.
Object is a sort of wrapper for general info.
#define RV3D_CLIPPING_ENABLED(v3d, rv3d)
Read Blender memory allocation and freeing.
#define C
Definition RandGen.cpp:29
#define BLI_assert_unreachable()
#define BM_ELEM_CD_SET_FLOAT(ele, offset, f)
#define BM_ELEM_CD_GET_FLOAT(ele, offset)
#define BM_elem_flag_test(ele, hflag)
int64_t size() const
Definition BLI_array.hh:267
Span< T > as_span() const
Definition BLI_array.hh:254
MutableSpan< T > as_mutable_span()
Definition BLI_array.hh:259
bool is_empty() const
Definition BLI_array.hh:275
static IndexMask from_predicate(const IndexMask &universe, LinearAllocator<> &memory, Fn &&predicate, exec_mode::Mode mode=exec_mode::parallel)
static IndexMask from_bools(Span< bool > bools, LinearAllocator<> &memory)
constexpr Iterator end() const
constexpr Iterator begin() const
constexpr int64_t size() const
Definition BLI_span.hh:499
constexpr MutableSpan slice(const int64_t start, const int64_t size) const
Definition BLI_span.hh:579
constexpr void fill(const T &value) const
Definition BLI_span.hh:523
constexpr IndexRange index_range() const
Definition BLI_span.hh:676
int64_t size() const
Definition BLI_set.hh:606
constexpr Span drop_front(int64_t n) const
Definition BLI_span.hh:175
constexpr int64_t size() const
Definition BLI_span.hh:256
constexpr const T * end() const
Definition BLI_span.hh:228
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
constexpr const T * begin() const
Definition BLI_span.hh:224
constexpr Span take_front(int64_t n) const
Definition BLI_span.hh:197
constexpr bool is_empty() const
Definition BLI_span.hh:264
void resize(const int64_t new_size)
GAttributeReader lookup_or_default(StringRef name, AttrDomain domain, AttrType data_type, const void *default_value=nullptr) const
GAttributeReader lookup(const StringRef name) const
GSpanAttributeWriter lookup_or_add_for_write_span(StringRef name, AttrDomain domain, AttrType data_type, const AttributeInit &initializer=AttributeInitDefaultValue())
IndexMask slice(IndexRange range) const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
bool indexed_data_equal(const Span< T > all_values, const Span< int > indices, const Span< T > values)
void foreach_0_index(const BitSpanT &data, Fn &&fn)
IndexRange grid_range(const int grid_area, const int grid)
pbvh::Tree * pbvh_get(Object &object)
IndexMask all_leaf_nodes(const Tree &pbvh, IndexMaskMemory &memory)
Definition pbvh.cc:2522
void node_update_mask_bmesh(int mask_offset, BMeshNode &node)
Definition pbvh.cc:1404
void node_update_mask_mesh(Span< float > mask, MeshNode &node)
Definition pbvh.cc:1345
void node_update_mask_grids(const CCGKey &key, Span< float > masks, GridsNode &node)
Definition pbvh.cc:1373
Span< float3 > vert_normals_eval(const Depsgraph &depsgraph, const Object &object_orig)
Definition pbvh.cc:952
Span< float3 > vert_positions_eval(const Depsgraph &depsgraph, const Object &object_orig)
Definition pbvh.cc:933
std::unique_ptr< GestureData > init_from_box(bContext *C, wmOperator *op)
void operator_properties(wmOperatorType *ot, ShapeType shapeType)
std::unique_ptr< GestureData > init_from_polyline(bContext *C, wmOperator *op)
std::unique_ptr< GestureData > init_from_line(bContext *C, const wmOperator *op)
void apply(bContext &C, GestureData &gesture_data, wmOperator &op)
std::unique_ptr< GestureData > init_from_lasso(bContext *C, wmOperator *op)
bool is_affected(const GestureData &gesture_data, const float3 &position, const float3 &normal)
Span< int > node_visible_all_verts(const bke::pbvh::MeshNode &node, const Span< bool > hide_vert, Vector< int > &indices, int &visible_unique_verts_num)
Span< int > node_visible_shared_verts(const bke::pbvh::MeshNode &node, const Span< bool > hide_vert, Vector< int > &indices)
Span< int > node_visible_verts(const bke::pbvh::MeshNode &node, const Span< bool > hide_vert, Vector< int, bke::pbvh::MESH_LEAF_LIMIT > &indices)
bool mask_equals_array_bmesh(const int mask_offset, const Set< BMVert *, 0 > &verts, const Span< float > values)
void scatter_mask_grids(const Span< float > mask, SubdivCCG &subdiv_ccg, const Span< int > grids)
static void gesture_end(bContext &C, gesture::GestureData &gesture_data)
static float average_masks(const int mask_offset, const Span< const BMVert * > verts)
void PAINT_OT_mask_polyline_gesture(wmOperatorType *ot)
bool mask_equals_array_grids(const Span< float > masks, const CCGKey &key, const Span< int > grids, const Span< float > values)
void PAINT_OT_mask_line_gesture(wmOperatorType *ot)
void write_mask_mesh(const Depsgraph &depsgraph, Object &object, const IndexMask &node_mask, FunctionRef< void(MutableSpan< float >, Span< int >)> write_fn)
static wmOperatorStatus gesture_polyline_exec(bContext *C, wmOperator *op)
static const EnumPropertyItem mode_items[]
static wmOperatorStatus mask_flood_fill_exec(bContext *C, wmOperator *op)
static void fill_mask_grids(Main &bmain, const Scene &scene, Depsgraph &depsgraph, Object &object, const float value, const IndexMask &node_mask)
static void invert_mask_bmesh(const Depsgraph &depsgraph, Object &object, const IndexMask &node_mask)
void update_mask_mesh(const Depsgraph &depsgraph, Object &object, const IndexMask &node_mask, FunctionRef< void(MutableSpan< float >, Span< int >)> update_fn)
static void init_operation(bContext &C, gesture::GestureData &gesture_data, wmOperator &op)
static bool try_remove_mask_mesh(const Depsgraph &depsgraph, Object &object, const IndexMask &node_mask)
void scatter_mask_bmesh(const Span< float > mask, const BMesh &bm, const Set< BMVert *, 0 > &verts)
static void gesture_apply_for_symmetry_pass(bContext &, gesture::GestureData &gesture_data)
void gather_mask_bmesh(const BMesh &bm, const Set< BMVert *, 0 > &verts, const MutableSpan< float > r_mask)
void mix_new_masks(const Span< float > new_masks, const float factor, const MutableSpan< float > masks)
Definition paint_mask.cc:96
static void gesture_begin(bContext &C, wmOperator &op, gesture::GestureData &gesture_data)
static wmOperatorStatus gesture_lasso_exec(bContext *C, wmOperator *op)
Array< float > duplicate_mask(const Object &object)
Definition paint_mask.cc:56
static Span< int > get_hidden_verts(const bke::pbvh::MeshNode &node, const Span< bool > hide_vert, Vector< int > &indices)
static void fill_mask(Main &bmain, const Scene &scene, Depsgraph &depsgraph, Object &object, const float value)
void invert_mask(const MutableSpan< float > masks)
void gather_mask_grids(const SubdivCCG &subdiv_ccg, const Span< int > grids, const MutableSpan< float > r_mask)
static wmOperatorStatus gesture_line_exec(bContext *C, wmOperator *op)
static void fill_mask_bmesh(const Depsgraph &depsgraph, Object &object, const float value, const IndexMask &node_mask)
static float mask_gesture_get_new_value(const float elem, FloodFillMode mode, float value)
static void gesture_operator_properties(wmOperatorType *ot)
void PAINT_OT_mask_box_gesture(wmOperatorType *ot)
static void invert_mask_grids(Main &bmain, const Scene &scene, Depsgraph &depsgraph, Object &object, const IndexMask &node_mask)
void PAINT_OT_mask_lasso_gesture(wmOperatorType *ot)
static wmOperatorStatus gesture_box_exec(bContext *C, wmOperator *op)
void clamp_mask(const MutableSpan< float > masks)
void PAINT_OT_mask_flood_fill(wmOperatorType *ot)
void average_neighbor_mask_bmesh(const int mask_offset, const Set< BMVert *, 0 > &verts, const MutableSpan< float > new_masks)
static void fill_mask_mesh(const Depsgraph &depsgraph, Object &object, const float value, const IndexMask &node_mask)
void push_nodes(const Depsgraph &depsgraph, Object &object, const IndexMask &node_mask, const Type type)
void push_node(const Depsgraph &depsgraph, const Object &object, const bke::pbvh::Node *node, const Type type)
void push_begin(const Scene &scene, Object &ob, const wmOperator *op)
void gather_data_grids(const SubdivCCG &subdiv_ccg, Span< T > src, Span< int > grids, MutableSpan< T > node_data)
Definition sculpt.cc:6528
void vert_random_access_ensure(Object &object)
Definition sculpt.cc:154
Vector< BMVert *, 64 > BMeshNeighborVerts
bool sculpt_mode_poll(bContext *C)
Definition sculpt.cc:3800
void scatter_data_mesh(Span< T > src, Span< int > indices, MutableSpan< T > dst)
bool sculpt_mode_poll_view3d(bContext *C)
Definition sculpt.cc:3806
Span< BMVert * > vert_neighbors_get_bmesh(BMVert &vert, BMeshNeighborVerts &r_neighbors)
Definition sculpt.cc:490
void gather_data_mesh(Span< T > src, Span< int > indices, MutableSpan< T > dst)
void mask_overlay_check(bContext &C, wmOperator &op)
Definition sculpt.cc:8298
void scatter_data_grids(const SubdivCCG &subdiv_ccg, Span< T > node_data, Span< int > grids, MutableSpan< T > dst)
Definition sculpt.cc:6560
void tag_update_overlays(bContext *C)
Definition sculpt.cc:895
constexpr ParallelGrainSize grain_size(int grain_size)
Value parallel_reduce(IndexRange range, int64_t grain_size, const Value &identity, const Function &function, const Reduction &reduction)
Definition BLI_task.hh:127
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
int RNA_enum_get(PointerRNA *ptr, const char *name)
wmOperatorStatus WM_gesture_polyline_invoke(bContext *C, wmOperator *op, const wmEvent *event)
void multires_mark_as_modified(Depsgraph *depsgraph, Object *object, MultiresModifiedFlags flags)
Definition multires.cc:254
void ED_view3d_clipping_local(RegionView3D *rv3d, const float mat[4][4])
wmOperatorStatus WM_gesture_box_invoke(bContext *C, wmOperator *op, const wmEvent *event)
MultiresModifierData * BKE_sculpt_multires_active(const Scene *scene, Object *ob)
Depsgraph * CTX_data_depsgraph_pointer(const bContext *C)
PropertyRNA * RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items, const int default_value, const char *ui_name, const char *ui_description)
void WM_operator_properties_border(wmOperatorType *ot)
wmOperatorStatus WM_gesture_straightline_active_side_invoke(bContext *C, wmOperator *op, const wmEvent *event)
wmOperatorStatus WM_gesture_lasso_modal(bContext *C, wmOperator *op, const wmEvent *event)
void BKE_pbvh_node_fully_masked_set(bke::pbvh::Node &node, int fully_masked)
Definition pbvh.cc:1630
void BKE_sculpt_mask_layers_ensure(Depsgraph *depsgraph, Main *bmain, Object *ob, MultiresModifierData *mmd)
CCGKey BKE_subdiv_ccg_key_top_level(const SubdivCCG &subdiv_ccg)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
BMesh const char void * data
@ MULTIRES_COORDS_MODIFIED
void BKE_pbvh_node_fully_unmasked_set(bke::pbvh::Node &node, int fully_masked)
Definition pbvh.cc:1647
Depsgraph * CTX_data_ensure_evaluated_depsgraph(const bContext *C, bool rna_write_check=false)
int CustomData_get_offset_named(const CustomData *data, eCustomDataType type, StringRef name)
void WM_operator_properties_gesture_straightline(wmOperatorType *ot, int cursor)
BLI_INLINE BMVert * BM_vert_at_index(BMesh *bm, const int index)
wmOperatorStatus WM_gesture_polyline_modal(bContext *C, wmOperator *op, const wmEvent *event)
wmOperatorStatus WM_gesture_box_modal(bContext *C, wmOperator *op, const wmEvent *event)
bool ED_view3d_clipping_test(const RegionView3D *rv3d, const float co[3], bool is_local)
@ WM_CURSOR_EDIT
Definition wm_cursors.hh:21
Main * CTX_data_main(const bContext *C)
wmOperatorStatus WM_gesture_lasso_invoke(bContext *C, wmOperator *op, const wmEvent *event)
bool BKE_pbvh_node_fully_hidden_get(const bke::pbvh::Node &node)
Definition pbvh.cc:1625
void BKE_sculptsession_update_for_edit(Depsgraph *depsgraph, Object *ob_orig, bool is_paint_tool)
void BKE_subdiv_ccg_foreach_visible_grid_vert(const CCGKey &key, const BitGroupVector<> &grid_hidden, const int grid, const Fn &fn)
Scene * CTX_data_scene(const bContext *C)
wmOperatorStatus WM_gesture_straightline_oneshot_modal(bContext *C, wmOperator *op, const wmEvent *event)
@ OPTYPE_REGISTER
Definition WM_types.hh:188
@ OPTYPE_DEPENDS_ON_CURSOR
Definition WM_types.hh:228
void WM_operator_properties_gesture_polyline(wmOperatorType *ot)
PropertyRNA * RNA_def_float(StructOrFunctionRNA *cont_, const char *identifier, const float default_value, const float hardmin, const float hardmax, const char *ui_name, const char *ui_description, const float softmin, const float softmax)
Object * CTX_data_active_object(const bContext *C)
const Set< BMVert *, 0 > & BKE_pbvh_bmesh_node_unique_verts(bke::pbvh::BMeshNode *node)
float RNA_float_get(PointerRNA *ptr, const char *name)
void WM_operator_properties_gesture_lasso(wmOperatorType *ot)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
CustomData vdata
Array< float3 > positions
Array< float > masks
RegionView3D * rv3d
Definition ED_view3d.hh:86
Depsgraph * depsgraph
Definition ED_view3d.hh:78
void(*) end(bContext &, GestureData &)
void(*) apply_for_symmetry_pass(bContext &, GestureData &)
void(*) begin(bContext &, wmOperator &, GestureData &)
wmOperatorStatus(*) exec(bContext *C, wmOperator *op) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1125
const char * description
Definition WM_types.hh:1115
bool(*) poll(bContext *C) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1165
wmOperatorStatus(*) invoke(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1141
wmOperatorStatus(*) modal(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1157
void resize(int new_size)
Definition vector.hh:94