Blender V5.3
modifiers/intern/MOD_mask.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2005 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "BLI_utildefines.hh"
10
11#include "BLI_array_utils.hh"
12#include "BLI_listbase.hh"
13
14#include "BLT_translation.hh"
15
16#include "DNA_armature_types.h"
17#include "DNA_mesh_types.h"
18#include "DNA_meshdata_types.h"
19#include "DNA_modifier_types.h"
20#include "DNA_object_types.h"
21#include "DNA_screen_types.h"
22
23#include "BKE_action.hh" /* BKE_pose_channel_find_name */
25#include "BKE_customdata.hh"
26#include "BKE_deform.hh"
27#include "BKE_lib_query.hh"
28#include "BKE_mesh.hh"
29#include "BKE_modifier.hh"
30
32#include "UI_resources.hh"
33
34#include "RNA_access.hh"
35#include "RNA_prototypes.hh"
36
38
39#include "MOD_ui_common.hh"
40
41#include "BLI_array.hh"
43#include "BLI_vector.hh"
44
45namespace blender {
46
47static void init_data(ModifierData *md)
48{
49 MaskModifierData *mmd = reinterpret_cast<MaskModifierData *>(md);
51}
52
53static void required_data_mask(ModifierData * /*md*/, CustomData_MeshMasks *r_cddata_masks)
54{
55 r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
56}
57
58static void foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data)
59{
60 MaskModifierData *mmd = reinterpret_cast<MaskModifierData *>(md);
61 walk(user_data, ob, reinterpret_cast<ID **>(&mmd->ob_arm), IDWALK_CB_NOP);
62}
63
65{
66 MaskModifierData *mmd = reinterpret_cast<MaskModifierData *>(md);
67 if (mmd->ob_arm) {
68 bArmature *arm = id_cast<bArmature *>(mmd->ob_arm->data);
69 /* Tag relationship in depsgraph, but also on the armature. */
70 /* TODO(sergey): Is it a proper relation here? */
71 DEG_add_object_relation(ctx->node, mmd->ob_arm, DEG_OB_COMP_TRANSFORM, "Mask Modifier");
72 arm->flag |= ARM_HAS_VIZ_DEPS;
73 DEG_add_depends_on_transform_relation(ctx->node, "Mask Modifier");
74 }
75}
76
77/* A vertex will be in the mask if a selected bone influences it more than a certain threshold. */
79 Mesh *mesh,
80 Object *armature_ob,
81 float threshold,
82 MutableSpan<bool> r_vertex_mask)
83{
84 /* Element i is true if there is a selected bone that uses vertex group i. */
85 Vector<bool> selected_bone_uses_group;
86
87 for (bDeformGroup &def : mesh->vertex_group_names) {
88 bPoseChannel *pchan = BKE_pose_channel_find_name(armature_ob->pose, def.name);
89 const bool bone_for_group_exists = pchan && pchan->bone_get(*armature_ob) &&
90 (pchan->flag & POSE_SELECTED);
91 selected_bone_uses_group.append(bone_for_group_exists);
92 }
93 const int64_t total_size = selected_bone_uses_group.size();
94
95 for (int i : r_vertex_mask.index_range()) {
96 Span<MDeformWeight> weights(dvert[i].dw, dvert[i].totweight);
97 r_vertex_mask[i] = false;
98
99 /* check the groups that vertex is assigned to, and see if it was any use */
100 for (const MDeformWeight &dw : weights) {
101 if (dw.def_nr >= total_size) {
102 continue;
103 }
104 if (selected_bone_uses_group[dw.def_nr]) {
105 if (dw.weight > threshold) {
106 r_vertex_mask[i] = true;
107 break;
108 }
109 }
110 }
111 }
112}
113
114/* A vertex will be in the mask if the vertex group influences it more than a certain threshold. */
116 int defgrp_index,
117 float threshold,
118 MutableSpan<bool> r_vertex_mask)
119{
120 for (int i : r_vertex_mask.index_range()) {
121 const bool found = BKE_defvert_find_weight(&dvert[i], defgrp_index) > threshold;
122 r_vertex_mask[i] = found;
123 }
124}
125
126static void compute_masked_verts(Span<bool> vertex_mask,
127 MutableSpan<int> r_vertex_map,
128 uint *r_verts_masked_num)
129{
130 BLI_assert(vertex_mask.size() == r_vertex_map.size());
131
132 uint verts_masked_num = 0;
133 for (uint i_src : r_vertex_map.index_range()) {
134 if (vertex_mask[i_src]) {
135 r_vertex_map[i_src] = verts_masked_num;
136 verts_masked_num++;
137 }
138 else {
139 r_vertex_map[i_src] = -1;
140 }
141 }
142
143 *r_verts_masked_num = verts_masked_num;
144}
145
146static void computed_masked_edges(const Mesh *mesh,
147 Span<bool> vertex_mask,
148 MutableSpan<int> r_edge_map,
149 uint *r_edges_masked_num)
150{
151 BLI_assert(mesh->edges_num == r_edge_map.size());
152 const Span<int2> edges = mesh->edges();
153
154 uint edges_masked_num = 0;
155 for (int i : IndexRange(mesh->edges_num)) {
156 const int2 &edge = edges[i];
157
158 /* only add if both verts will be in new mesh */
159 if (vertex_mask[edge[0]] && vertex_mask[edge[1]]) {
160 r_edge_map[i] = edges_masked_num;
161 edges_masked_num++;
162 }
163 else {
164 r_edge_map[i] = -1;
165 }
166 }
167
168 *r_edges_masked_num = edges_masked_num;
169}
170
172 Span<bool> vertex_mask,
173 MutableSpan<int> r_edge_map,
174 uint *r_edges_masked_num,
175 uint *r_verts_add_num)
176{
177 BLI_assert(mesh->edges_num == r_edge_map.size());
178 const Span<int2> edges = mesh->edges();
179
180 uint edges_masked_num = 0;
181 uint verts_add_num = 0;
182 for (int i : IndexRange(mesh->edges_num)) {
183 const int2 &edge = edges[i];
184
185 /* only add if both verts will be in new mesh */
186 bool v1 = vertex_mask[edge[0]];
187 bool v2 = vertex_mask[edge[1]];
188 if (v1 && v2) {
189 r_edge_map[i] = edges_masked_num;
190 edges_masked_num++;
191 }
192 else if (v1 != v2) {
193 r_edge_map[i] = -2;
194 verts_add_num++;
195 }
196 else {
197 r_edge_map[i] = -1;
198 }
199 }
200
201 edges_masked_num += verts_add_num;
202 *r_edges_masked_num = edges_masked_num;
203 *r_verts_add_num = verts_add_num;
204}
205
206static void computed_masked_faces(const Mesh *mesh,
207 Span<bool> vertex_mask,
208 Vector<int> &r_masked_face_indices,
209 Vector<int> &r_loop_starts,
210 uint *r_faces_masked_num,
211 uint *r_loops_masked_num)
212{
213 BLI_assert(mesh->verts_num == vertex_mask.size());
214 const OffsetIndices faces = mesh->faces();
215 const Span<int> corner_verts = mesh->corner_verts();
216
217 r_masked_face_indices.reserve(mesh->faces_num);
218 r_loop_starts.reserve(mesh->faces_num);
219
220 uint loops_masked_num = 0;
221 for (int i : IndexRange(mesh->faces_num)) {
222 const IndexRange face = faces[i];
223
224 bool all_verts_in_mask = true;
225 for (const int vert_i : corner_verts.slice(face)) {
226 if (!vertex_mask[vert_i]) {
227 all_verts_in_mask = false;
228 break;
229 }
230 }
231
232 if (all_verts_in_mask) {
233 r_masked_face_indices.append_unchecked(i);
234 r_loop_starts.append_unchecked(loops_masked_num);
235 loops_masked_num += face.size();
236 }
237 }
238
239 *r_faces_masked_num = r_masked_face_indices.size();
240 *r_loops_masked_num = loops_masked_num;
241}
242
244 Span<bool> vertex_mask,
245 uint verts_add_num,
246 uint loops_masked_num,
247 Vector<int> &r_masked_face_indices,
248 Vector<int> &r_loop_starts,
249 uint *r_edges_add_num,
250 uint *r_faces_add_num,
251 uint *r_loops_add_num)
252{
253 BLI_assert(mesh->verts_num == vertex_mask.size());
254
255 /* Can't really know ahead of time how much space to use exactly. Estimate limit instead. */
256 /* NOTE: this reserve can only lift the capacity if there are ngons, which get split. */
257 r_masked_face_indices.reserve(r_masked_face_indices.size() + verts_add_num);
258 r_loop_starts.reserve(r_loop_starts.size() + verts_add_num);
259 const OffsetIndices faces = mesh->faces();
260 const Span<int> corner_verts = mesh->corner_verts();
261
262 uint edges_add_num = 0;
263 uint faces_add_num = 0;
264 uint loops_add_num = 0;
265 for (int i : IndexRange(mesh->faces_num)) {
266 const IndexRange face_src = faces[i];
267
268 int in_count = 0;
269 int start = -1;
270 int dst_totloop = -1;
271 const Span<int> face_verts_src = corner_verts.slice(face_src);
272 for (const int j : face_verts_src.index_range()) {
273 const int vert_i = face_verts_src[j];
274 if (vertex_mask[vert_i]) {
275 in_count++;
276 }
277 else if (start == -1) {
278 start = j;
279 }
280 }
281 if (0 < in_count && in_count < face_src.size()) {
282 /* Ring search starting at a vertex which is not included in the mask. */
283 int last_corner_vert = face_verts_src[start];
284 bool v_loop_in_mask_last = vertex_mask[last_corner_vert];
285 for (const int j : face_verts_src.index_range()) {
286 const int corner_vert = face_verts_src[(start + 1 + j) % face_src.size()];
287 const bool v_loop_in_mask = vertex_mask[corner_vert];
288 if (v_loop_in_mask && !v_loop_in_mask_last) {
289 dst_totloop = 3;
290 }
291 else if (!v_loop_in_mask && v_loop_in_mask_last) {
292 BLI_assert(dst_totloop > 2);
293 r_masked_face_indices.append(i);
294 r_loop_starts.append(loops_masked_num + loops_add_num);
295 loops_add_num += dst_totloop;
296 faces_add_num++;
297 edges_add_num++;
298 dst_totloop = -1;
299 }
300 else if (v_loop_in_mask && v_loop_in_mask_last) {
301 BLI_assert(dst_totloop > 2);
302 dst_totloop++;
303 }
304 last_corner_vert = corner_vert;
305 v_loop_in_mask_last = v_loop_in_mask;
306 }
307 }
308 }
309
310 *r_edges_add_num = edges_add_num;
311 *r_faces_add_num = faces_add_num;
312 *r_loops_add_num = loops_add_num;
313}
314
315static void copy_masked_verts_to_new_mesh(const Mesh &src_mesh,
316 Mesh &dst_mesh,
317 Span<int> vertex_map)
318{
319 bke::LegacyMeshInterpolator vert_interp(src_mesh, dst_mesh, bke::AttrDomain::Point);
320 BLI_assert(src_mesh.verts_num == vertex_map.size());
321 for (const int i_src : vertex_map.index_range()) {
322 const int i_dst = vertex_map[i_src];
323 if (i_dst == -1) {
324 continue;
325 }
326
327 vert_interp.copy(i_src, i_dst, 1);
328 }
329}
330
332 const MDeformVert *dvert, int defgrp_index, float threshold, uint v1, uint v2)
333{
334 /* NOTE: this calculation is done twice for every vertex,
335 * instead of storing it the first time and then reusing it. */
336 float value1 = BKE_defvert_find_weight(&dvert[v1], defgrp_index);
337 float value2 = BKE_defvert_find_weight(&dvert[v2], defgrp_index);
338 return (threshold - value1) / (value2 - value1);
339}
340
342 Mesh &dst_mesh,
343 Span<bool> vertex_mask,
344 Span<int> vertex_map,
345 const MDeformVert *dvert,
346 int defgrp_index,
347 float threshold,
348 uint edges_masked_num,
349 uint verts_add_num,
350 MutableSpan<int> r_edge_map)
351{
352 BLI_assert(src_mesh.verts_num == vertex_mask.size());
353 BLI_assert(src_mesh.edges_num == r_edge_map.size());
354 const Span<int2> src_edges = src_mesh.edges();
355 MutableSpan<int2> dst_edges = dst_mesh.edges_for_write();
356
357 bke::LegacyMeshInterpolator vert_interp(src_mesh, dst_mesh, bke::AttrDomain::Point);
358 bke::LegacyMeshInterpolator edge_interp(src_mesh, dst_mesh, bke::AttrDomain::Edge);
359
360 uint vert_index = dst_mesh.verts_num - verts_add_num;
361 uint edge_index = edges_masked_num - verts_add_num;
362 for (int i_src : IndexRange(src_mesh.edges_num)) {
363 if (r_edge_map[i_src] != -1) {
364 int i_dst = r_edge_map[i_src];
365 if (i_dst == -2) {
366 i_dst = edge_index;
367 }
368 const int2 &e_src = src_edges[i_src];
369 int2 &e_dst = dst_edges[i_dst];
370
371 edge_interp.copy(i_src, i_dst, 1);
372 e_dst = e_src;
373 e_dst[0] = vertex_map[e_src[0]];
374 e_dst[1] = vertex_map[e_src[1]];
375 }
376 if (r_edge_map[i_src] == -2) {
377 const int i_dst = edge_index++;
378 r_edge_map[i_src] = i_dst;
379 const int2 &e_src = src_edges[i_src];
380 /* Cut destination edge and make v1 the new vertex. */
381 int2 &e_dst = dst_edges[i_dst];
382 if (!vertex_mask[e_src[0]]) {
383 e_dst[0] = vert_index;
384 }
385 else {
386 BLI_assert(!vertex_mask[e_src[1]]);
387 e_dst[1] = e_dst[0];
388 e_dst[0] = vert_index;
389 }
390 /* Create the new vertex. */
392 dvert, defgrp_index, threshold, e_src[0], e_src[1]);
393
394 vert_interp.mix({e_src[0], e_src[1]}, Span{1.0f - fac, fac}, vert_index);
395 vert_index++;
396 }
397 }
398 BLI_assert(vert_index == dst_mesh.verts_num);
399 BLI_assert(edge_index == edges_masked_num);
400}
401
402static void copy_masked_edges_to_new_mesh(const Mesh &src_mesh,
403 Mesh &dst_mesh,
404 Span<int> vertex_map,
405 Span<int> edge_map)
406{
407 const Span<int2> src_edges = src_mesh.edges();
408 MutableSpan<int2> dst_edges = dst_mesh.edges_for_write();
409 bke::LegacyMeshInterpolator edge_interp(src_mesh, dst_mesh, bke::AttrDomain::Edge);
410
411 BLI_assert(src_mesh.verts_num == vertex_map.size());
412 BLI_assert(src_mesh.edges_num == edge_map.size());
413 for (const int i_src : IndexRange(src_mesh.edges_num)) {
414 const int i_dst = edge_map[i_src];
415 if (ELEM(i_dst, -1, -2)) {
416 continue;
417 }
418
419 edge_interp.copy(i_src, i_dst, 1);
420 dst_edges[i_dst][0] = vertex_map[src_edges[i_src][0]];
421 dst_edges[i_dst][1] = vertex_map[src_edges[i_src][1]];
422 }
423}
424
425static void copy_masked_faces_to_new_mesh(const Mesh &src_mesh,
426 Mesh &dst_mesh,
427 Span<int> vertex_map,
428 Span<int> edge_map,
429 Span<int> masked_face_indices,
430 Span<int> new_loop_starts,
431 int faces_masked_num)
432{
433 const OffsetIndices src_faces = src_mesh.faces();
434 MutableSpan<int> dst_face_offsets = dst_mesh.face_offsets_for_write();
435 const Span<int> src_corner_verts = src_mesh.corner_verts();
436 const Span<int> src_corner_edges = src_mesh.corner_edges();
437 MutableSpan<int> dst_corner_verts = dst_mesh.corner_verts_for_write();
438 MutableSpan<int> dst_corner_edges = dst_mesh.corner_edges_for_write();
439
440 bke::LegacyMeshInterpolator face_interp(src_mesh, dst_mesh, bke::AttrDomain::Face);
441 bke::LegacyMeshInterpolator corner_interp(src_mesh, dst_mesh, bke::AttrDomain::Corner);
442
443 for (const int i_dst : IndexRange(faces_masked_num)) {
444 const int i_src = masked_face_indices[i_dst];
445 const IndexRange src_face = src_faces[i_src];
446
447 dst_face_offsets[i_dst] = new_loop_starts[i_dst];
448
449 face_interp.copy(i_src, i_dst, 1);
450 corner_interp.copy(src_face.start(), dst_face_offsets[i_dst], src_face.size());
451
452 for (int i : IndexRange(src_face.size())) {
453 dst_corner_verts[new_loop_starts[i_dst] + i] = vertex_map[src_corner_verts[src_face[i]]];
454 dst_corner_edges[new_loop_starts[i_dst] + i] = edge_map[src_corner_edges[src_face[i]]];
455 }
456 }
457}
458
459static void add_interpolated_faces_to_new_mesh(const Mesh &src_mesh,
460 Mesh &dst_mesh,
461 Span<bool> vertex_mask,
462 Span<int> vertex_map,
463 Span<int> edge_map,
464 const MDeformVert *dvert,
465 int defgrp_index,
466 float threshold,
467 Span<int> masked_face_indices,
468 Span<int> new_loop_starts,
469 int faces_masked_num,
470 int edges_add_num)
471{
472 const OffsetIndices src_faces = src_mesh.faces();
473 MutableSpan<int> dst_face_offsets = dst_mesh.face_offsets_for_write();
474 MutableSpan<int2> dst_edges = dst_mesh.edges_for_write();
475 const Span<int> src_corner_verts = src_mesh.corner_verts();
476 const Span<int> src_corner_edges = src_mesh.corner_edges();
477 MutableSpan<int> dst_corner_verts = dst_mesh.corner_verts_for_write();
478 MutableSpan<int> dst_corner_edges = dst_mesh.corner_edges_for_write();
479
480 bke::LegacyMeshInterpolator face_interp(src_mesh, dst_mesh, bke::AttrDomain::Face);
481 bke::LegacyMeshInterpolator corner_interp(src_mesh, dst_mesh, bke::AttrDomain::Corner);
482
483 int edge_index = dst_mesh.edges_num - edges_add_num;
484 int sub_face_index = 0;
485 int last_i_src = -1;
486 for (const int i_dst :
487 IndexRange(faces_masked_num, masked_face_indices.size() - faces_masked_num))
488 {
489 const int i_src = masked_face_indices[i_dst];
490 if (i_src == last_i_src) {
491 sub_face_index++;
492 }
493 else {
494 sub_face_index = 0;
495 last_i_src = i_src;
496 }
497
498 const IndexRange src_face = src_faces[i_src];
499 const int i_ml_src = src_face.start();
500 int i_ml_dst = new_loop_starts[i_dst];
501 face_interp.copy(i_src, i_dst, 1);
502
503 dst_face_offsets[i_dst] = i_ml_dst;
504
505 /* Ring search starting at a vertex which is not included in the mask. */
506 int start = -sub_face_index - 1;
507 bool skip = false;
508 const Span<int> face_verts_src = src_corner_verts.slice(src_face);
509 const Span<int> face_edges_src = src_corner_edges.slice(src_face);
510 for (const int j : face_verts_src.index_range()) {
511 if (!vertex_mask[face_verts_src[j]]) {
512 if (start == -1) {
513 start = j;
514 break;
515 }
516 if (!skip) {
517 skip = true;
518 }
519 }
520 else if (skip) {
521 skip = false;
522 start++;
523 }
524 }
525
526 BLI_assert(start >= 0);
527 BLI_assert(edge_index < dst_mesh.edges_num);
528
529 int last_index = start;
530 bool v_loop_in_mask_last = vertex_mask[face_verts_src[last_index]];
531 for (const int j : face_verts_src.index_range()) {
532 const int index = (start + 1 + j) % src_face.size();
533 const bool v_loop_in_mask = vertex_mask[face_verts_src[index]];
534 if (v_loop_in_mask && !v_loop_in_mask_last) {
535 /* Start new cut. */
537 dvert, defgrp_index, threshold, face_verts_src[last_index], face_verts_src[index]);
538 corner_interp.mix(
539 {i_ml_src + last_index, i_ml_src + index}, Span{1.0f - fac, fac}, i_ml_dst);
540 dst_corner_edges[i_ml_dst] = edge_map[face_edges_src[last_index]];
541 dst_corner_verts[i_ml_dst] = dst_edges[dst_corner_edges[i_ml_dst]][0];
542 i_ml_dst++;
543
544 corner_interp.copy(i_ml_src + index, i_ml_dst, 1);
545 dst_corner_verts[i_ml_dst] = vertex_map[face_verts_src[index]];
546 dst_corner_edges[i_ml_dst] = edge_map[face_edges_src[index]];
547 i_ml_dst++;
548 }
549 else if (!v_loop_in_mask && v_loop_in_mask_last) {
550 BLI_assert(i_ml_dst != dst_face_offsets[i_dst]);
551 /* End active cut. */
553 dvert, defgrp_index, threshold, face_verts_src[last_index], face_verts_src[index]);
554 corner_interp.mix(
555 {i_ml_src + last_index, i_ml_src + index}, Span{1.0f - fac, fac}, i_ml_dst);
556 dst_corner_edges[i_ml_dst] = edge_index;
557 dst_corner_verts[i_ml_dst] = dst_edges[edge_map[face_edges_src[last_index]]][0];
558
559 /* Create closing edge. */
560 int2 &cut_edge = dst_edges[edge_index];
561 cut_edge[0] = dst_corner_verts[dst_face_offsets[i_dst]];
562 cut_edge[1] = dst_corner_verts[i_ml_dst];
563 BLI_assert(cut_edge[0] != cut_edge[1]);
564 edge_index++;
565 i_ml_dst++;
566
567 /* Only handle one of the cuts per iteration. */
568 break;
569 }
570 else if (v_loop_in_mask && v_loop_in_mask_last) {
571 BLI_assert(i_ml_dst != dst_face_offsets[i_dst]);
572 /* Extend active face. */
573 corner_interp.copy(i_ml_src + index, i_ml_dst, 1);
574 dst_corner_verts[i_ml_dst] = vertex_map[face_verts_src[index]];
575 dst_corner_edges[i_ml_dst] = edge_map[face_edges_src[index]];
576 i_ml_dst++;
577 }
578 last_index = index;
579 v_loop_in_mask_last = v_loop_in_mask;
580 }
581 }
582 BLI_assert(edge_index == dst_mesh.edges_num);
583}
584
585/* Components of the algorithm:
586 * 1. Figure out which vertices should be present in the output mesh.
587 * 2. Find edges and faces only using those vertices.
588 * 3. Create a new mesh that only uses the found vertices, edges and faces.
589 */
591{
592 MaskModifierData *mmd = reinterpret_cast<MaskModifierData *>(md);
593 const bool invert_mask = mmd->flag & MOD_MASK_INV;
594 const bool use_interpolation = mmd->mode == MOD_MASK_MODE_VGROUP &&
595 (mmd->flag & MOD_MASK_SMOOTH);
596
597 /* Return empty or input mesh when there are no vertex groups. */
598 const Span<MDeformVert> dverts = mesh->deform_verts();
599 if (dverts.is_empty()) {
600 return invert_mask ? mesh : BKE_mesh_new_nomain_from_template(mesh, 0, 0, 0, 0);
601 }
602
603 /* Quick test to see if we can return early. */
604 if (!ELEM(mmd->mode, MOD_MASK_MODE_ARM, MOD_MASK_MODE_VGROUP) || (mesh->verts_num == 0) ||
605 mesh->vertex_group_names.is_empty())
606 {
607 return mesh;
608 }
609
610 int defgrp_index = -1;
611
612 Array<bool> vertex_mask;
613 if (mmd->mode == MOD_MASK_MODE_ARM) {
614 Object *armature_ob = mmd->ob_arm;
615
616 /* Return input mesh if there is no armature with bones. */
617 if (ELEM(nullptr, armature_ob, armature_ob->pose)) {
618 return mesh;
619 }
620
621 vertex_mask = Array<bool>(mesh->verts_num);
623 dverts.data(), mesh, armature_ob, mmd->threshold, vertex_mask);
624 }
625 else {
627 defgrp_index = BKE_id_defgroup_name_index(&mesh->id, mmd->vgroup);
628
629 /* Return input mesh if the vertex group does not exist. */
630 if (defgrp_index == -1) {
631 return mesh;
632 }
633
634 vertex_mask = Array<bool>(mesh->verts_num);
636 dverts.data(), defgrp_index, mmd->threshold, vertex_mask);
637 }
638
639 if (invert_mask) {
640 array_utils::invert_booleans(vertex_mask);
641 }
642
643 Array<int> vertex_map(mesh->verts_num);
644 uint verts_masked_num;
645 compute_masked_verts(vertex_mask, vertex_map, &verts_masked_num);
646
647 Array<int> edge_map(mesh->edges_num);
648 uint edges_masked_num;
649 uint verts_add_num;
650 if (use_interpolation) {
651 computed_masked_edges_smooth(mesh, vertex_mask, edge_map, &edges_masked_num, &verts_add_num);
652 }
653 else {
654 computed_masked_edges(mesh, vertex_mask, edge_map, &edges_masked_num);
655 verts_add_num = 0;
656 }
657
658 Vector<int> masked_face_indices;
659 Vector<int> new_loop_starts;
660 uint faces_masked_num;
661 uint loops_masked_num;
663 vertex_mask,
664 masked_face_indices,
665 new_loop_starts,
666 &faces_masked_num,
667 &loops_masked_num);
668
669 uint edges_add_num = 0;
670 uint faces_add_num = 0;
671 uint loops_add_num = 0;
672 if (use_interpolation) {
674 vertex_mask,
675 verts_add_num,
676 loops_masked_num,
677 masked_face_indices,
678 new_loop_starts,
679 &edges_add_num,
680 &faces_add_num,
681 &loops_add_num);
682 }
683
685 verts_masked_num + verts_add_num,
686 edges_masked_num + edges_add_num,
687 faces_masked_num + faces_add_num,
688 loops_masked_num + loops_add_num);
689
691 if (use_interpolation) {
693 *result,
694 vertex_mask,
695 vertex_map,
696 dverts.data(),
697 defgrp_index,
698 mmd->threshold,
699 edges_masked_num,
700 verts_add_num,
701 edge_map);
702 }
703 else {
704 copy_masked_edges_to_new_mesh(*mesh, *result, vertex_map, edge_map);
705 }
707 *result,
708 vertex_map,
709 edge_map,
710 masked_face_indices,
711 new_loop_starts,
712 faces_masked_num);
713 if (use_interpolation) {
715 *result,
716 vertex_mask,
717 vertex_map,
718 edge_map,
719 dverts.data(),
720 defgrp_index,
721 mmd->threshold,
722 masked_face_indices,
723 new_loop_starts,
724 faces_masked_num,
725 edges_add_num);
726 }
727
728 return result;
729}
730
731static bool is_disabled(const Scene * /*scene*/, ModifierData *md, bool /*use_render_params*/)
732{
733 MaskModifierData *mmd = reinterpret_cast<MaskModifierData *>(md);
734
735 /* The object type check is only needed here in case we have a placeholder
736 * object assigned (because the library containing the armature is missing).
737 *
738 * In other cases it should be impossible to have a type mismatch.
739 */
740 return mmd->ob_arm && mmd->ob_arm->type != OB_ARMATURE;
741}
742
743static void panel_draw(const bContext * /*C*/, Panel *panel)
744{
745 ui::Layout &layout = *panel->layout;
746
747 PointerRNA ob_ptr;
749
750 int mode = RNA_enum_get(ptr, "mode");
751
752 layout.prop(ptr, "mode", ui::ITEM_R_EXPAND, std::nullopt, ICON_NONE);
753
754 layout.use_property_split_set(true);
755
756 if (mode == MOD_MASK_MODE_ARM) {
757 ui::Layout &row = layout.row(true);
758 row.prop(ptr, "armature", UI_ITEM_NONE, std::nullopt, ICON_NONE);
759 ui::Layout &sub = row.row(true);
760 sub.use_property_decorate_set(false);
761 sub.prop(ptr, "invert_vertex_group", UI_ITEM_NONE, "", ICON_ARROW_LEFTRIGHT);
762 }
763 else if (mode == MOD_MASK_MODE_VGROUP) {
764 modifier_vgroup_ui(layout, ptr, &ob_ptr, "vertex_group", "invert_vertex_group", std::nullopt);
765 layout.prop(ptr, "use_smooth", UI_ITEM_NONE, std::nullopt, ICON_NONE);
766 }
767
768 layout.prop(ptr, "threshold", UI_ITEM_NONE, std::nullopt, ICON_NONE);
769
770 modifier_error_message_draw(layout, ptr);
771}
772
773static void panel_register(ARegionType *region_type)
774{
776}
777
779 /*idname*/ "Mask",
780 /*name*/ N_("Mask"),
781 /*struct_name*/ "MaskModifierData",
782 /*struct_size*/ sizeof(MaskModifierData),
783 /*srna*/ &RNA_MaskModifier,
785 /*flags*/
788 /*icon*/ ICON_MOD_MASK,
789
790 /*copy_data*/ BKE_modifier_copydata_generic,
791
792 /*deform_verts*/ nullptr,
793 /*deform_matrices*/ nullptr,
794 /*deform_verts_EM*/ nullptr,
795 /*deform_matrices_EM*/ nullptr,
796 /*modify_mesh*/ modify_mesh,
797 /*modify_geometry_set*/ nullptr,
798
799 /*init_data*/ init_data,
800 /*required_data_mask*/ required_data_mask,
801 /*free_data*/ nullptr,
802 /*is_disabled*/ is_disabled,
803 /*update_depsgraph*/ update_depsgraph,
804 /*depends_on_time*/ nullptr,
805 /*depends_on_normals*/ nullptr,
806 /*foreach_ID_link*/ foreach_ID_link,
807 /*foreach_tex_link*/ nullptr,
808 /*free_runtime_data*/ nullptr,
809 /*panel_register*/ panel_register,
810 /*blend_write*/ nullptr,
811 /*blend_read*/ nullptr,
812 /*foreach_cache*/ nullptr,
813 /*foreach_working_space_color*/ nullptr,
814};
815
816} // namespace blender
Blender kernel action and pose functionality.
CustomData interface, see also DNA_customdata_types.h.
support for deformation groups and hooks.
Object is a sort of wrapper for general info.
#define UI_ITEM_NONE
#define INIT_DEFAULT_STRUCT_AFTER(struct_dst, member)
#define ELEM(...)
#define CD_MASK_MDEFORMVERT
const T * data() const
Definition BLI_array.hh:323
constexpr int64_t size() const
constexpr IndexRange()=default
constexpr int64_t start() const
constexpr int64_t size() const
Definition BLI_span.hh:499
constexpr IndexRange index_range() const
Definition BLI_span.hh:676
constexpr Span slice(int64_t start, int64_t size) const
Definition BLI_span.hh:141
constexpr int64_t size() const
Definition BLI_span.hh:256
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
int64_t size() const
void append(const T &value)
void append_unchecked(const T &value)
void reserve(const int64_t min_capacity)
void copy(int src_index, int dst_index, int count) const
void mix(Span< int > src_indices, std::optional< Span< float > > weights, int dst_index) const
void invert_booleans(MutableSpan< bool > span)
BMesh Iterators.
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
static void compute_interpolated_faces(const Mesh *mesh, Span< bool > vertex_mask, uint verts_add_num, uint loops_masked_num, Vector< int > &r_masked_face_indices, Vector< int > &r_loop_starts, uint *r_edges_add_num, uint *r_faces_add_num, uint *r_loops_add_num)
__int64 int64_t
Definition BKE_text.h:90
int RNA_enum_get(PointerRNA *ptr, const char *name)
static void copy_masked_edges_to_new_mesh(const Mesh &src_mesh, Mesh &dst_mesh, Span< int > vertex_map, Span< int > edge_map)
PointerRNA * modifier_panel_get_property_pointers(Panel *panel, PointerRNA *r_ob_ptr)
unsigned int uint
Definition BKE_text.h:55
static void copy_masked_faces_to_new_mesh(const Mesh &src_mesh, Mesh &dst_mesh, Span< int > vertex_map, Span< int > edge_map, Span< int > masked_face_indices, Span< int > new_loop_starts, int faces_masked_num)
static void init_data(ModifierData *md)
void(*)(void *user_data, Object *ob, ID **idpoin, LibraryForeachIDCallbackFlag cb_flag) IDWalkFunc
static void update_depsgraph(tGraphSliderOp *gso)
static void add_interp_verts_copy_edges_to_new_mesh(const Mesh &src_mesh, Mesh &dst_mesh, Span< bool > vertex_mask, Span< int > vertex_map, const MDeformVert *dvert, int defgrp_index, float threshold, uint edges_masked_num, uint verts_add_num, MutableSpan< int > r_edge_map)
static void foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data)
void DEG_add_object_relation(DepsNodeHandle *node_handle, Object *object, eDepsObjectComponentType component, const char *description)
static void add_interpolated_faces_to_new_mesh(const Mesh &src_mesh, Mesh &dst_mesh, Span< bool > vertex_mask, Span< int > vertex_map, Span< int > edge_map, const MDeformVert *dvert, int defgrp_index, float threshold, Span< int > masked_face_indices, Span< int > new_loop_starts, int faces_masked_num, int edges_add_num)
ModifierTypeInfo modifierType_Mask
void DEG_add_depends_on_transform_relation(DepsNodeHandle *node_handle, const char *description)
int BKE_id_defgroup_name_index(const ID *id, StringRef name)
Definition deform.cc:557
static void compute_masked_verts(Span< bool > vertex_mask, MutableSpan< int > r_vertex_map, uint *r_verts_masked_num)
static void required_data_mask(ModifierData *, CustomData_MeshMasks *r_cddata_masks)
void modifier_error_message_draw(ui::Layout &layout, PointerRNA *ptr)
float BKE_defvert_find_weight(const MDeformVert *dvert, int defgroup)
Definition deform.cc:779
void modifier_vgroup_ui(ui::Layout &layout, PointerRNA *ptr, PointerRNA *ob_ptr, const StringRefNull vgroup_prop, const std::optional< StringRefNull > invert_vgroup_prop, const std::optional< StringRefNull > text)
VecBase< int32_t, 2 > int2
static void panel_register(ARegionType *region_type)
static void compute_vertex_mask__vertex_group_mode(const MDeformVert *dvert, int defgrp_index, float threshold, MutableSpan< bool > r_vertex_mask)
static void copy_masked_verts_to_new_mesh(const Mesh &src_mesh, Mesh &dst_mesh, Span< int > vertex_map)
static Mesh * modify_mesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh)
Definition MOD_array.cc:873
@ eModifierTypeFlag_SupportsMapping
@ eModifierTypeFlag_SupportsEditmode
@ eModifierTypeFlag_AcceptsMesh
static void computed_masked_edges(const Mesh *mesh, Span< bool > vertex_mask, MutableSpan< int > r_edge_map, uint *r_edges_masked_num)
static void computed_masked_edges_smooth(const Mesh *mesh, Span< bool > vertex_mask, MutableSpan< int > r_edge_map, uint *r_edges_masked_num, uint *r_verts_add_num)
static void compute_vertex_mask__armature_mode(const MDeformVert *dvert, Mesh *mesh, Object *armature_ob, float threshold, MutableSpan< bool > r_vertex_mask)
ATTR_WARN_UNUSED_RESULT const BMVert * v2
static float get_interp_factor_from_vgroup(const MDeformVert *dvert, int defgrp_index, float threshold, uint v1, uint v2)
PanelType * modifier_panel_register(ARegionType *region_type, ModifierType type, PanelDrawFn draw)
Mesh * BKE_mesh_new_nomain_from_template(const Mesh *me_src, int verts_num, int edges_num, int faces_num, int corners_num)
static void panel_draw(const bContext *, Panel *panel)
static void computed_masked_faces(const Mesh *mesh, Span< bool > vertex_mask, Vector< int > &r_masked_face_indices, Vector< int > &r_loop_starts, uint *r_faces_masked_num, uint *r_loops_masked_num)
static bool is_disabled(const Scene *, ModifierData *md, bool)
bPoseChannel * BKE_pose_channel_find_name(const bPose *pose, const char *name)
void BKE_modifier_copydata_generic(const ModifierData *md, ModifierData *md_dst, int flag)
struct bPose * pose
ui::Layout * layout
void use_property_decorate_set(bool is_decorate)
void use_property_split_set(bool is_sep)
void prop(PointerRNA *ptr, PropertyRNA *prop, int index, int value, eUI_Item_Flag flag, std::optional< StringRef > name_opt, int icon, std::optional< StringRef > placeholder=std::nullopt)
Layout & row(bool align)
#define N_(msgid)