Blender V5.3
relax.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2024 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
10
11#include "DNA_brush_types.h"
12#include "DNA_mesh_types.h"
13
14#include "BKE_object_types.hh"
15#include "BKE_subdiv_ccg.hh"
16
18#include "BLI_task.hh"
19
26
27#include "bmesh.hh"
28
30
31inline namespace relax_cc {
32
33/* -------------------------------------------------------------------- */
36
41
46
51
52static void apply_positions_faces(const Sculpt &sd,
53 const Span<int> verts,
54 Object &object,
55 const MutableSpan<float3> translations,
56 const PositionDeformData &position_data)
57{
58 SculptSession &ss = *object.runtime->sculpt_session;
59 clip_and_lock_translations(sd, ss, position_data.eval, verts, translations);
60 position_data.deform(translations, verts);
61}
62
63static void apply_positions_grids(const Sculpt &sd,
64 const Span<int> grids,
65 Object &object,
66 const Span<float3> positions,
67 const MutableSpan<float3> translations)
68{
69 SculptSession &ss = *object.runtime->sculpt_session;
70 SubdivCCG &subdiv_ccg = *ss.subdiv_ccg;
71
72 clip_and_lock_translations(sd, ss, positions, translations);
73 apply_translations(translations, grids, subdiv_ccg);
74}
75
76static void apply_positions_bmesh(const Sculpt &sd,
77 const Set<BMVert *, 0> verts,
78 Object &object,
79 const MutableSpan<float3> translations,
80 const Span<float3> positions)
81
82{
83 SculptSession &ss = *object.runtime->sculpt_session;
84
85 clip_and_lock_translations(sd, ss, positions, translations);
86 apply_translations(translations, verts);
87}
88
90
91/* -------------------------------------------------------------------- */
94
95static std::array<float, 4> iteration_strengths(const float strength, const int stroke_iteration)
96{
97 if (stroke_iteration % 3 == 0) {
98 return {strength, strength, strength, strength};
99 }
100
101 /* This operation needs a strength tweak as the relax deformation is too weak by default.
102 * We cap the strength at 1.0 to avoid ripping the mesh in cases where this modified value is
103 * too strong. */
104 const float modified_strength = std::min(strength * 1.5f, 1.0f);
105 return {modified_strength, modified_strength, strength, strength};
106}
107
108BLI_NOINLINE static void calc_factors_faces(const Depsgraph &depsgraph,
109 const Brush &brush,
110 const Span<float3> positions_eval,
111 const Span<float3> vert_normals,
112 const GroupedSpan<int> vert_to_face_map,
113 const MeshAttributeData &attribute_data,
114 const float strength,
115 const bool relax_face_sets,
116 const Object &object,
118 MeshLocalData &tls,
119 const MutableSpan<float> factors)
120{
121 const SculptSession &ss = *object.runtime->sculpt_session;
122 const StrokeCache &cache = *ss.cache;
123
124 const Span<int> verts = node.verts();
125
126 fill_factor_from_hide_and_mask(attribute_data.hide_vert, attribute_data.mask, verts, factors);
127 filter_region_clip_factors(ss, positions_eval, verts, factors);
128 if (brush.flag & BRUSH_FRONTFACE) {
129 calc_front_face(cache.view_normal_symm, vert_normals, verts, factors);
130 }
131
132 tls.distances.resize(verts.size());
133 const MutableSpan<float> distances = tls.distances;
135 ss, positions_eval, verts, eBrushFalloffShape(brush.falloff_shape), distances);
136 filter_distances_with_radius(cache.radius, distances, factors);
137 apply_hardness_to_distances(cache, distances);
138 calc_brush_strength_factors(cache, brush, distances, factors);
139
140 auto_mask::calc_vert_factors(depsgraph, object, cache.automasking.get(), node, verts, factors);
141
142 scale_factors(factors, strength);
143
144 calc_brush_texture_factors(PaintMode::Sculpt, ss, brush, positions_eval, verts, factors);
145
147 vert_to_face_map, attribute_data.face_sets, relax_face_sets, verts, factors);
148}
149
150static void do_relax_face_sets_brush_mesh(const Depsgraph &depsgraph,
151 const Sculpt &sd,
152 const Brush &brush,
153 Object &object,
154 const IndexMask &node_mask,
155 const float strength,
156 const bool relax_face_sets)
157{
158 const SculptSession &ss = *object.runtime->sculpt_session;
161 Mesh &mesh = *id_cast<Mesh *>(object.data);
162 const OffsetIndices faces = mesh.faces();
163 const Span<int> corner_verts = mesh.corner_verts();
164 const GroupedSpan<int> vert_to_face_map = mesh.vert_to_face_map();
165 const MeshAttributeData attribute_data(mesh);
166
167 const PositionDeformData position_data(depsgraph, object);
168 const Span<float3> vert_normals = bke::pbvh::vert_normals_eval(depsgraph, object);
169
170 Array<int> node_offset_data;
171 const OffsetIndices<int> node_vert_offsets = create_node_vert_offsets(
172 nodes, node_mask, node_offset_data);
173
174 Array<float3> translations(node_vert_offsets.total_size());
175 Array<float> factors(node_vert_offsets.total_size());
176
178 node_mask.foreach_index(
179 [&](const int i, const int pos) {
180 MeshLocalData &tls = all_tls.local();
181 calc_factors_faces(depsgraph,
182 brush,
183 position_data.eval,
184 vert_normals,
185 vert_to_face_map,
186 attribute_data,
187 strength,
188 relax_face_sets,
189 object,
190 nodes[i],
191 tls,
192 factors.as_mutable_span().slice(node_vert_offsets[pos]));
193 },
195
196 node_mask.foreach_index(
197 [&](const int i, const int pos) {
199 position_data.eval,
200 vert_normals,
201 faces,
202 corner_verts,
203 vert_to_face_map,
204 ss.boundary_info_cache->verts,
205 ss.boundary_info_cache->edges,
206 attribute_data.face_sets,
207 attribute_data.hide_poly,
208 relax_face_sets,
209 nodes[i].verts(),
210 factors.as_span().slice(node_vert_offsets[pos]),
211 translations.as_mutable_span().slice(node_vert_offsets[pos]));
212 },
214
215 node_mask.foreach_index(
216 [&](const int i, const int pos) {
218 nodes[i].verts(),
219 object,
220 translations.as_mutable_span().slice(node_vert_offsets[pos]),
221 position_data);
222 bke::pbvh::update_node_bounds_mesh(position_data.eval, nodes[i]);
223 },
225 pbvh.tag_positions_changed(node_mask);
226 pbvh.flush_bounds_to_parents();
227}
228
229BLI_NOINLINE static void calc_factors_grids(const Depsgraph &depsgraph,
230 const Brush &brush,
231 const OffsetIndices<int> faces,
232 const Span<int> corner_verts,
233 const GroupedSpan<int> vert_to_face_map,
234 const Span<int> face_sets,
236 const float strength,
237 const bool relax_face_sets,
238 Object &object,
239 GridLocalData &tls,
240 const MutableSpan<float3> positions,
241 const MutableSpan<float> factors)
242{
243 SculptSession &ss = *object.runtime->sculpt_session;
244 const StrokeCache &cache = *ss.cache;
245 const SubdivCCG &subdiv_ccg = *ss.subdiv_ccg;
246 const CCGKey key = BKE_subdiv_ccg_key_top_level(subdiv_ccg);
247
248 const Span<int> grids = node.grids();
249 const int grid_verts_num = grids.size() * key.grid_area;
250
251 gather_data_grids(subdiv_ccg, subdiv_ccg.positions.as_span(), grids, positions);
252
253 fill_factor_from_hide_and_mask(subdiv_ccg, grids, factors);
254 filter_region_clip_factors(ss, positions, factors);
255 if (brush.flag & BRUSH_FRONTFACE) {
256 calc_front_face(cache.view_normal_symm, subdiv_ccg, grids, factors);
257 }
258
259 tls.distances.resize(grid_verts_num);
260 const MutableSpan<float> distances = tls.distances;
261 calc_brush_distances(ss, positions, eBrushFalloffShape(brush.falloff_shape), distances);
262 filter_distances_with_radius(cache.radius, distances, factors);
263 apply_hardness_to_distances(cache, distances);
264 calc_brush_strength_factors(cache, brush, distances, factors);
265
266 auto_mask::calc_grids_factors(depsgraph, object, cache.automasking.get(), node, grids, factors);
267
268 scale_factors(factors, strength);
269
270 calc_brush_texture_factors(PaintMode::Sculpt, ss, brush, positions, factors);
271
273 corner_verts,
274 vert_to_face_map,
275 face_sets,
276 subdiv_ccg,
277 relax_face_sets,
278 grids,
279 factors);
280}
281
282static void do_relax_face_sets_brush_grids(const Depsgraph &depsgraph,
283 const Sculpt &sd,
284 const Brush &brush,
285 Object &object,
286 const IndexMask &node_mask,
287 const float strength,
288 const bool relax_face_sets)
289{
290 const SculptSession &ss = *object.runtime->sculpt_session;
293 SubdivCCG &subdiv_ccg = *ss.subdiv_ccg;
294 MutableSpan<float3> positions = subdiv_ccg.positions;
295 const CCGKey key = BKE_subdiv_ccg_key_top_level(subdiv_ccg);
296
297 Mesh &mesh = *id_cast<Mesh *>(object.data);
298 const OffsetIndices faces = mesh.faces();
299 const Span<int> corner_verts = mesh.corner_verts();
300 const GroupedSpan<int> vert_to_face_map = mesh.vert_to_face_map();
301 const bke::AttributeAccessor attributes = mesh.attributes();
302 const VArraySpan hide_poly = *attributes.lookup<bool>(".hide_poly", bke::AttrDomain::Face);
303 const VArraySpan face_sets = *attributes.lookup<int>(".sculpt_face_set", bke::AttrDomain::Face);
304
305 Array<int> node_offset_data;
306 const OffsetIndices<int> node_vert_offsets = create_node_vert_offsets(
307 key, nodes, node_mask, node_offset_data);
308
309 Array<float3> current_positions(node_vert_offsets.total_size());
310 Array<float3> translations(node_vert_offsets.total_size());
311 Array<float> factors(node_vert_offsets.total_size());
312
314 node_mask.foreach_index(
315 [&](const int i, const int pos) {
316 GridLocalData &tls = all_tls.local();
317 calc_factors_grids(depsgraph,
318 brush,
319 faces,
320 corner_verts,
321 vert_to_face_map,
322 face_sets,
323 nodes[i],
324 strength,
325 relax_face_sets,
326 object,
327 tls,
328 current_positions.as_mutable_span().slice(node_vert_offsets[pos]),
329 factors.as_mutable_span().slice(node_vert_offsets[pos]));
330 },
332
333 node_mask.foreach_index(
334 [&](const int i, const int pos) {
336 subdiv_ccg,
337 faces,
338 corner_verts,
339 face_sets,
340 vert_to_face_map,
341 ss.boundary_info_cache->verts,
342 ss.boundary_info_cache->edges,
343 nodes[i].grids(),
344 relax_face_sets,
345 factors.as_span().slice(node_vert_offsets[pos]),
346 translations.as_mutable_span().slice(node_vert_offsets[pos]));
347 },
349
350 node_mask.foreach_index(
351 [&](const int i, const int pos) {
353 nodes[i].grids(),
354 object,
355 current_positions.as_mutable_span().slice(node_vert_offsets[pos]),
356 translations.as_mutable_span().slice(node_vert_offsets[pos]));
357 bke::pbvh::update_node_bounds_grids(subdiv_ccg.grid_area, positions, nodes[i]);
358 },
360 pbvh.tag_positions_changed(node_mask);
361 pbvh.flush_bounds_to_parents();
362}
363
364static void calc_factors_bmesh(const Depsgraph &depsgraph,
365 Object &object,
366 const Brush &brush,
367 const int face_set_offset,
369 const float strength,
370 const bool relax_face_sets,
371 BMeshLocalData &tls,
372 MutableSpan<float3> positions,
373 MutableSpan<float> factors)
374{
375 SculptSession &ss = *object.runtime->sculpt_session;
376 const StrokeCache &cache = *ss.cache;
377
379
380 gather_bmesh_positions(verts, positions);
381
382 fill_factor_from_hide_and_mask(*ss.bm, verts, factors);
383 filter_region_clip_factors(ss, positions, factors);
384 if (brush.flag & BRUSH_FRONTFACE) {
385 calc_front_face(cache.view_normal_symm, verts, factors);
386 }
387
388 tls.distances.resize(verts.size());
389 const MutableSpan<float> distances = tls.distances;
390 calc_brush_distances(ss, positions, eBrushFalloffShape(brush.falloff_shape), distances);
391 filter_distances_with_radius(cache.radius, distances, factors);
392 apply_hardness_to_distances(cache, distances);
393 calc_brush_strength_factors(cache, brush, distances, factors);
394
395 auto_mask::calc_vert_factors(depsgraph, object, cache.automasking.get(), node, verts, factors);
396
397 scale_factors(factors, strength);
398
399 calc_brush_texture_factors(PaintMode::Sculpt, ss, brush, positions, factors);
401 face_set_offset, relax_face_sets, verts, factors);
402}
403
404static void do_relax_face_sets_brush_bmesh(const Depsgraph &depsgraph,
405 const Sculpt &sd,
406 const Brush &brush,
407 Object &object,
408 const IndexMask &node_mask,
409 const float strength,
410 const bool relax_face_sets)
411{
414 Array<int> node_offset_data;
415 const OffsetIndices<int> node_vert_offsets = create_node_vert_offsets_bmesh(
416 nodes, node_mask, node_offset_data);
417
418 const int face_set_offset = CustomData_get_offset_named(
419 &object.runtime->sculpt_session->bm->pdata, CD_PROP_INT32, ".sculpt_face_set");
420
421 Array<float3> current_positions(node_vert_offsets.total_size());
422 Array<float3> translations(node_vert_offsets.total_size());
423 Array<float> factors(node_vert_offsets.total_size());
424
426 node_mask.foreach_index(
427 [&](const int i, const int pos) {
428 BMeshLocalData &tls = all_tls.local();
429 calc_factors_bmesh(depsgraph,
430 object,
431 brush,
432 face_set_offset,
433 nodes[i],
434 strength,
435 relax_face_sets,
436 tls,
437 current_positions.as_mutable_span().slice(node_vert_offsets[pos]),
438 factors.as_mutable_span().slice(node_vert_offsets[pos]));
439 },
441
442 node_mask.foreach_index(
443 [&](const int i, const int pos) {
446 current_positions.as_mutable_span().slice(node_vert_offsets[pos]),
447 face_set_offset,
448 relax_face_sets,
449 factors.as_span().slice(node_vert_offsets[pos]),
450 translations.as_mutable_span().slice(node_vert_offsets[pos]));
451 },
453
454 node_mask.foreach_index(
455 [&](const int i, const int pos) {
458 object,
459 translations.as_mutable_span().slice(node_vert_offsets[pos]),
460 current_positions.as_span().slice(node_vert_offsets[pos]));
462 },
464 pbvh.tag_positions_changed(node_mask);
465 pbvh.flush_bounds_to_parents();
466}
467
469
470/* -------------------------------------------------------------------- */
473BLI_NOINLINE static void calc_topology_relax_factors_faces(const Depsgraph &depsgraph,
474 const Brush &brush,
475 const float strength,
476 const Object &object,
477 const MeshAttributeData &attribute_data,
479 MeshLocalData &tls,
480 const MutableSpan<float> factors)
481{
482 SculptSession &ss = *object.runtime->sculpt_session;
483 const StrokeCache &cache = *ss.cache;
484
485 const OrigPositionData orig_data = orig_position_data_get_mesh(object, node);
486 const Span<int> verts = node.verts();
487
488 fill_factor_from_hide_and_mask(attribute_data.hide_vert, attribute_data.mask, verts, factors);
489 filter_region_clip_factors(ss, orig_data.positions, factors);
490 if (brush.flag & BRUSH_FRONTFACE) {
491 calc_front_face(cache.view_normal_symm, orig_data.normals, factors);
492 }
493
494 tls.distances.resize(verts.size());
495 const MutableSpan<float> distances = tls.distances;
497 ss, orig_data.positions, eBrushFalloffShape(brush.falloff_shape), distances);
498 filter_distances_with_radius(cache.radius, distances, factors);
499 apply_hardness_to_distances(cache, distances);
500 calc_brush_strength_factors(cache, brush, distances, factors);
501
502 auto_mask::calc_vert_factors(depsgraph, object, cache.automasking.get(), node, verts, factors);
503
504 scale_factors(factors, strength);
505
507}
508
509static void do_topology_relax_brush_mesh(const Depsgraph &depsgraph,
510 const Sculpt &sd,
511 const Brush &brush,
512 Object &object,
513 const IndexMask &node_mask,
514 const float strength)
515{
516 const SculptSession &ss = *object.runtime->sculpt_session;
519 Mesh &mesh = *id_cast<Mesh *>(object.data);
520 const OffsetIndices faces = mesh.faces();
521 const Span<int> corner_verts = mesh.corner_verts();
522 const GroupedSpan<int> vert_to_face_map = mesh.vert_to_face_map();
523 const MeshAttributeData attribute_data(mesh);
524 const PositionDeformData position_data(depsgraph, object);
525 const Span<float3> vert_normals = bke::pbvh::vert_normals_eval(depsgraph, object);
526
527 Array<int> node_offset_data;
528 const OffsetIndices<int> node_vert_offsets = create_node_vert_offsets(
529 nodes, node_mask, node_offset_data);
530
531 Array<float3> translations(node_vert_offsets.total_size());
532 Array<float> factors(node_vert_offsets.total_size());
533
535 node_mask.foreach_index(
536 [&](const int i, const int pos) {
537 MeshLocalData &tls = all_tls.local();
539 brush,
540 strength,
541 object,
542 attribute_data,
543 nodes[i],
544 tls,
545 factors.as_mutable_span().slice(node_vert_offsets[pos]));
546 },
548
549 node_mask.foreach_index(
550 [&](const int i, const int pos) {
552 position_data.eval,
553 vert_normals,
554 faces,
555 corner_verts,
556 vert_to_face_map,
557 ss.boundary_info_cache->verts,
558 ss.boundary_info_cache->edges,
559 attribute_data.face_sets,
560 attribute_data.hide_poly,
561 false,
562 nodes[i].verts(),
563 factors.as_span().slice(node_vert_offsets[pos]),
564 translations.as_mutable_span().slice(node_vert_offsets[pos]));
565 },
567
568 node_mask.foreach_index(
569 [&](const int i, const int pos) {
571 nodes[i].verts(),
572 object,
573 translations.as_mutable_span().slice(node_vert_offsets[pos]),
574 position_data);
575 bke::pbvh::update_node_bounds_mesh(position_data.eval, nodes[i]);
576 },
578 pbvh.tag_positions_changed(node_mask);
579 pbvh.flush_bounds_to_parents();
580}
581
582BLI_NOINLINE static void calc_topology_relax_factors_grids(const Depsgraph &depsgraph,
583 const Brush &brush,
584 const float strength,
585 const Object &object,
587 GridLocalData &tls,
588 const MutableSpan<float3> positions,
589 const MutableSpan<float> factors)
590{
591 const SculptSession &ss = *object.runtime->sculpt_session;
592 const StrokeCache &cache = *ss.cache;
593 const SubdivCCG &subdiv_ccg = *ss.subdiv_ccg;
594 const CCGKey key = BKE_subdiv_ccg_key_top_level(subdiv_ccg);
595
596 const Span<int> grids = node.grids();
597 const int grid_verts_num = grids.size() * key.grid_area;
598
599 gather_data_grids(subdiv_ccg, subdiv_ccg.positions.as_span(), grids, positions);
600 const OrigPositionData orig_data = orig_position_data_get_grids(object, node);
601
602 fill_factor_from_hide_and_mask(subdiv_ccg, grids, factors);
603 filter_region_clip_factors(ss, orig_data.positions, factors);
604 if (brush.flag & BRUSH_FRONTFACE) {
605 calc_front_face(cache.view_normal_symm, orig_data.normals, factors);
606 }
607
608 tls.distances.resize(grid_verts_num);
609 const MutableSpan<float> distances = tls.distances;
611 ss, orig_data.positions, eBrushFalloffShape(brush.falloff_shape), distances);
612 filter_distances_with_radius(cache.radius, distances, factors);
613 apply_hardness_to_distances(cache, distances);
614 calc_brush_strength_factors(cache, brush, distances, factors);
615
616 auto_mask::calc_grids_factors(depsgraph, object, cache.automasking.get(), node, grids, factors);
617
618 scale_factors(factors, strength);
619
621}
622
623static void do_topology_relax_brush_grids(const Depsgraph &depsgraph,
624 const Sculpt &sd,
625 const Brush &brush,
626 Object &object,
627 const IndexMask &node_mask,
628 const float strength)
629{
630 const SculptSession &ss = *object.runtime->sculpt_session;
633 SubdivCCG &subdiv_ccg = *object.runtime->sculpt_session->subdiv_ccg;
634 MutableSpan<float3> positions = subdiv_ccg.positions;
635 const CCGKey key = BKE_subdiv_ccg_key_top_level(subdiv_ccg);
636
637 Mesh &mesh = *id_cast<Mesh *>(object.data);
638 const OffsetIndices faces = mesh.faces();
639 const Span<int> corner_verts = mesh.corner_verts();
640 const GroupedSpan<int> vert_to_face_map = mesh.vert_to_face_map();
641 const bke::AttributeAccessor attributes = mesh.attributes();
642 const VArraySpan hide_poly = *attributes.lookup<bool>(".hide_poly", bke::AttrDomain::Face);
643 const VArraySpan face_sets = *attributes.lookup<int>(".sculpt_face_set", bke::AttrDomain::Face);
644
645 Array<int> node_offset_data;
646 const OffsetIndices<int> node_vert_offsets = create_node_vert_offsets(
647 key, nodes, node_mask, node_offset_data);
648
649 Array<float3> current_positions(node_vert_offsets.total_size());
650 Array<float3> translations(node_vert_offsets.total_size());
651 Array<float> factors(node_vert_offsets.total_size());
652
654 node_mask.foreach_index(
655 [&](const int i, const int pos) {
656 GridLocalData &tls = all_tls.local();
658 depsgraph,
659 brush,
660 strength,
661 object,
662 nodes[i],
663 tls,
664 current_positions.as_mutable_span().slice(node_vert_offsets[pos]),
665 factors.as_mutable_span().slice(node_vert_offsets[pos]));
666 },
668
669 node_mask.foreach_index(
670 [&](const int i, const int pos) {
672 subdiv_ccg,
673 faces,
674 corner_verts,
675 face_sets,
676 vert_to_face_map,
677 ss.boundary_info_cache->verts,
678 ss.boundary_info_cache->edges,
679 nodes[i].grids(),
680 false,
681 factors.as_span().slice(node_vert_offsets[pos]),
682 translations.as_mutable_span().slice(node_vert_offsets[pos]));
683 },
685
686 node_mask.foreach_index(
687 [&](const int i, const int pos) {
689 nodes[i].grids(),
690 object,
691 current_positions.as_mutable_span().slice(node_vert_offsets[pos]),
692 translations.as_mutable_span().slice(node_vert_offsets[pos]));
693 bke::pbvh::update_node_bounds_grids(subdiv_ccg.grid_area, positions, nodes[i]);
694 },
696 pbvh.tag_positions_changed(node_mask);
697 pbvh.flush_bounds_to_parents();
698}
699
700static void calc_topology_relax_factors_bmesh(const Depsgraph &depsgraph,
701 Object &object,
702 const Brush &brush,
704 const float strength,
705 BMeshLocalData &tls,
706 MutableSpan<float3> positions,
707 MutableSpan<float> factors)
708{
709 SculptSession &ss = *object.runtime->sculpt_session;
710 const StrokeCache &cache = *ss.cache;
711
713
714 Array<float3> orig_positions(verts.size());
715 Array<float3> orig_normals(verts.size());
716 orig_position_data_gather_bmesh(*ss.bm_log, verts, orig_positions, orig_normals);
717
718 gather_bmesh_positions(verts, positions);
719
720 fill_factor_from_hide_and_mask(*ss.bm, verts, factors);
721 filter_region_clip_factors(ss, orig_positions, factors);
722 if (brush.flag & BRUSH_FRONTFACE) {
723 calc_front_face(cache.view_normal_symm, orig_normals, factors);
724 }
725
726 tls.distances.resize(verts.size());
727 const MutableSpan<float> distances = tls.distances;
728 calc_brush_distances(ss, orig_positions, eBrushFalloffShape(brush.falloff_shape), distances);
729 filter_distances_with_radius(cache.radius, distances, factors);
730 apply_hardness_to_distances(cache, distances);
731 calc_brush_strength_factors(cache, brush, distances, factors);
732
733 auto_mask::calc_vert_factors(depsgraph, object, cache.automasking.get(), node, verts, factors);
734
735 scale_factors(factors, strength);
736
737 calc_brush_texture_factors(PaintMode::Sculpt, ss, brush, orig_positions, factors);
738}
739
740static void do_topology_relax_brush_bmesh(const Depsgraph &depsgraph,
741 const Sculpt &sd,
742 const Brush &brush,
743 Object &object,
744 const IndexMask &node_mask,
745 const float strength)
746{
749 const int face_set_offset = CustomData_get_offset_named(
750 &object.runtime->sculpt_session->bm->pdata, CD_PROP_INT32, ".sculpt_face_set");
751
752 Array<int> node_offset_data;
753 const OffsetIndices<int> node_vert_offsets = create_node_vert_offsets_bmesh(
754 nodes, node_mask, node_offset_data);
755
756 Array<float3> current_positions(node_vert_offsets.total_size());
757 Array<float3> translations(node_vert_offsets.total_size());
758 Array<float> factors(node_vert_offsets.total_size());
759
761 node_mask.foreach_index(
762 [&](const int i, const int pos) {
763 BMeshLocalData &tls = all_tls.local();
765 depsgraph,
766 object,
767 brush,
768 nodes[i],
769 strength,
770 tls,
771 current_positions.as_mutable_span().slice(node_vert_offsets[pos]),
772 factors.as_mutable_span().slice(node_vert_offsets[pos]));
773 },
775
776 node_mask.foreach_index(
777 [&](const int i, const int pos) {
780 current_positions.as_mutable_span().slice(node_vert_offsets[pos]),
781 face_set_offset,
782 false,
783 factors.as_span().slice(node_vert_offsets[pos]),
784 translations.as_mutable_span().slice(node_vert_offsets[pos]));
785 },
787
788 node_mask.foreach_index(
789 [&](const int i, const int pos) {
792 object,
793 translations.as_mutable_span().slice(node_vert_offsets[pos]),
794 current_positions.as_span().slice(node_vert_offsets[pos]));
796 },
798 pbvh.tag_positions_changed(node_mask);
799 pbvh.flush_bounds_to_parents();
800}
801
802
803} // namespace relax_cc
804
805void do_relax_face_sets_brush(const Depsgraph &depsgraph,
806 const Sculpt &sd,
807 Object &object,
808 const IndexMask &node_mask)
809{
812
814
815 const SculptSession &ss = *object.runtime->sculpt_session;
816 const std::array<float, 4> strengths = iteration_strengths(ss.cache->bstrength,
818
819 /* On every third step of the stroke, behave more similarly to the Topology Relax brush */
820 const bool relax_face_sets = !(ss.cache->iteration_count % 3 == 0);
821
822 for (const float strength : strengths) {
823 switch (bke::object::pbvh_get(object)->type()) {
826 depsgraph, sd, brush, object, node_mask, strength * strength, relax_face_sets);
827 break;
830 depsgraph, sd, brush, object, node_mask, strength * strength, relax_face_sets);
831 break;
834 depsgraph, sd, brush, object, node_mask, strength * strength, relax_face_sets);
835 break;
836 }
837 }
838}
839
840void do_topology_relax_brush(const Depsgraph &depsgraph,
841 const Sculpt &sd,
842 Object &object,
843 const IndexMask &node_mask)
844{
847 const SculptSession &ss = *object.runtime->sculpt_session;
848
850 return;
851 }
852
853 const float strength = ss.cache->bstrength;
854
856
857 for (int i = 0; i < 4; i++) {
858 switch (bke::object::pbvh_get(object)->type()) {
860 do_topology_relax_brush_mesh(depsgraph, sd, brush, object, node_mask, strength);
861 break;
863 do_topology_relax_brush_grids(depsgraph, sd, brush, object, node_mask, strength);
864 break;
866 do_topology_relax_brush_bmesh(depsgraph, sd, brush, object, node_mask, strength);
867 break;
868 }
869 }
870}
871} // namespace blender::ed::sculpt_paint::brushes
#define PRF_scope(category)
#define BLI_NOINLINE
Span< T > as_span() const
Definition BLI_array.hh:254
MutableSpan< T > as_mutable_span()
Definition BLI_array.hh:259
int64_t size() const
Definition BLI_set.hh:606
constexpr int64_t size() const
Definition BLI_span.hh:256
GAttributeReader lookup(const StringRef name) const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
pbvh::Tree * pbvh_get(Object &object)
void update_node_bounds_bmesh(BMeshNode &node)
Definition pbvh.cc:1216
void update_node_bounds_mesh(Span< float3 > positions, MeshNode &node)
Definition pbvh.cc:1196
Span< float3 > vert_normals_eval(const Depsgraph &depsgraph, const Object &object_orig)
Definition pbvh.cc:952
void update_node_bounds_grids(int grid_area, Span< float3 > positions, GridsNode &node)
Definition pbvh.cc:1205
void calc_vert_factors(const Depsgraph &depsgraph, const Object &object, const Cache &automasking, const bke::pbvh::MeshNode &node, Span< int > verts, MutableSpan< float > factors)
void calc_grids_factors(const Depsgraph &depsgraph, const Object &object, const Cache &automasking, const bke::pbvh::GridsNode &node, Span< int > grids, MutableSpan< float > factors)
void ensure_boundary_info(Object &object)
Definition sculpt.cc:588
static BLI_NOINLINE void calc_topology_relax_factors_faces(const Depsgraph &depsgraph, const Brush &brush, const float strength, const Object &object, const MeshAttributeData &attribute_data, const bke::pbvh::MeshNode &node, MeshLocalData &tls, const MutableSpan< float > factors)
Definition relax.cc:473
static BLI_NOINLINE void calc_topology_relax_factors_grids(const Depsgraph &depsgraph, const Brush &brush, const float strength, const Object &object, const bke::pbvh::GridsNode &node, GridLocalData &tls, const MutableSpan< float3 > positions, const MutableSpan< float > factors)
Definition relax.cc:582
static void do_topology_relax_brush_mesh(const Depsgraph &depsgraph, const Sculpt &sd, const Brush &brush, Object &object, const IndexMask &node_mask, const float strength)
Definition relax.cc:509
static void do_topology_relax_brush_bmesh(const Depsgraph &depsgraph, const Sculpt &sd, const Brush &brush, Object &object, const IndexMask &node_mask, const float strength)
Definition relax.cc:740
static void do_relax_face_sets_brush_grids(const Depsgraph &depsgraph, const Sculpt &sd, const Brush &brush, Object &object, const IndexMask &node_mask, const float strength, const bool relax_face_sets)
Definition relax.cc:282
static BLI_NOINLINE void calc_factors_faces(const Depsgraph &depsgraph, const Brush &brush, const Span< float3 > positions_eval, const Span< float3 > vert_normals, const GroupedSpan< int > vert_to_face_map, const MeshAttributeData &attribute_data, const float strength, const bool relax_face_sets, const Object &object, const bke::pbvh::MeshNode &node, MeshLocalData &tls, const MutableSpan< float > factors)
Definition relax.cc:108
static void apply_positions_grids(const Sculpt &sd, const Span< int > grids, Object &object, const Span< float3 > positions, const MutableSpan< float3 > translations)
Definition relax.cc:63
static void calc_topology_relax_factors_bmesh(const Depsgraph &depsgraph, Object &object, const Brush &brush, bke::pbvh::BMeshNode &node, const float strength, BMeshLocalData &tls, MutableSpan< float3 > positions, MutableSpan< float > factors)
Definition relax.cc:700
static void calc_factors_bmesh(const Depsgraph &depsgraph, Object &object, const Brush &brush, const int face_set_offset, bke::pbvh::BMeshNode &node, const float strength, const bool relax_face_sets, BMeshLocalData &tls, MutableSpan< float3 > positions, MutableSpan< float > factors)
Definition relax.cc:364
static BLI_NOINLINE void calc_factors_grids(const Depsgraph &depsgraph, const Brush &brush, const OffsetIndices< int > faces, const Span< int > corner_verts, const GroupedSpan< int > vert_to_face_map, const Span< int > face_sets, const bke::pbvh::GridsNode &node, const float strength, const bool relax_face_sets, Object &object, GridLocalData &tls, const MutableSpan< float3 > positions, const MutableSpan< float > factors)
Definition relax.cc:229
static std::array< float, 4 > iteration_strengths(const float strength, const int stroke_iteration)
Definition relax.cc:95
static void apply_positions_faces(const Sculpt &sd, const Span< int > verts, Object &object, const MutableSpan< float3 > translations, const PositionDeformData &position_data)
Definition relax.cc:52
static void do_topology_relax_brush_grids(const Depsgraph &depsgraph, const Sculpt &sd, const Brush &brush, Object &object, const IndexMask &node_mask, const float strength)
Definition relax.cc:623
static void apply_positions_bmesh(const Sculpt &sd, const Set< BMVert *, 0 > verts, Object &object, const MutableSpan< float3 > translations, const Span< float3 > positions)
Definition relax.cc:76
static void do_relax_face_sets_brush_mesh(const Depsgraph &depsgraph, const Sculpt &sd, const Brush &brush, Object &object, const IndexMask &node_mask, const float strength, const bool relax_face_sets)
Definition relax.cc:150
static void do_relax_face_sets_brush_bmesh(const Depsgraph &depsgraph, const Sculpt &sd, const Brush &brush, Object &object, const IndexMask &node_mask, const float strength, const bool relax_face_sets)
Definition relax.cc:404
void do_topology_relax_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask)
Definition relax.cc:840
void do_relax_face_sets_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask)
Definition relax.cc:805
void filter_verts_with_unique_face_sets_mesh(const GroupedSpan< int > vert_to_face_map, const Span< int > face_sets, const bool unique, const Span< int > verts, const MutableSpan< float > factors)
void filter_verts_with_unique_face_sets_bmesh(int face_set_offset, const bool unique, const Set< BMVert *, 0 > &verts, const MutableSpan< float > factors)
void filter_verts_with_unique_face_sets_grids(const OffsetIndices< int > faces, const Span< int > corner_verts, const GroupedSpan< int > vert_to_face_map, const Span< int > face_sets, const SubdivCCG &subdiv_ccg, const bool unique, const Span< int > grids, const MutableSpan< float > factors)
void calc_relaxed_translations_faces(const Span< float3 > vert_positions, const Span< float3 > vert_normals, const OffsetIndices< int > faces, const Span< int > corner_verts, const GroupedSpan< int > vert_to_face_map, const BitSpan boundary_verts, const Set< OrderedEdge > &boundary_edges, const Span< int > face_sets, const Span< bool > hide_poly, const bool filter_boundary_face_sets, const Span< int > verts, const Span< float > factors, const MutableSpan< float3 > translations)
void calc_relaxed_translations_bmesh(const Set< BMVert *, 0 > &verts, const Span< float3 > positions, const int face_set_offset, const bool filter_boundary_face_sets, const Span< float > factors, const MutableSpan< float3 > translations)
void calc_relaxed_translations_grids(const SubdivCCG &subdiv_ccg, const OffsetIndices< int > faces, const Span< int > corner_verts, const Span< int > face_sets, const GroupedSpan< int > vert_to_face_map, const BitSpan boundary_verts, const Set< OrderedEdge > &boundary_edges, const Span< int > grids, const bool filter_boundary_face_sets, const Span< float > factors, const MutableSpan< float3 > translations)
void fill_factor_from_hide_and_mask(Span< bool > hide_vert, Span< float > mask, Span< int > verts, MutableSpan< float > r_factors)
Definition sculpt.cc:7128
void gather_bmesh_positions(const Set< BMVert *, 0 > &verts, MutableSpan< float3 > positions)
Definition sculpt.cc:6497
void calc_brush_strength_factors(const StrokeCache &cache, const Brush &brush, Span< float > distances, MutableSpan< float > factors)
Definition sculpt.cc:7501
void gather_data_grids(const SubdivCCG &subdiv_ccg, Span< T > src, Span< int > grids, MutableSpan< T > node_data)
Definition sculpt.cc:6528
void apply_hardness_to_distances(float radius, float hardness, MutableSpan< float > distances)
Definition sculpt.cc:7473
void filter_distances_with_radius(float radius, Span< float > distances, MutableSpan< float > factors)
Definition sculpt.cc:7422
void filter_region_clip_factors(const SculptSession &ss, Span< float3 > vert_positions, Span< int > verts, MutableSpan< float > factors)
Definition sculpt.cc:7285
bool stroke_is_first_brush_step_of_symmetry_pass(const StrokeCache &cache)
Definition sculpt.cc:667
void orig_position_data_gather_bmesh(const BMLog &bm_log, const Set< BMVert *, 0 > &verts, MutableSpan< float3 > positions, MutableSpan< float3 > normals)
void scale_factors(MutableSpan< float > factors, float strength)
Definition sculpt.cc:7856
void clip_and_lock_translations(const Sculpt &sd, const SculptSession &ss, Span< float3 > positions, Span< int > verts, MutableSpan< float3 > translations)
Definition sculpt.cc:7664
void calc_brush_distances(const SculptSession &ss, Span< float3 > vert_positions, Span< int > vert, eBrushFalloffShape falloff_shape, MutableSpan< float > r_distances)
Definition sculpt.cc:7370
OffsetIndices< int > create_node_vert_offsets(Span< bke::pbvh::MeshNode > nodes, const IndexMask &node_mask, Array< int > &node_data)
Definition sculpt.cc:7912
void apply_translations(Span< float3 > translations, Span< int > verts, MutableSpan< float3 > positions)
Definition sculpt.cc:7592
OrigPositionData orig_position_data_get_mesh(const Object &object, const bke::pbvh::MeshNode &node)
OrigPositionData orig_position_data_get_grids(const Object &object, const bke::pbvh::GridsNode &node)
void calc_front_face(const float3 &view_normal, Span< float3 > normals, MutableSpan< float > factors)
Definition sculpt.cc:7223
void calc_brush_texture_factors(PaintMode paint_mode, const SculptSession &ss, const Brush &brush, Span< float3 > vert_positions, Span< int > vert, MutableSpan< float > factors)
Definition sculpt.cc:7513
OffsetIndices< int > create_node_vert_offsets_bmesh(Span< bke::pbvh::BMeshNode > nodes, const IndexMask &node_mask, Array< int > &node_data)
Definition sculpt.cc:7936
constexpr ParallelGrainSize grain_size(int grain_size)
CCGKey BKE_subdiv_ccg_key_top_level(const SubdivCCG &subdiv_ccg)
BMesh const char void * data
int CustomData_get_offset_named(const CustomData *data, eCustomDataType type, StringRef name)
const Brush * BKE_paint_brush_for_read(const Paint *paint)
const Set< BMVert *, 0 > & BKE_pbvh_bmesh_node_unique_verts(bke::pbvh::BMeshNode *node)
std::unique_ptr< SculptBoundaryInfoCache > boundary_info_cache
Definition BKE_paint.hh:458
ed::sculpt_paint::StrokeCache * cache
Definition BKE_paint.hh:409
Array< float3 > positions
std::unique_ptr< auto_mask::Cache > automasking
void resize(int new_size)
Definition vector.hh:94