Blender V5.3
sculpt_boundary.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2020 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8#include "sculpt_boundary.hh"
9
10#include "BLI_array_utils.hh"
12#include "BLI_math_geom_c.hh"
14#include "BLI_math_vector.hh"
15
16#include "DNA_brush_types.h"
17#include "DNA_mesh_types.h"
18#include "DNA_object_types.h"
19
20#include "BKE_attribute.hh"
21#include "BKE_brush.hh"
22#include "BKE_ccg.hh"
23#include "BKE_colortools.hh"
24#include "BKE_object_types.hh"
25#include "BKE_paint.hh"
26#include "BKE_paint_bvh.hh"
27
28#include "../paint_intern.hh"
29#include "mesh_brush_common.hh"
30#include "sculpt_automask.hh"
31#include "sculpt_cloth.hh"
32#include "sculpt_flood_fill.hh"
33#include "sculpt_intern.hh"
34
35#include "GPU_immediate.hh"
36#include "GPU_state.hh"
37
38#include "bmesh.hh"
39
40#include <cstdlib>
41
43
44static bool check_counts(const int neighbor_count, const int boundary_vertex_count)
45{
46 /* Corners are ambiguous as it can't be decide which boundary should be active. The flood fill
47 * should also stop at corners. */
48 if (neighbor_count <= 2) {
49 return false;
50 }
51
52 /* Non manifold geometry in the mesh boundary.
53 * The deformation result will be unpredictable and not very useful. */
54 if (boundary_vertex_count > 2) {
55 return false;
56 }
57
58 return true;
59}
60
66 const Span<int> corner_verts,
67 const GroupedSpan<int> vert_to_face,
68 const Span<bool> hide_vert,
69 const Span<bool> hide_poly,
70 const BitSpan boundary_verts,
71 const int initial_vert)
72{
73 if (!hide_vert.is_empty() && hide_vert[initial_vert]) {
74 return false;
75 }
76
77 int neighbor_count = 0;
78 int boundary_vertex_count = 0;
79
80 Vector<int> neighbors;
81 for (const int neighbor : vert_neighbors_get_mesh(
82 faces, corner_verts, vert_to_face, hide_poly, initial_vert, neighbors))
83 {
84 if (hide_vert.is_empty() || !hide_vert[neighbor]) {
85 neighbor_count++;
86 if (boundary::vert_is_boundary(vert_to_face, hide_poly, boundary_verts, neighbor)) {
87 boundary_vertex_count++;
88 }
89 }
90 }
91
92 return check_counts(neighbor_count, boundary_vertex_count);
93}
94
96 const Span<int> corner_verts,
97 const SubdivCCG &subdiv_ccg,
98 const BitSpan boundary_verts,
99 const Set<OrderedEdge> &boundary_edges,
100 const SubdivCCGCoord initial_vert)
101{
102 const CCGKey key = BKE_subdiv_ccg_key_top_level(subdiv_ccg);
103 const BitGroupVector<> &grid_hidden = subdiv_ccg.grid_hidden;
104 if (!grid_hidden.is_empty() && grid_hidden[initial_vert.grid_index][initial_vert.to_index(key)])
105 {
106 return false;
107 }
108
109 SubdivCCGNeighbors neighbors;
110 BKE_subdiv_ccg_neighbor_coords_get(subdiv_ccg, initial_vert, false, neighbors);
111
112 int neighbor_count = 0;
113 int boundary_vertex_count = 0;
114 for (const SubdivCCGCoord neighbor : neighbors.coords) {
115 if (grid_hidden.is_empty() || !grid_hidden[neighbor.grid_index][neighbor.to_index(key)]) {
116 neighbor_count++;
118 faces, corner_verts, boundary_verts, boundary_edges, subdiv_ccg, neighbor))
119 {
120 boundary_vertex_count++;
121 }
122 }
123 }
124
125 return check_counts(neighbor_count, boundary_vertex_count);
126}
127
129{
130 if (BM_elem_flag_test(&initial_vert, BM_ELEM_HIDDEN)) {
131 return false;
132 }
133
134 int neighbor_count = 0;
135 int boundary_vertex_count = 0;
136
137 BMeshNeighborVerts neighbors;
138 for (BMVert *neighbor : vert_neighbors_get_bmesh(initial_vert, neighbors)) {
139 if (!BM_elem_flag_test(neighbor, BM_ELEM_HIDDEN)) {
140 neighbor_count++;
141 if (boundary::vert_is_boundary(neighbor)) {
142 boundary_vertex_count++;
143 }
144 }
145 }
146
147 return check_counts(neighbor_count, boundary_vertex_count);
148}
149
150/* -------------------------------------------------------------------- */
157static std::optional<int> get_closest_boundary_vert_mesh(Object &object,
158 const GroupedSpan<int> vert_to_face,
159 const Span<float3> vert_positions,
160 const Span<bool> hide_vert,
161 const Span<bool> hide_poly,
162 const BitSpan boundary_verts,
163 const int initial_vert,
164 const float radius)
165{
166 if (boundary::vert_is_boundary(vert_to_face, hide_poly, boundary_verts, initial_vert)) {
167 return initial_vert;
168 }
169
170 flood_fill::FillDataMesh flood_fill(vert_positions.size());
171 flood_fill.add_initial(initial_vert);
172
173 const float3 initial_vert_position = vert_positions[initial_vert];
174 const float radius_sq = radius * radius;
175
176 std::optional<int> boundary_initial_vert;
177 int boundary_initial_vert_steps = std::numeric_limits<int>::max();
178 Array<int> floodfill_steps(vert_positions.size(), 0);
179
180 flood_fill.execute(object, vert_to_face, [&](int from_v, int to_v) {
181 if (!hide_vert.is_empty() && hide_vert[from_v]) {
182 return false;
183 }
184
185 floodfill_steps[to_v] = floodfill_steps[from_v] + 1;
186
187 if (boundary::vert_is_boundary(vert_to_face, hide_poly, boundary_verts, to_v)) {
188 if (floodfill_steps[to_v] < boundary_initial_vert_steps) {
189 boundary_initial_vert_steps = floodfill_steps[to_v];
190 boundary_initial_vert = to_v;
191 }
192 }
193
194 const float len_sq = math::distance_squared(initial_vert_position, vert_positions[to_v]);
195 return len_sq < radius_sq;
196 });
197
198 return boundary_initial_vert;
199}
200
201static std::optional<SubdivCCGCoord> get_closest_boundary_vert_grids(
202 Object &object,
203 const OffsetIndices<int> faces,
204 const Span<int> corner_verts,
205 const SubdivCCG &subdiv_ccg,
206 const BitSpan boundary_verts,
207 const Set<OrderedEdge> &boundary_edges,
208 const SubdivCCGCoord initial_vert,
209 const float radius)
210{
212 faces, corner_verts, boundary_verts, boundary_edges, subdiv_ccg, initial_vert))
213 {
214 return initial_vert;
215 }
216
217 const Span<float3> positions = subdiv_ccg.positions;
218 const CCGKey key = BKE_subdiv_ccg_key_top_level(subdiv_ccg);
219
221 flood_fill.add_initial(initial_vert);
222
223 const float3 initial_vert_position = positions[initial_vert.to_index(key)];
224 const float radius_sq = radius * radius;
225
226 int boundary_initial_vert_steps = std::numeric_limits<int>::max();
227 Array<int> floodfill_steps(positions.size(), 0);
228 std::optional<SubdivCCGCoord> boundary_initial_vert;
229
230 flood_fill.execute(
231 object, subdiv_ccg, [&](SubdivCCGCoord from_v, SubdivCCGCoord to_v, bool is_duplicate) {
232 const int to_v_index = to_v.to_index(key);
233 const int from_v_index = from_v.to_index(key);
234
235 if (!subdiv_ccg.grid_hidden.is_empty()) {
236 return false;
237 }
238
239 if (is_duplicate) {
240 floodfill_steps[to_v_index] = floodfill_steps[from_v_index];
241 }
242 else {
243 floodfill_steps[to_v_index] = floodfill_steps[from_v_index] + 1;
244 }
245
247 faces, corner_verts, boundary_verts, boundary_edges, subdiv_ccg, to_v))
248 {
249 if (floodfill_steps[to_v_index] < boundary_initial_vert_steps) {
250 boundary_initial_vert_steps = floodfill_steps[to_v_index];
251 boundary_initial_vert = to_v;
252 }
253 }
254
255 const float len_sq = math::distance_squared(initial_vert_position,
256 positions[to_v.to_index(key)]);
257 return len_sq < radius_sq;
258 });
259
260 return boundary_initial_vert;
261}
262
263static std::optional<BMVert *> get_closest_boundary_vert_bmesh(Object &object,
264 BMesh *bm,
265 BMVert &initial_vert,
266 const float radius)
267{
268 if (boundary::vert_is_boundary(&initial_vert)) {
269 return &initial_vert;
270 }
271
272 const int num_verts = BM_mesh_elem_count(bm, BM_VERT);
274 flood_fill.add_initial(&initial_vert);
275
276 const float3 initial_vert_position = initial_vert.co;
277 const float radius_sq = radius * radius;
278
279 int boundary_initial_vert_steps = std::numeric_limits<int>::max();
280 Array<int> floodfill_steps(num_verts, 0);
281 std::optional<BMVert *> boundary_initial_vert;
282
283 flood_fill.execute(object, [&](BMVert *from_v, BMVert *to_v) {
284 const int from_v_i = BM_elem_index_get(from_v);
285 const int to_v_i = BM_elem_index_get(to_v);
286
288 return false;
289 }
290
291 floodfill_steps[to_v_i] = floodfill_steps[from_v_i] + 1;
292
293 if (boundary::vert_is_boundary(to_v)) {
294 if (floodfill_steps[to_v_i] < boundary_initial_vert_steps) {
295 boundary_initial_vert_steps = floodfill_steps[to_v_i];
296 boundary_initial_vert = to_v;
297 }
298 }
299
300 const float len_sq = math::distance_squared(initial_vert_position, float3(to_v->co));
301 return len_sq < radius_sq;
302 });
303
304 return boundary_initial_vert;
305}
306
308
309/* -------------------------------------------------------------------- */
312
313/* Used to allocate the memory of the boundary index arrays. This was decided considered the most
314 * common use cases for the brush deformers, taking into account how many vertices those
315 * deformations usually need in the boundary. */
316constexpr int BOUNDARY_INDICES_BLOCK_SIZE = 300;
317
319 const int new_index,
320 const float distance,
322{
323 boundary.verts.append(new_index);
324
325 boundary.distance.add(new_index, distance);
326 included_verts.add(new_index);
327};
328
332static void indices_init_mesh(Object &object,
333 const OffsetIndices<int> faces,
334 const Span<int> corner_verts,
335 const GroupedSpan<int> vert_to_face,
336 const Span<bool> hide_vert,
337 const Span<bool> hide_poly,
338 const BitSpan boundary_verts,
339 const Span<float3> vert_positions,
340 const int initial_boundary_vert,
342{
343 flood_fill::FillDataMesh flood_fill(vert_positions.size());
344
346 add_index(boundary, initial_boundary_vert, 0.0f, included_verts);
347 flood_fill.add_initial(initial_boundary_vert);
348
349 flood_fill.execute(object, vert_to_face, [&](const int from_v, const int to_v) {
350 const float3 from_v_co = vert_positions[from_v];
351 const float3 to_v_co = vert_positions[to_v];
352
353 if (!boundary::vert_is_boundary(vert_to_face, hide_poly, boundary_verts, to_v)) {
354 return false;
355 }
356 const float edge_len = len_v3v3(from_v_co, to_v_co);
357 const float distance_boundary_to_dst = boundary.distance.lookup_default(from_v, 0.0f) +
358 edge_len;
359 add_index(boundary, to_v, distance_boundary_to_dst, included_verts);
360 boundary.edges.append({from_v_co, to_v_co});
362 faces, corner_verts, vert_to_face, hide_vert, hide_poly, boundary_verts, to_v);
363 });
364}
365
366static void indices_init_grids(Object &object,
367 const OffsetIndices<int> faces,
368 const Span<int> corner_verts,
369 const SubdivCCG &subdiv_ccg,
370 const BitSpan boundary_verts,
371 const Set<OrderedEdge> &boundary_edges,
372 const SubdivCCGCoord initial_vert,
374{
375 const Span<float3> positions = subdiv_ccg.positions;
376 const CCGKey key = BKE_subdiv_ccg_key_top_level(subdiv_ccg);
378
379 const int initial_boundary_index = initial_vert.to_index(key);
381 add_index(boundary, initial_boundary_index, 0.0f, included_verts);
382 flood_fill.add_initial(initial_vert);
383
384 flood_fill.execute(
385 object,
386 subdiv_ccg,
387 [&](const SubdivCCGCoord from_v, const SubdivCCGCoord to_v, const bool is_duplicate) {
388 const int from_v_i = from_v.to_index(key);
389 const int to_v_i = to_v.to_index(key);
390
391 const float3 &from_v_co = positions[from_v_i];
392 const float3 &to_v_co = positions[to_v_i];
393
395 faces, corner_verts, boundary_verts, boundary_edges, subdiv_ccg, to_v))
396 {
397 return false;
398 }
399 const float edge_len = len_v3v3(from_v_co, to_v_co);
400 const float distance_boundary_to_dst = boundary.distance.lookup_default(from_v_i, 0.0f) +
401 edge_len;
402 add_index(boundary, to_v_i, distance_boundary_to_dst, included_verts);
403 if (!is_duplicate) {
404 boundary.edges.append({from_v_co, to_v_co});
405 }
407 faces, corner_verts, subdiv_ccg, boundary_verts, boundary_edges, to_v);
408 });
409}
410
411static void indices_init_bmesh(Object &object,
412 BMesh *bm,
413 BMVert &initial_boundary_vert,
415{
416 const int num_verts = BM_mesh_elem_count(bm, BM_VERT);
418
419 const int initial_boundary_index = BM_elem_index_get(&initial_boundary_vert);
421 add_index(boundary, initial_boundary_index, 0.0f, included_verts);
422 flood_fill.add_initial(&initial_boundary_vert);
423
424 flood_fill.execute(object, [&](BMVert *from_v, BMVert *to_v) {
425 const int from_v_i = BM_elem_index_get(from_v);
426 const int to_v_i = BM_elem_index_get(to_v);
427
428 const float3 from_v_co = from_v->co;
429 const float3 to_v_co = to_v->co;
430
431 if (!boundary::vert_is_boundary(to_v)) {
432 return false;
433 }
434 const float edge_len = len_v3v3(from_v_co, to_v_co);
435 const float distance_boundary_to_dst = boundary.distance.lookup_default(from_v_i, 0.0f) +
436 edge_len;
437 add_index(boundary, to_v_i, distance_boundary_to_dst, included_verts);
438 boundary.edges.append({from_v_co, to_v_co});
440 });
441}
442
444
445/* -------------------------------------------------------------------- */
448
449#define BOUNDARY_VERTEX_NONE -1
450#define BOUNDARY_STEPS_NONE -1
451
459 Span<int> corner_verts,
460 GroupedSpan<int> vert_to_face,
461 Span<float3> vert_positions,
462 Span<bool> hide_vert,
463 Span<bool> hide_poly,
464 const int initial_vert_i,
465 const float radius,
467{
468 boundary.edit_info.original_vertex_i = Array<int>(vert_positions.size(), BOUNDARY_VERTEX_NONE);
469 boundary.edit_info.propagation_steps_num = Array<int>(vert_positions.size(),
471 boundary.edit_info.strength_factor = Array<float>(vert_positions.size(), 0.0f);
472
473 std::queue<int> current_iteration;
474
475 for (const int i : boundary.verts.index_range()) {
476 const int vert = boundary.verts[i];
477 const int index = boundary.verts[i];
478
479 boundary.edit_info.original_vertex_i[index] = index;
480 boundary.edit_info.propagation_steps_num[index] = 0;
481
482 current_iteration.push(vert);
483 }
484
485 int propagation_steps_num = 0;
486 float accum_distance = 0.0f;
487
488 std::queue<int> next_iteration;
489
490 while (true) {
491 /* Stop adding steps to edit info. This happens when a steps is further away from the boundary
492 * than the brush radius or when the entire mesh was already processed. */
493 if (accum_distance > radius || current_iteration.empty()) {
494 boundary.max_propagation_steps = propagation_steps_num;
495 break;
496 }
497
498 while (!current_iteration.empty()) {
499 const int from_v = current_iteration.front();
500 current_iteration.pop();
501
502 Vector<int> neighbors;
503 for (const int neighbor : vert_neighbors_get_mesh(
504 faces, corner_verts, vert_to_face, hide_poly, from_v, neighbors))
505 {
506 if ((!hide_vert.is_empty() && hide_vert[from_v]) ||
507 boundary.edit_info.propagation_steps_num[neighbor] != BOUNDARY_STEPS_NONE)
508 {
509 continue;
510 }
511
512 boundary.edit_info.original_vertex_i[neighbor] =
513 boundary.edit_info.original_vertex_i[from_v];
514
515 boundary.edit_info.propagation_steps_num[neighbor] =
516 boundary.edit_info.propagation_steps_num[from_v] + 1;
517
518 next_iteration.push(neighbor);
519
520 /* Check the distance using the vertex that was propagated from the initial vertex that
521 * was used to initialize the boundary. */
522 if (boundary.edit_info.original_vertex_i[from_v] == initial_vert_i) {
523 boundary.pivot_position = vert_positions[neighbor];
524 accum_distance += math::distance(vert_positions[from_v], boundary.pivot_position);
525 }
526 }
527 }
528
529 /* Copy the new vertices to the queue to be processed in the next iteration. */
530 while (!next_iteration.empty()) {
531 const int next_v = next_iteration.front();
532 next_iteration.pop();
533 current_iteration.push(next_v);
534 }
535
536 propagation_steps_num++;
537 }
538}
539
540static void edit_data_init_grids(const SubdivCCG &subdiv_ccg,
541 const int initial_vert_i,
542 const float radius,
544{
545 const Span<float3> positions = subdiv_ccg.positions;
546 const CCGKey key = BKE_subdiv_ccg_key_top_level(subdiv_ccg);
547
548 boundary.edit_info.original_vertex_i = Array<int>(positions.size(), BOUNDARY_VERTEX_NONE);
549 boundary.edit_info.propagation_steps_num = Array<int>(positions.size(), BOUNDARY_STEPS_NONE);
550 boundary.edit_info.strength_factor = Array<float>(positions.size(), 0.0f);
551
552 std::queue<SubdivCCGCoord> current_iteration;
553
554 for (const int i : boundary.verts.index_range()) {
555 const SubdivCCGCoord vert = SubdivCCGCoord::from_index(key, boundary.verts[i]);
556
557 const int index = boundary.verts[i];
558
559 boundary.edit_info.original_vertex_i[index] = index;
560 boundary.edit_info.propagation_steps_num[index] = 0;
561
562 SubdivCCGNeighbors neighbors;
563 BKE_subdiv_ccg_neighbor_coords_get(subdiv_ccg, vert, true, neighbors);
564 for (SubdivCCGCoord neighbor : neighbors.duplicates()) {
565 boundary.edit_info.original_vertex_i[neighbor.to_index(key)] = index;
566 }
567
568 current_iteration.push(vert);
569 }
570
571 int propagation_steps_num = 0;
572 float accum_distance = 0.0f;
573
574 std::queue<SubdivCCGCoord> next_iteration;
575
576 while (true) {
577 /* Stop adding steps to edit info. This happens when a steps is further away from the boundary
578 * than the brush radius or when the entire mesh was already processed. */
579 if (accum_distance > radius || current_iteration.empty()) {
580 boundary.max_propagation_steps = propagation_steps_num;
581 break;
582 }
583
584 while (!current_iteration.empty()) {
585 const SubdivCCGCoord from_v = current_iteration.front();
586 current_iteration.pop();
587
588 const int from_v_i = from_v.to_index(key);
589
590 SubdivCCGNeighbors neighbors;
591 BKE_subdiv_ccg_neighbor_coords_get(subdiv_ccg, from_v, true, neighbors);
592
593 for (const SubdivCCGCoord neighbor : neighbors.duplicates()) {
594 const int neighbor_idx = neighbor.to_index(key);
595 const int index_in_grid = CCG_grid_xy_to_index(key.grid_size, neighbor.x, neighbor.y);
596
597 const bool is_hidden = !subdiv_ccg.grid_hidden.is_empty() &&
598 subdiv_ccg.grid_hidden[neighbor.grid_index][index_in_grid];
599 if (is_hidden ||
600 boundary.edit_info.propagation_steps_num[neighbor_idx] != BOUNDARY_STEPS_NONE)
601 {
602 continue;
603 }
604 boundary.edit_info.original_vertex_i[neighbor_idx] =
605 boundary.edit_info.original_vertex_i[from_v_i];
606
607 boundary.edit_info.propagation_steps_num[neighbor_idx] =
608 boundary.edit_info.propagation_steps_num[from_v_i];
609 }
610
611 for (const SubdivCCGCoord neighbor : neighbors.unique()) {
612 const int neighbor_idx = neighbor.to_index(key);
613 const int index_in_grid = CCG_grid_xy_to_index(key.grid_size, neighbor.x, neighbor.y);
614
615 const bool is_hidden = !subdiv_ccg.grid_hidden.is_empty() &&
616 subdiv_ccg.grid_hidden[neighbor.grid_index][index_in_grid];
617 if (is_hidden ||
618 boundary.edit_info.propagation_steps_num[neighbor_idx] != BOUNDARY_STEPS_NONE)
619 {
620 continue;
621 }
622 boundary.edit_info.original_vertex_i[neighbor_idx] =
623 boundary.edit_info.original_vertex_i[from_v_i];
624
625 boundary.edit_info.propagation_steps_num[neighbor_idx] =
626 boundary.edit_info.propagation_steps_num[from_v_i] + 1;
627
628 next_iteration.push(neighbor);
629
630 /* When copying the data to the neighbor for the next iteration, it has to be copied to
631 * all its duplicates too. This is because it is not possible to know if the updated
632 * neighbor or one if its uninitialized duplicates is going to come first in order to
633 * copy the data in the from_v neighbor iterator. */
634
635 SubdivCCGNeighbors neighbor_duplicates;
636 BKE_subdiv_ccg_neighbor_coords_get(subdiv_ccg, neighbor, true, neighbor_duplicates);
637
638 for (const SubdivCCGCoord coord : neighbor_duplicates.duplicates()) {
639 const int neighbor_duplicate_index = coord.to_index(key);
640 boundary.edit_info.original_vertex_i[neighbor_duplicate_index] =
641 boundary.edit_info.original_vertex_i[from_v_i];
642 boundary.edit_info.propagation_steps_num[neighbor_duplicate_index] =
643 boundary.edit_info.propagation_steps_num[from_v_i] + 1;
644 }
645
646 /* Check the distance using the vertex that was propagated from the initial vertex that
647 * was used to initialize the boundary. */
648 if (boundary.edit_info.original_vertex_i[from_v_i] == initial_vert_i) {
649 boundary.pivot_position = positions[neighbor_idx];
650 accum_distance += math::distance(positions[from_v_i], boundary.pivot_position);
651 }
652 }
653 }
654
655 /* Copy the new vertices to the queue to be processed in the next iteration. */
656 while (!next_iteration.empty()) {
657 const SubdivCCGCoord next_v = next_iteration.front();
658 next_iteration.pop();
659 current_iteration.push(next_v);
660 }
661
662 propagation_steps_num++;
663 }
664}
665
667 const int initial_vert_i,
668 const float radius,
670{
671 const int num_verts = BM_mesh_elem_count(bm, BM_VERT);
672
673 boundary.edit_info.original_vertex_i = Array<int>(num_verts, BOUNDARY_VERTEX_NONE);
674 boundary.edit_info.propagation_steps_num = Array<int>(num_verts, BOUNDARY_STEPS_NONE);
675 boundary.edit_info.strength_factor = Array<float>(num_verts, 0.0f);
676
677 std::queue<BMVert *> current_iteration;
678
679 for (const int i : boundary.verts.index_range()) {
680 const int index = boundary.verts[i];
682
683 boundary.edit_info.original_vertex_i[index] = index;
684 boundary.edit_info.propagation_steps_num[index] = 0;
685
686 /* This ensures that all duplicate vertices in the boundary have the same original_vertex
687 * index, so the deformation for them will be the same. */
688 current_iteration.push(vert);
689 }
690
691 int propagation_steps_num = 0;
692 float accum_distance = 0.0f;
693
694 std::queue<BMVert *> next_iteration;
695
696 while (true) {
697 /* Stop adding steps to edit info. This happens when a steps is further away from the boundary
698 * than the brush radius or when the entire mesh was already processed. */
699 if (accum_distance > radius || current_iteration.empty()) {
700 boundary.max_propagation_steps = propagation_steps_num;
701 break;
702 }
703
704 while (!current_iteration.empty()) {
705 BMVert *from_v = current_iteration.front();
706 current_iteration.pop();
707
708 const int from_v_i = BM_elem_index_get(from_v);
709
710 BMeshNeighborVerts neighbors;
711 for (BMVert *neighbor : vert_neighbors_get_bmesh(*from_v, neighbors)) {
712 const int neighbor_idx = BM_elem_index_get(neighbor);
713 if (BM_elem_flag_test(neighbor, BM_ELEM_HIDDEN) ||
714 boundary.edit_info.propagation_steps_num[neighbor_idx] != BOUNDARY_STEPS_NONE)
715 {
716 continue;
717 }
718 boundary.edit_info.original_vertex_i[neighbor_idx] =
719 boundary.edit_info.original_vertex_i[from_v_i];
720
721 boundary.edit_info.propagation_steps_num[neighbor_idx] =
722 boundary.edit_info.propagation_steps_num[from_v_i] + 1;
723
724 next_iteration.push(neighbor);
725
726 /* Check the distance using the vertex that was propagated from the initial vertex that
727 * was used to initialize the boundary. */
728 if (boundary.edit_info.original_vertex_i[from_v_i] == initial_vert_i) {
729 boundary.pivot_position = neighbor->co;
730 accum_distance += math::distance(float3(from_v->co), boundary.pivot_position);
731 }
732 }
733 }
734
735 /* Copy the new vertices to the queue to be processed in the next iteration. */
736 while (!next_iteration.empty()) {
737 BMVert *next_v = next_iteration.front();
738 next_iteration.pop();
739 current_iteration.push(next_v);
740 }
741
742 propagation_steps_num++;
743 }
744}
745
747
748/* -------------------------------------------------------------------- */
753
754/* These functions initialize the required vectors for the desired deformation using the
755 * SculptBoundaryEditInfo. They calculate the data using the vertices that have the
756 * max_propagation_steps value and them this data is copied to the rest of the vertices using the
757 * original vertex index. */
758static void bend_data_init_mesh(const Span<float3> vert_positions,
759 const Span<float3> vert_normals,
761{
762 BLI_assert(boundary.edit_info.original_vertex_i.size() ==
763 boundary.edit_info.propagation_steps_num.size());
764 BLI_assert(boundary.edit_info.original_vertex_i.size() ==
765 boundary.edit_info.strength_factor.size());
766
767 const int num_elements = boundary.edit_info.strength_factor.size();
768
769 boundary.bend.pivot_rotation_axis = Array<float3>(num_elements, float3(0));
770 boundary.bend.pivot_positions = Array<float3>(num_elements, float3(0));
771
772 for (const int i : IndexRange(num_elements)) {
773 if (boundary.edit_info.propagation_steps_num[i] != boundary.max_propagation_steps) {
774 continue;
775 }
776
777 const int orig_vert_i = boundary.edit_info.original_vertex_i[i];
778
779 const float3 normal = vert_normals[i];
780 const float3 dir = vert_positions[orig_vert_i] - vert_positions[i];
781 boundary.bend.pivot_rotation_axis[orig_vert_i] = math::normalize(math::cross(dir, normal));
782 boundary.bend.pivot_positions[orig_vert_i] = vert_positions[i];
783 }
784
785 for (const int i : IndexRange(num_elements)) {
786 if (boundary.edit_info.propagation_steps_num[i] == BOUNDARY_STEPS_NONE) {
787 continue;
788 }
789 const int orig_vert_i = boundary.edit_info.original_vertex_i[i];
790
791 boundary.bend.pivot_positions[i] = boundary.bend.pivot_positions[orig_vert_i];
792 boundary.bend.pivot_rotation_axis[i] = boundary.bend.pivot_rotation_axis[orig_vert_i];
793 }
794}
795
797{
798 BLI_assert(boundary.edit_info.original_vertex_i.size() ==
799 boundary.edit_info.propagation_steps_num.size());
800 BLI_assert(boundary.edit_info.original_vertex_i.size() ==
801 boundary.edit_info.strength_factor.size());
802
803 const int num_elements = boundary.edit_info.strength_factor.size();
804
805 const Span<float3> positions = subdiv_ccg.positions;
806 const Span<float3> normals = subdiv_ccg.normals;
807
808 boundary.bend.pivot_rotation_axis = Array<float3>(num_elements, float3(0));
809 boundary.bend.pivot_positions = Array<float3>(num_elements, float3(0));
810
811 for (const int i : IndexRange(num_elements)) {
812 if (boundary.edit_info.propagation_steps_num[i] != boundary.max_propagation_steps) {
813 continue;
814 }
815
816 const int orig_vert_i = boundary.edit_info.original_vertex_i[i];
817
818 const float3 normal = normals[i];
819 const float3 dir = positions[orig_vert_i] - positions[i];
820 boundary.bend.pivot_rotation_axis[orig_vert_i] = math::normalize(math::cross(dir, normal));
821 boundary.bend.pivot_positions[orig_vert_i] = positions[i];
822 }
823
824 for (const int i : IndexRange(num_elements)) {
825 if (boundary.edit_info.propagation_steps_num[i] == BOUNDARY_STEPS_NONE) {
826 continue;
827 }
828 const int orig_vert_i = boundary.edit_info.original_vertex_i[i];
829
830 boundary.bend.pivot_positions[i] = boundary.bend.pivot_positions[orig_vert_i];
831 boundary.bend.pivot_rotation_axis[i] = boundary.bend.pivot_rotation_axis[orig_vert_i];
832 }
833}
834
836{
837 BLI_assert(boundary.edit_info.original_vertex_i.size() ==
838 boundary.edit_info.propagation_steps_num.size());
839 BLI_assert(boundary.edit_info.original_vertex_i.size() ==
840 boundary.edit_info.strength_factor.size());
841
842 const int num_elements = boundary.edit_info.strength_factor.size();
843
844 boundary.bend.pivot_rotation_axis = Array<float3>(num_elements, float3(0));
845 boundary.bend.pivot_positions = Array<float3>(num_elements, float3(0));
846
847 for (const int i : IndexRange(num_elements)) {
848 if (boundary.edit_info.propagation_steps_num[i] != boundary.max_propagation_steps) {
849 continue;
850 }
851
852 BMVert *vert = BM_vert_at_index(bm, i);
853 const int orig_vert_i = boundary.edit_info.original_vertex_i[i];
854 BMVert *orig_vert = BM_vert_at_index(bm, orig_vert_i);
855
856 const float3 normal = vert->no;
857 const float3 dir = float3(orig_vert->co) - float3(vert->co);
858 boundary.bend.pivot_rotation_axis[orig_vert_i] = math::normalize(math::cross(dir, normal));
859 boundary.bend.pivot_positions[boundary.edit_info.original_vertex_i[i]] = vert->co;
860 }
861
862 for (const int i : IndexRange(num_elements)) {
863 if (boundary.edit_info.propagation_steps_num[i] == BOUNDARY_STEPS_NONE) {
864 continue;
865 }
866 const int orig_vert_i = boundary.edit_info.original_vertex_i[i];
867 boundary.bend.pivot_positions[i] = boundary.bend.pivot_positions[orig_vert_i];
868 boundary.bend.pivot_rotation_axis[i] = boundary.bend.pivot_rotation_axis[orig_vert_i];
869 }
870}
871
872static void slide_data_init_mesh(const Span<float3> vert_positions, SculptBoundary &boundary)
873{
874 BLI_assert(boundary.edit_info.original_vertex_i.size() ==
875 boundary.edit_info.propagation_steps_num.size());
876 BLI_assert(boundary.edit_info.original_vertex_i.size() ==
877 boundary.edit_info.strength_factor.size());
878
879 const int num_elements = boundary.edit_info.strength_factor.size();
880 boundary.slide.directions = Array<float3>(num_elements, float3(0));
881
882 for (const int i : IndexRange(num_elements)) {
883 if (boundary.edit_info.propagation_steps_num[i] != boundary.max_propagation_steps) {
884 continue;
885 }
886 const int orig_vert_i = boundary.edit_info.original_vertex_i[i];
887 boundary.slide.directions[orig_vert_i] = math::normalize(vert_positions[orig_vert_i] -
888 vert_positions[i]);
889 }
890
891 for (const int i : IndexRange(num_elements)) {
892 if (boundary.edit_info.propagation_steps_num[i] == BOUNDARY_STEPS_NONE) {
893 continue;
894 }
895 boundary.slide.directions[i] =
896 boundary.slide.directions[boundary.edit_info.original_vertex_i[i]];
897 }
898}
899
901{
902 BLI_assert(boundary.edit_info.original_vertex_i.size() ==
903 boundary.edit_info.propagation_steps_num.size());
904 BLI_assert(boundary.edit_info.original_vertex_i.size() ==
905 boundary.edit_info.strength_factor.size());
906
907 const int num_elements = boundary.edit_info.strength_factor.size();
908 const Span<float3> positions = subdiv_ccg.positions;
909
910 boundary.slide.directions = Array<float3>(num_elements, float3(0));
911
912 for (const int i : IndexRange(num_elements)) {
913 if (boundary.edit_info.propagation_steps_num[i] != boundary.max_propagation_steps) {
914 continue;
915 }
916 const int orig_vert_i = boundary.edit_info.original_vertex_i[i];
917
918 boundary.slide.directions[orig_vert_i] = math::normalize(positions[orig_vert_i] -
919 positions[i]);
920 }
921
922 for (const int i : IndexRange(num_elements)) {
923 if (boundary.edit_info.propagation_steps_num[i] == BOUNDARY_STEPS_NONE) {
924 continue;
925 }
926 boundary.slide.directions[i] =
927 boundary.slide.directions[boundary.edit_info.original_vertex_i[i]];
928 }
929}
930
932{
933 BLI_assert(boundary.edit_info.original_vertex_i.size() ==
934 boundary.edit_info.propagation_steps_num.size());
935 BLI_assert(boundary.edit_info.original_vertex_i.size() ==
936 boundary.edit_info.strength_factor.size());
937
938 const int num_elements = boundary.edit_info.strength_factor.size();
939 boundary.slide.directions = Array<float3>(num_elements, float3(0));
940
941 for (const int i : IndexRange(num_elements)) {
942 if (boundary.edit_info.propagation_steps_num[i] != boundary.max_propagation_steps) {
943 continue;
944 }
945 BMVert *vert = BM_vert_at_index(bm, i);
946 const int orig_vert_i = boundary.edit_info.original_vertex_i[i];
947 BMVert *orig_vert = BM_vert_at_index(bm, orig_vert_i);
948 boundary.slide.directions[orig_vert_i] = math::normalize(float3(orig_vert->co) -
949 float3(vert->co));
950 }
951
952 for (const int i : IndexRange(num_elements)) {
953 if (boundary.edit_info.propagation_steps_num[i] == BOUNDARY_STEPS_NONE) {
954 continue;
955 }
956 boundary.slide.directions[i] =
957 boundary.slide.directions[boundary.edit_info.original_vertex_i[i]];
958 }
959}
960
962{
963 boundary.twist.pivot_position = float3(0);
964 for (const float3 &position : positions) {
965 boundary.twist.pivot_position += position;
966 }
967 boundary.twist.pivot_position *= 1.0f / boundary.verts.size();
968 boundary.twist.rotation_axis = math::normalize(boundary.pivot_position -
969 boundary.initial_vert_position);
970}
971
972static void twist_data_init_mesh(const Span<float3> vert_positions, SculptBoundary &boundary)
973{
974 Array<float3> positions(boundary.verts.size());
975 array_utils::gather(vert_positions, boundary.verts.as_span(), positions.as_mutable_span());
976 populate_twist_data(positions, boundary);
977}
978
980{
981 const Span<float3> vert_positions = subdiv_ccg.positions;
982 Array<float3> positions(boundary.verts.size());
983 array_utils::gather(vert_positions, boundary.verts.as_span(), positions.as_mutable_span());
984 populate_twist_data(positions, boundary);
985}
986
988{
989 Array<float3> positions(boundary.verts.size());
990 for (const int i : positions.index_range()) {
991 BMVert *vert = BM_vert_at_index(bm, i);
992 positions[i] = vert->co;
993 }
994 populate_twist_data(positions, boundary);
995}
996
998
999/* -------------------------------------------------------------------- */
1002
1003BLI_NOINLINE static void filter_uninitialized_verts(const Span<int> propagation_steps,
1004 const MutableSpan<float> factors)
1005{
1006 BLI_assert(propagation_steps.size() == factors.size());
1007
1008 for (const int i : factors.index_range()) {
1009 if (propagation_steps[i] == BOUNDARY_STEPS_NONE) {
1010 factors[i] = 0.0f;
1011 }
1012 }
1013}
1014
1019
1042
1065
1067
1068/* -------------------------------------------------------------------- */
1071
1073 const Span<float3> pivot_positions,
1074 const Span<float3> pivot_axes,
1075 const Span<float> factors,
1076 const MutableSpan<float3> new_positions)
1077{
1078 BLI_assert(positions.size() == pivot_positions.size());
1079 BLI_assert(positions.size() == pivot_axes.size());
1080 BLI_assert(positions.size() == factors.size());
1081 BLI_assert(positions.size() == new_positions.size());
1082
1083 for (const int i : positions.index_range()) {
1084 float3 from_pivot_to_pos = positions[i] - pivot_positions[i];
1085 float3 rotated;
1086 rotate_v3_v3v3fl(rotated, from_pivot_to_pos, pivot_axes[i], factors[i]);
1087 new_positions[i] = rotated + pivot_positions[i];
1088 }
1089}
1090
1091static void calc_bend_mesh(const Depsgraph &depsgraph,
1092 const Sculpt &sd,
1093 Object &object,
1094 const Span<int> vert_propagation_steps,
1095 const Span<float> vert_factors,
1096 const Span<float3> vert_pivot_positions,
1097 const Span<float3> vert_pivot_axes,
1099 const float3 symmetry_pivot,
1100 const float strength,
1101 const eBrushDeformTarget deform_target,
1102 const PositionDeformData &position_data)
1103{
1104 SculptSession &ss = *object.runtime->sculpt_session;
1105 const StrokeCache &cache = *ss.cache;
1106
1107 const Span<int> verts = node.verts();
1108 const OrigPositionData orig_data = orig_position_data_get_mesh(object, node);
1109
1110 const ePaintSymmetryFlags symm = mesh_symmetry_xyz_get(object);
1111
1113 gather_data_mesh(vert_factors, verts, factors.as_mutable_span());
1114
1115 auto_mask::calc_vert_factors(depsgraph, object, cache.automasking.get(), node, verts, factors);
1116
1117 Array<int, bke::pbvh::MESH_LEAF_LIMIT> propagation_steps(verts.size());
1118 gather_data_mesh(vert_propagation_steps, verts, propagation_steps.as_mutable_span());
1119
1120 filter_uninitialized_verts(propagation_steps, factors);
1121 filter_verts_outside_symmetry_area(orig_data.positions, symmetry_pivot, symm, factors);
1122
1123 scale_factors(factors, strength);
1124
1125 Array<float3, bke::pbvh::MESH_LEAF_LIMIT> pivot_positions(verts.size());
1126 gather_data_mesh(vert_pivot_positions, verts, pivot_positions.as_mutable_span());
1128 gather_data_mesh(vert_pivot_axes, verts, pivot_axes.as_mutable_span());
1129
1130 Array<float3, bke::pbvh::MESH_LEAF_LIMIT> new_positions(verts.size());
1131 calc_bend_position(orig_data.positions, pivot_positions, pivot_axes, factors, new_positions);
1132
1133 switch (eBrushDeformTarget(deform_target)) {
1135 Array<float3, bke::pbvh::MESH_LEAF_LIMIT> translations(verts.size());
1136 translations_from_new_positions(new_positions, verts, position_data.eval, translations);
1137 filter_translations(translations, factors);
1138 clip_and_lock_translations(sd, ss, position_data.eval, verts, translations);
1139 position_data.deform(translations, verts);
1140 break;
1141 }
1144 new_positions.as_span(), verts, cache.cloth_sim->deformation_pos.as_mutable_span());
1145 break;
1146 }
1147}
1148
1149static void calc_bend_grids(const Depsgraph &depsgraph,
1150 const Sculpt &sd,
1151 Object &object,
1152 SubdivCCG &subdiv_ccg,
1153 const Span<int> vert_propagation_steps,
1154 const Span<float> vert_factors,
1155 const Span<float3> vert_pivot_positions,
1156 const Span<float3> vert_pivot_axes,
1158 LocalDataGrids &tls,
1159 const float3 symmetry_pivot,
1160 const float strength,
1161 const eBrushDeformTarget deform_target)
1162{
1163 SculptSession &ss = *object.runtime->sculpt_session;
1164 const StrokeCache &cache = *ss.cache;
1165 const CCGKey key = BKE_subdiv_ccg_key_top_level(subdiv_ccg);
1166
1167 const Span<int> grids = node.grids();
1168 const int grid_verts_num = grids.size() * key.grid_area;
1169 const OrigPositionData orig_data = orig_position_data_get_grids(object, node);
1170
1171 const ePaintSymmetryFlags symm = mesh_symmetry_xyz_get(object);
1172
1173 const MutableSpan<float> factors = gather_data_grids(
1174 subdiv_ccg, vert_factors, grids, tls.factors);
1175
1176 auto_mask::calc_grids_factors(depsgraph, object, cache.automasking.get(), node, grids, factors);
1177
1178 const Span<int> propagation_steps = gather_data_grids(
1179 subdiv_ccg, vert_propagation_steps, grids, tls.propagation_steps);
1180
1181 filter_uninitialized_verts(propagation_steps, factors);
1182 filter_verts_outside_symmetry_area(orig_data.positions, symmetry_pivot, symm, factors);
1183
1184 scale_factors(factors, strength);
1185
1186 const Span<float3> pivot_positions = gather_data_grids(
1187 subdiv_ccg, vert_pivot_positions, grids, tls.pivot_positions);
1188 const Span<float3> pivot_axes = gather_data_grids(
1189 subdiv_ccg, vert_pivot_axes, grids, tls.pivot_axes);
1190
1191 tls.new_positions.resize(grid_verts_num);
1192 const MutableSpan<float3> new_positions = tls.new_positions;
1193 calc_bend_position(orig_data.positions, pivot_positions, pivot_axes, factors, new_positions);
1194
1195 switch (eBrushDeformTarget(deform_target)) {
1197 tls.translations.resize(grid_verts_num);
1198 const MutableSpan<float3> translations = tls.translations;
1199 const Span<float3> positions = gather_grids_positions(subdiv_ccg, grids, tls.positions);
1200 translations_from_new_positions(new_positions, positions, translations);
1201 filter_translations(translations, factors);
1202
1203 clip_and_lock_translations(sd, ss, orig_data.positions, translations);
1204 apply_translations(translations, grids, subdiv_ccg);
1205 break;
1206 }
1208 scatter_data_grids(subdiv_ccg,
1209 new_positions.as_span(),
1210 grids,
1211 cache.cloth_sim->deformation_pos.as_mutable_span());
1212 break;
1213 }
1214}
1215
1216static void calc_bend_bmesh(const Depsgraph &depsgraph,
1217 const Sculpt &sd,
1218 Object &object,
1219 const Span<int> vert_propagation_steps,
1220 const Span<float> vert_factors,
1221 const Span<float3> vert_pivot_positions,
1222 const Span<float3> vert_pivot_axes,
1224 LocalDataBMesh &tls,
1225 const float3 symmetry_pivot,
1226 const float strength,
1227 const eBrushDeformTarget deform_target)
1228
1229{
1230 SculptSession &ss = *object.runtime->sculpt_session;
1231 const StrokeCache &cache = *ss.cache;
1232
1234 Array<float3> orig_positions(verts.size());
1235 Array<float3> orig_normals(verts.size());
1236 orig_position_data_gather_bmesh(*ss.bm_log, verts, orig_positions, orig_normals);
1237
1238 const ePaintSymmetryFlags symm = mesh_symmetry_xyz_get(object);
1239
1240 const MutableSpan<float> factors = gather_data_bmesh(vert_factors, verts, tls.factors);
1241
1242 auto_mask::calc_vert_factors(depsgraph, object, cache.automasking.get(), node, verts, factors);
1243
1244 const Span<int> propagation_steps = gather_data_bmesh(
1245 vert_propagation_steps, verts, tls.propagation_steps);
1246
1247 filter_uninitialized_verts(propagation_steps, factors);
1248 filter_verts_outside_symmetry_area(orig_positions, symmetry_pivot, symm, factors);
1249
1250 scale_factors(factors, strength);
1251
1252 const Span<float3> pivot_positions = gather_data_bmesh(
1253 vert_pivot_positions, verts, tls.pivot_positions);
1254 const Span<float3> pivot_axes = gather_data_bmesh(vert_pivot_axes, verts, tls.pivot_axes);
1255
1256 tls.new_positions.resize(verts.size());
1257 const MutableSpan<float3> new_positions = tls.new_positions;
1258 calc_bend_position(orig_positions, pivot_positions, pivot_axes, factors, new_positions);
1259
1260 switch (eBrushDeformTarget(deform_target)) {
1262 const MutableSpan<float3> positions = gather_bmesh_positions(verts, tls.positions);
1263 tls.translations.resize(verts.size());
1264 const MutableSpan<float3> translations = tls.translations;
1265 translations_from_new_positions(new_positions, positions, translations);
1266 filter_translations(translations, factors);
1267
1268 clip_and_lock_translations(sd, ss, orig_positions, translations);
1269 apply_translations(translations, verts);
1270 break;
1271 }
1274 new_positions.as_span(), verts, cache.cloth_sim->deformation_pos.as_mutable_span());
1275 break;
1276 }
1277}
1278
1279static void do_bend_brush(const Depsgraph &depsgraph,
1280 const Sculpt &sd,
1281 Object &object,
1282 const IndexMask &node_mask,
1283 const SculptBoundary &boundary,
1284 const float strength,
1285 const eBrushDeformTarget deform_target)
1286{
1288 switch (pbvh.type()) {
1289 case bke::pbvh::Type::Mesh: {
1290 const PositionDeformData position_data(depsgraph, object);
1291
1293 node_mask.foreach_index(
1294 [&](const int i) {
1295 calc_bend_mesh(depsgraph,
1296 sd,
1297 object,
1298 boundary.edit_info.propagation_steps_num,
1299 boundary.edit_info.strength_factor,
1300 boundary.bend.pivot_positions,
1301 boundary.bend.pivot_rotation_axis,
1302 nodes[i],
1303 boundary.initial_vert_position,
1304 strength,
1305 deform_target,
1306 position_data);
1307 bke::pbvh::update_node_bounds_mesh(position_data.eval, nodes[i]);
1308 },
1310 break;
1311 }
1313 SubdivCCG &subdiv_ccg = *object.runtime->sculpt_session->subdiv_ccg;
1314 MutableSpan<float3> positions = subdiv_ccg.positions;
1317 node_mask.foreach_index(
1318 [&](const int i) {
1319 LocalDataGrids &tls = all_tls.local();
1320 calc_bend_grids(depsgraph,
1321 sd,
1322 object,
1323 subdiv_ccg,
1324 boundary.edit_info.propagation_steps_num,
1325 boundary.edit_info.strength_factor,
1326 boundary.bend.pivot_positions,
1327 boundary.bend.pivot_rotation_axis,
1328 nodes[i],
1329 tls,
1330 boundary.initial_vert_position,
1331 strength,
1332 deform_target);
1333 bke::pbvh::update_node_bounds_grids(subdiv_ccg.grid_area, positions, nodes[i]);
1334 },
1336 break;
1337 }
1341 node_mask.foreach_index(
1342 [&](const int i) {
1343 LocalDataBMesh &tls = all_tls.local();
1344 calc_bend_bmesh(depsgraph,
1345 sd,
1346 object,
1347 boundary.edit_info.propagation_steps_num,
1348 boundary.edit_info.strength_factor,
1349 boundary.bend.pivot_positions,
1350 boundary.bend.pivot_rotation_axis,
1351 nodes[i],
1352 tls,
1353 boundary.initial_vert_position,
1354 strength,
1355 deform_target);
1357 },
1359 break;
1360 }
1361 }
1362 pbvh.tag_positions_changed(node_mask);
1363 pbvh.flush_bounds_to_parents();
1364}
1365
1367
1368/* -------------------------------------------------------------------- */
1371
1373 const Span<float3> directions,
1374 const Span<float> factors,
1375 const MutableSpan<float3> new_positions)
1376{
1377 BLI_assert(positions.size() == directions.size());
1378 BLI_assert(positions.size() == factors.size());
1379 BLI_assert(positions.size() == new_positions.size());
1380
1381 for (const int i : positions.index_range()) {
1382 new_positions[i] = positions[i] + (directions[i] * factors[i]);
1383 }
1384}
1385
1386static void calc_slide_mesh(const Depsgraph &depsgraph,
1387 const Sculpt &sd,
1388 Object &object,
1389 const Span<int> vert_propagation_steps,
1390 const Span<float> vert_factors,
1391 const Span<float3> vert_slide_directions,
1393 const float3 symmetry_pivot,
1394 const float strength,
1395 const eBrushDeformTarget deform_target,
1396 const PositionDeformData &position_data)
1397{
1398 SculptSession &ss = *object.runtime->sculpt_session;
1399 const StrokeCache &cache = *ss.cache;
1400
1401 const Span<int> verts = node.verts();
1402 const OrigPositionData orig_data = orig_position_data_get_mesh(object, node);
1403
1404 const ePaintSymmetryFlags symm = mesh_symmetry_xyz_get(object);
1405
1407 gather_data_mesh(vert_factors, verts, factors.as_mutable_span());
1408
1409 auto_mask::calc_vert_factors(depsgraph, object, cache.automasking.get(), node, verts, factors);
1410
1411 Array<int, bke::pbvh::MESH_LEAF_LIMIT> propagation_steps(verts.size());
1412 gather_data_mesh(vert_propagation_steps, verts, propagation_steps.as_mutable_span());
1413
1414 filter_uninitialized_verts(propagation_steps, factors);
1415 filter_verts_outside_symmetry_area(orig_data.positions, symmetry_pivot, symm, factors);
1416
1417 scale_factors(factors, strength);
1418
1419 Array<float3, bke::pbvh::MESH_LEAF_LIMIT> slide_directions(verts.size());
1420 gather_data_mesh(vert_slide_directions, verts, slide_directions.as_mutable_span());
1421
1422 Array<float3, bke::pbvh::MESH_LEAF_LIMIT> new_positions(verts.size());
1423 calc_slide_position(orig_data.positions, slide_directions, factors, new_positions);
1424
1425 switch (eBrushDeformTarget(deform_target)) {
1427 Array<float3, bke::pbvh::MESH_LEAF_LIMIT> translations(verts.size());
1428 translations_from_new_positions(new_positions, verts, position_data.eval, translations);
1429 filter_translations(translations, factors);
1430 clip_and_lock_translations(sd, ss, position_data.eval, verts, translations);
1431 position_data.deform(translations, verts);
1432 break;
1433 }
1436 new_positions.as_span(), verts, cache.cloth_sim->deformation_pos.as_mutable_span());
1437 break;
1438 }
1439}
1440
1441static void calc_slide_grids(const Depsgraph &depsgraph,
1442 const Sculpt &sd,
1443 Object &object,
1444 SubdivCCG &subdiv_ccg,
1445 const Span<int> vert_propagation_steps,
1446 const Span<float> vert_factors,
1447 const Span<float3> vert_slide_directions,
1449 LocalDataGrids &tls,
1450 const float3 symmetry_pivot,
1451 const float strength,
1452 const eBrushDeformTarget deform_target)
1453{
1454 SculptSession &ss = *object.runtime->sculpt_session;
1455 const StrokeCache &cache = *ss.cache;
1456 const CCGKey key = BKE_subdiv_ccg_key_top_level(subdiv_ccg);
1457
1458 const Span<int> grids = node.grids();
1459 const int grid_verts_num = grids.size() * key.grid_area;
1460 const OrigPositionData orig_data = orig_position_data_get_grids(object, node);
1461
1462 const ePaintSymmetryFlags symm = mesh_symmetry_xyz_get(object);
1463
1464 const MutableSpan<float> factors = gather_data_grids(
1465 subdiv_ccg, vert_factors, grids, tls.factors);
1466
1467 auto_mask::calc_grids_factors(depsgraph, object, cache.automasking.get(), node, grids, factors);
1468
1469 const Span<int> propagation_steps = gather_data_grids(
1470 subdiv_ccg, vert_propagation_steps, grids, tls.propagation_steps);
1471
1472 filter_uninitialized_verts(propagation_steps, factors);
1473 filter_verts_outside_symmetry_area(orig_data.positions, symmetry_pivot, symm, factors);
1474
1475 scale_factors(factors, strength);
1476
1477 tls.new_positions.resize(grid_verts_num);
1478 const MutableSpan<float3> new_positions = tls.new_positions;
1479
1480 const Span<float3> slide_directions = gather_data_grids(
1481 subdiv_ccg, vert_slide_directions, grids, tls.pivot_positions);
1482
1483 calc_slide_position(orig_data.positions, slide_directions, factors, new_positions);
1484
1485 switch (eBrushDeformTarget(deform_target)) {
1487 tls.translations.resize(grid_verts_num);
1488 const MutableSpan<float3> translations = tls.translations;
1489 const Span<float3> positions = gather_grids_positions(subdiv_ccg, grids, tls.positions);
1490 translations_from_new_positions(new_positions, positions, translations);
1491 filter_translations(translations, factors);
1492
1493 clip_and_lock_translations(sd, ss, orig_data.positions, translations);
1494 apply_translations(translations, grids, subdiv_ccg);
1495 break;
1496 }
1498 scatter_data_grids(subdiv_ccg,
1499 new_positions.as_span(),
1500 grids,
1501 cache.cloth_sim->deformation_pos.as_mutable_span());
1502 break;
1503 }
1504}
1505
1506static void calc_slide_bmesh(const Depsgraph &depsgraph,
1507 const Sculpt &sd,
1508 Object &object,
1509 const Span<int> vert_propagation_steps,
1510 const Span<float> vert_factors,
1511 const Span<float3> vert_slide_directions,
1513 LocalDataBMesh &tls,
1514 const float3 symmetry_pivot,
1515 const float strength,
1516 const eBrushDeformTarget deform_target)
1517
1518{
1519 SculptSession &ss = *object.runtime->sculpt_session;
1520 const StrokeCache &cache = *ss.cache;
1521
1523 Array<float3> orig_positions(verts.size());
1524 Array<float3> orig_normals(verts.size());
1525 orig_position_data_gather_bmesh(*ss.bm_log, verts, orig_positions, orig_normals);
1526
1527 const ePaintSymmetryFlags symm = mesh_symmetry_xyz_get(object);
1528
1529 const MutableSpan<float> factors = gather_data_bmesh(vert_factors, verts, tls.factors);
1530
1531 auto_mask::calc_vert_factors(depsgraph, object, cache.automasking.get(), node, verts, factors);
1532
1533 const Span<int> propagation_steps = gather_data_bmesh(
1534 vert_propagation_steps, verts, tls.propagation_steps);
1535
1536 filter_uninitialized_verts(propagation_steps, factors);
1537 filter_verts_outside_symmetry_area(orig_positions, symmetry_pivot, symm, factors);
1538
1539 scale_factors(factors, strength);
1540
1541 const Span<float3> slide_directions = gather_data_bmesh(
1542 vert_slide_directions, verts, tls.pivot_positions);
1543
1544 tls.new_positions.resize(verts.size());
1545 const MutableSpan<float3> new_positions = tls.new_positions;
1546 calc_slide_position(orig_positions, slide_directions, factors, new_positions);
1547
1548 switch (eBrushDeformTarget(deform_target)) {
1550 const MutableSpan<float3> positions = gather_bmesh_positions(verts, tls.positions);
1551 tls.translations.resize(verts.size());
1552 const MutableSpan<float3> translations = tls.translations;
1553 translations_from_new_positions(new_positions, positions, translations);
1554 filter_translations(translations, factors);
1555
1556 clip_and_lock_translations(sd, ss, orig_positions, translations);
1557 apply_translations(translations, verts);
1558 break;
1559 }
1562 new_positions.as_span(), verts, cache.cloth_sim->deformation_pos.as_mutable_span());
1563 break;
1564 }
1565}
1566
1567static void do_slide_brush(const Depsgraph &depsgraph,
1568 const Sculpt &sd,
1569 Object &object,
1570 const IndexMask &node_mask,
1571 const SculptBoundary &boundary,
1572 const float strength,
1573 const eBrushDeformTarget deform_target)
1574{
1576 switch (pbvh.type()) {
1577 case bke::pbvh::Type::Mesh: {
1578 const PositionDeformData position_data(depsgraph, object);
1579
1581 node_mask.foreach_index(
1582 [&](const int i) {
1583 calc_slide_mesh(depsgraph,
1584 sd,
1585 object,
1586 boundary.edit_info.propagation_steps_num,
1587 boundary.edit_info.strength_factor,
1588 boundary.slide.directions,
1589 nodes[i],
1590 boundary.initial_vert_position,
1591 strength,
1592 deform_target,
1593 position_data);
1594 bke::pbvh::update_node_bounds_mesh(position_data.eval, nodes[i]);
1595 },
1597 break;
1598 }
1600 SubdivCCG &subdiv_ccg = *object.runtime->sculpt_session->subdiv_ccg;
1601 MutableSpan<float3> positions = subdiv_ccg.positions;
1604 node_mask.foreach_index(
1605 [&](const int i) {
1606 LocalDataGrids &tls = all_tls.local();
1607 calc_slide_grids(depsgraph,
1608 sd,
1609 object,
1610 subdiv_ccg,
1611 boundary.edit_info.propagation_steps_num,
1612 boundary.edit_info.strength_factor,
1613 boundary.slide.directions,
1614 nodes[i],
1615 tls,
1616 boundary.initial_vert_position,
1617 strength,
1618 deform_target);
1619 bke::pbvh::update_node_bounds_grids(subdiv_ccg.grid_area, positions, nodes[i]);
1620 },
1622 break;
1623 }
1627 node_mask.foreach_index(
1628 [&](const int i) {
1629 LocalDataBMesh &tls = all_tls.local();
1630 calc_slide_bmesh(depsgraph,
1631 sd,
1632 object,
1633 boundary.edit_info.propagation_steps_num,
1634 boundary.edit_info.strength_factor,
1635 boundary.slide.directions,
1636 nodes[i],
1637 tls,
1638 boundary.initial_vert_position,
1639 strength,
1640 deform_target);
1642 },
1644 break;
1645 }
1646 }
1647 pbvh.tag_positions_changed(node_mask);
1648 pbvh.flush_bounds_to_parents();
1649}
1650
1652
1653/* -------------------------------------------------------------------- */
1656
1658 const Span<float3> normals,
1659 const Span<float> factors,
1660 const MutableSpan<float3> new_positions)
1661{
1662 BLI_assert(positions.size() == normals.size());
1663 BLI_assert(positions.size() == factors.size());
1664 BLI_assert(positions.size() == new_positions.size());
1665
1666 for (const int i : positions.index_range()) {
1667 new_positions[i] = positions[i] + (normals[i] * factors[i]);
1668 }
1669}
1670
1671static void calc_inflate_mesh(const Depsgraph &depsgraph,
1672 const Sculpt &sd,
1673 Object &object,
1674 const Span<int> vert_propagation_steps,
1675 const Span<float> vert_factors,
1677 const float3 symmetry_pivot,
1678 const float strength,
1679 const eBrushDeformTarget deform_target,
1680 const PositionDeformData &position_data)
1681{
1682 SculptSession &ss = *object.runtime->sculpt_session;
1683 const StrokeCache &cache = *ss.cache;
1684
1685 const Span<int> verts = node.verts();
1686 const OrigPositionData orig_data = orig_position_data_get_mesh(object, node);
1687
1688 const ePaintSymmetryFlags symm = mesh_symmetry_xyz_get(object);
1689
1691 gather_data_mesh(vert_factors, verts, factors.as_mutable_span());
1692
1693 auto_mask::calc_vert_factors(depsgraph, object, cache.automasking.get(), node, verts, factors);
1694
1695 Array<int, bke::pbvh::MESH_LEAF_LIMIT> propagation_steps(verts.size());
1696 gather_data_mesh(vert_propagation_steps, verts, propagation_steps.as_mutable_span());
1697
1698 filter_uninitialized_verts(propagation_steps, factors);
1699 filter_verts_outside_symmetry_area(orig_data.positions, symmetry_pivot, symm, factors);
1700
1701 scale_factors(factors, strength);
1702
1703 Array<float3, bke::pbvh::MESH_LEAF_LIMIT> new_positions(verts.size());
1704 calc_inflate_position(orig_data.positions, orig_data.normals, factors, new_positions);
1705
1706 switch (eBrushDeformTarget(deform_target)) {
1708 Array<float3, bke::pbvh::MESH_LEAF_LIMIT> translations(verts.size());
1709 translations_from_new_positions(new_positions, verts, position_data.eval, translations);
1710 filter_translations(translations, factors);
1711 clip_and_lock_translations(sd, ss, position_data.eval, verts, translations);
1712 position_data.deform(translations, verts);
1713 break;
1714 }
1717 new_positions.as_span(), verts, cache.cloth_sim->deformation_pos.as_mutable_span());
1718 break;
1719 }
1720}
1721
1722static void calc_inflate_grids(const Depsgraph &depsgraph,
1723 const Sculpt &sd,
1724 Object &object,
1725 SubdivCCG &subdiv_ccg,
1726 const Span<int> vert_propagation_steps,
1727 const Span<float> vert_factors,
1729 LocalDataGrids &tls,
1730 const float3 symmetry_pivot,
1731 const float strength,
1732 const eBrushDeformTarget deform_target)
1733{
1734 SculptSession &ss = *object.runtime->sculpt_session;
1735 const StrokeCache &cache = *ss.cache;
1736 const CCGKey key = BKE_subdiv_ccg_key_top_level(subdiv_ccg);
1737
1738 const Span<int> grids = node.grids();
1739 const int grid_verts_num = grids.size() * key.grid_area;
1740 const OrigPositionData orig_data = orig_position_data_get_grids(object, node);
1741
1742 const ePaintSymmetryFlags symm = mesh_symmetry_xyz_get(object);
1743
1744 const MutableSpan<float> factors = gather_data_grids(
1745 subdiv_ccg, vert_factors, grids, tls.factors);
1746
1747 auto_mask::calc_grids_factors(depsgraph, object, cache.automasking.get(), node, grids, factors);
1748
1749 const Span<int> propagation_steps = gather_data_grids(
1750 subdiv_ccg, vert_propagation_steps, grids, tls.propagation_steps);
1751
1752 filter_uninitialized_verts(propagation_steps, factors);
1753 filter_verts_outside_symmetry_area(orig_data.positions, symmetry_pivot, symm, factors);
1754
1755 scale_factors(factors, strength);
1756
1757 tls.new_positions.resize(grid_verts_num);
1758 const MutableSpan<float3> new_positions = tls.new_positions;
1759 calc_inflate_position(orig_data.positions, orig_data.normals, factors, new_positions);
1760
1761 switch (eBrushDeformTarget(deform_target)) {
1763 tls.translations.resize(grid_verts_num);
1764 const MutableSpan<float3> translations = tls.translations;
1765 const Span<float3> positions = gather_grids_positions(subdiv_ccg, grids, tls.positions);
1766 translations_from_new_positions(new_positions, positions, translations);
1767 filter_translations(translations, factors);
1768
1769 clip_and_lock_translations(sd, ss, orig_data.positions, translations);
1770 apply_translations(translations, grids, subdiv_ccg);
1771 break;
1772 }
1774 scatter_data_grids(subdiv_ccg,
1775 new_positions.as_span(),
1776 grids,
1777 cache.cloth_sim->deformation_pos.as_mutable_span());
1778 break;
1779 }
1780}
1781
1782static void calc_inflate_bmesh(const Depsgraph &depsgraph,
1783 const Sculpt &sd,
1784 Object &object,
1785 const Span<int> vert_propagation_steps,
1786 const Span<float> vert_factors,
1788 LocalDataBMesh &tls,
1789 const float3 symmetry_pivot,
1790 const float strength,
1791 const eBrushDeformTarget deform_target)
1792
1793{
1794 SculptSession &ss = *object.runtime->sculpt_session;
1795 const StrokeCache &cache = *ss.cache;
1796
1798 Array<float3> orig_positions(verts.size());
1799 Array<float3> orig_normals(verts.size());
1800 orig_position_data_gather_bmesh(*ss.bm_log, verts, orig_positions, orig_normals);
1801
1802 const ePaintSymmetryFlags symm = mesh_symmetry_xyz_get(object);
1803
1804 const MutableSpan<float> factors = gather_data_bmesh(vert_factors, verts, tls.factors);
1805
1806 auto_mask::calc_vert_factors(depsgraph, object, cache.automasking.get(), node, verts, factors);
1807
1808 const Span<int> propagation_steps = gather_data_bmesh(
1809 vert_propagation_steps, verts, tls.propagation_steps);
1810
1811 filter_uninitialized_verts(propagation_steps, factors);
1812 filter_verts_outside_symmetry_area(orig_positions, symmetry_pivot, symm, factors);
1813
1814 scale_factors(factors, strength);
1815
1816 tls.new_positions.resize(verts.size());
1817 const MutableSpan<float3> new_positions = tls.new_positions;
1818 calc_inflate_position(orig_positions, orig_normals, factors, new_positions);
1819
1820 switch (eBrushDeformTarget(deform_target)) {
1822 const MutableSpan<float3> positions = gather_bmesh_positions(verts, tls.positions);
1823 tls.translations.resize(verts.size());
1824 const MutableSpan<float3> translations = tls.translations;
1825 translations_from_new_positions(new_positions, positions, translations);
1826 filter_translations(translations, factors);
1827
1828 clip_and_lock_translations(sd, ss, orig_positions, translations);
1829 apply_translations(translations, verts);
1830 break;
1831 }
1834 new_positions.as_span(), verts, cache.cloth_sim->deformation_pos.as_mutable_span());
1835 break;
1836 }
1837}
1838
1839static void do_inflate_brush(const Depsgraph &depsgraph,
1840 const Sculpt &sd,
1841 Object &object,
1842 const IndexMask &node_mask,
1843 const SculptBoundary &boundary,
1844 const float strength,
1845 const eBrushDeformTarget deform_target)
1846{
1848 switch (pbvh.type()) {
1849 case bke::pbvh::Type::Mesh: {
1850 const PositionDeformData position_data(depsgraph, object);
1851
1853 node_mask.foreach_index(
1854 [&](const int i) {
1855 calc_inflate_mesh(depsgraph,
1856 sd,
1857 object,
1858 boundary.edit_info.propagation_steps_num,
1859 boundary.edit_info.strength_factor,
1860 nodes[i],
1861 boundary.initial_vert_position,
1862 strength,
1863 deform_target,
1864 position_data);
1865 bke::pbvh::update_node_bounds_mesh(position_data.eval, nodes[i]);
1866 },
1868 break;
1869 }
1871 SubdivCCG &subdiv_ccg = *object.runtime->sculpt_session->subdiv_ccg;
1872 MutableSpan<float3> positions = subdiv_ccg.positions;
1875 node_mask.foreach_index(
1876 [&](const int i) {
1877 LocalDataGrids &tls = all_tls.local();
1878 calc_inflate_grids(depsgraph,
1879 sd,
1880 object,
1881 subdiv_ccg,
1882 boundary.edit_info.propagation_steps_num,
1883 boundary.edit_info.strength_factor,
1884 nodes[i],
1885 tls,
1886 boundary.initial_vert_position,
1887 strength,
1888 deform_target);
1889 bke::pbvh::update_node_bounds_grids(subdiv_ccg.grid_area, positions, nodes[i]);
1890 },
1892 break;
1893 }
1897 node_mask.foreach_index(
1898 [&](const int i) {
1899 LocalDataBMesh &tls = all_tls.local();
1900 calc_inflate_bmesh(depsgraph,
1901 sd,
1902 object,
1903 boundary.edit_info.propagation_steps_num,
1904 boundary.edit_info.strength_factor,
1905 nodes[i],
1906 tls,
1907 boundary.initial_vert_position,
1908 strength,
1909 deform_target);
1911 },
1913 break;
1914 }
1915 }
1916 pbvh.tag_positions_changed(node_mask);
1917 pbvh.flush_bounds_to_parents();
1918}
1919
1921
1922/* -------------------------------------------------------------------- */
1925
1927 const float3 grab_delta,
1928 const Span<float> factors,
1929 const MutableSpan<float3> new_positions)
1930{
1931 BLI_assert(positions.size() == factors.size());
1932 BLI_assert(positions.size() == new_positions.size());
1933
1934 for (const int i : positions.index_range()) {
1935 new_positions[i] = positions[i] + (grab_delta * factors[i]);
1936 }
1937}
1938
1939static void calc_grab_mesh(const Depsgraph &depsgraph,
1940 const Sculpt &sd,
1941 Object &object,
1942 const Span<int> vert_propagation_steps,
1943 const Span<float> vert_factors,
1945 const float3 grab_delta_symmetry,
1946 const float3 symmetry_pivot,
1947 const float strength,
1948 const eBrushDeformTarget deform_target,
1949 const PositionDeformData &position_data)
1950{
1951 SculptSession &ss = *object.runtime->sculpt_session;
1952 const StrokeCache &cache = *ss.cache;
1953
1954 const Span<int> verts = node.verts();
1955 const OrigPositionData orig_data = orig_position_data_get_mesh(object, node);
1956
1957 const ePaintSymmetryFlags symm = mesh_symmetry_xyz_get(object);
1958
1960 gather_data_mesh(vert_factors, verts, factors.as_mutable_span());
1961
1962 auto_mask::calc_vert_factors(depsgraph, object, cache.automasking.get(), node, verts, factors);
1963
1964 Array<int, bke::pbvh::MESH_LEAF_LIMIT> propagation_steps(verts.size());
1965 gather_data_mesh(vert_propagation_steps, verts, propagation_steps.as_mutable_span());
1966
1967 filter_uninitialized_verts(propagation_steps, factors);
1968 filter_verts_outside_symmetry_area(orig_data.positions, symmetry_pivot, symm, factors);
1969
1970 scale_factors(factors, strength);
1971
1972 Array<float3, bke::pbvh::MESH_LEAF_LIMIT> new_positions(verts.size());
1973 calc_grab_position(orig_data.positions, grab_delta_symmetry, factors, new_positions);
1974
1975 switch (eBrushDeformTarget(deform_target)) {
1977 Array<float3, bke::pbvh::MESH_LEAF_LIMIT> translations(verts.size());
1978 translations_from_new_positions(new_positions, verts, position_data.eval, translations);
1979 filter_translations(translations, factors);
1980 clip_and_lock_translations(sd, ss, position_data.eval, verts, translations);
1981 position_data.deform(translations, verts);
1982 break;
1983 }
1986 new_positions.as_span(), verts, cache.cloth_sim->deformation_pos.as_mutable_span());
1987 break;
1988 }
1989}
1990
1991static void calc_grab_grids(const Depsgraph &depsgraph,
1992 const Sculpt &sd,
1993 Object &object,
1994 SubdivCCG &subdiv_ccg,
1995 const Span<int> vert_propagation_steps,
1996 const Span<float> vert_factors,
1998 LocalDataGrids &tls,
1999 const float3 grab_delta_symmetry,
2000 const float3 symmetry_pivot,
2001 const float strength,
2002 const eBrushDeformTarget deform_target)
2003{
2004 SculptSession &ss = *object.runtime->sculpt_session;
2005 const StrokeCache &cache = *ss.cache;
2006 const CCGKey key = BKE_subdiv_ccg_key_top_level(subdiv_ccg);
2007
2008 const Span<int> grids = node.grids();
2009 const int grid_verts_num = grids.size() * key.grid_area;
2010 const OrigPositionData orig_data = orig_position_data_get_grids(object, node);
2011
2012 const ePaintSymmetryFlags symm = mesh_symmetry_xyz_get(object);
2013
2014 const MutableSpan<float> factors = gather_data_grids(
2015 subdiv_ccg, vert_factors, grids, tls.factors);
2016
2017 auto_mask::calc_grids_factors(depsgraph, object, cache.automasking.get(), node, grids, factors);
2018
2019 const Span<int> propagation_steps = gather_data_grids(
2020 subdiv_ccg, vert_propagation_steps, grids, tls.propagation_steps);
2021
2022 filter_uninitialized_verts(propagation_steps, factors);
2023 filter_verts_outside_symmetry_area(orig_data.positions, symmetry_pivot, symm, factors);
2024
2025 scale_factors(factors, strength);
2026
2027 tls.new_positions.resize(grid_verts_num);
2028 const MutableSpan<float3> new_positions = tls.new_positions;
2029 calc_grab_position(orig_data.positions, grab_delta_symmetry, factors, new_positions);
2030
2031 switch (eBrushDeformTarget(deform_target)) {
2033 tls.translations.resize(grid_verts_num);
2034 const MutableSpan<float3> translations = tls.translations;
2035 const Span<float3> positions = gather_grids_positions(subdiv_ccg, grids, tls.positions);
2036 translations_from_new_positions(new_positions, positions, translations);
2037 filter_translations(translations, factors);
2038
2039 clip_and_lock_translations(sd, ss, orig_data.positions, translations);
2040 apply_translations(translations, grids, subdiv_ccg);
2041 break;
2042 }
2044 scatter_data_grids(subdiv_ccg,
2045 new_positions.as_span(),
2046 grids,
2047 cache.cloth_sim->deformation_pos.as_mutable_span());
2048 break;
2049 }
2050}
2051
2052static void calc_grab_bmesh(const Depsgraph &depsgraph,
2053 const Sculpt &sd,
2054 Object &object,
2055 const Span<int> vert_propagation_steps,
2056 const Span<float> vert_factors,
2058 LocalDataBMesh &tls,
2059 const float3 grab_delta_symmetry,
2060 const float3 symmetry_pivot,
2061 const float strength,
2062 const eBrushDeformTarget deform_target)
2063
2064{
2065 SculptSession &ss = *object.runtime->sculpt_session;
2066 const StrokeCache &cache = *ss.cache;
2067
2069 Array<float3> orig_positions(verts.size());
2070 Array<float3> orig_normals(verts.size());
2071 orig_position_data_gather_bmesh(*ss.bm_log, verts, orig_positions, orig_normals);
2072
2073 const ePaintSymmetryFlags symm = mesh_symmetry_xyz_get(object);
2074
2075 const MutableSpan<float> factors = gather_data_bmesh(vert_factors, verts, tls.factors);
2076
2077 auto_mask::calc_vert_factors(depsgraph, object, cache.automasking.get(), node, verts, factors);
2078
2079 const Span<int> propagation_steps = gather_data_bmesh(
2080 vert_propagation_steps, verts, tls.propagation_steps);
2081
2082 filter_uninitialized_verts(propagation_steps, factors);
2083 filter_verts_outside_symmetry_area(orig_positions, symmetry_pivot, symm, factors);
2084
2085 scale_factors(factors, strength);
2086
2087 tls.new_positions.resize(verts.size());
2088 const MutableSpan<float3> new_positions = tls.new_positions;
2089 calc_grab_position(orig_positions, grab_delta_symmetry, factors, new_positions);
2090
2091 switch (eBrushDeformTarget(deform_target)) {
2093 const MutableSpan<float3> positions = gather_bmesh_positions(verts, tls.positions);
2094 tls.translations.resize(verts.size());
2095 const MutableSpan<float3> translations = tls.translations;
2096 translations_from_new_positions(new_positions, positions, translations);
2097 filter_translations(translations, factors);
2098
2099 clip_and_lock_translations(sd, ss, orig_positions, translations);
2100 apply_translations(translations, verts);
2101 break;
2102 }
2105 new_positions.as_span(), verts, cache.cloth_sim->deformation_pos.as_mutable_span());
2106 break;
2107 }
2108}
2109
2110static void do_grab_brush(const Depsgraph &depsgraph,
2111 const Sculpt &sd,
2112 Object &object,
2113 const IndexMask &node_mask,
2114 const SculptBoundary &boundary,
2115 const float strength,
2116 const eBrushDeformTarget deform_target)
2117{
2118 SculptSession &ss = *object.runtime->sculpt_session;
2120 switch (pbvh.type()) {
2121 case bke::pbvh::Type::Mesh: {
2122 const PositionDeformData position_data(depsgraph, object);
2123
2125 node_mask.foreach_index(
2126 [&](const int i) {
2127 calc_grab_mesh(depsgraph,
2128 sd,
2129 object,
2130 boundary.edit_info.propagation_steps_num,
2131 boundary.edit_info.strength_factor,
2132 nodes[i],
2134 boundary.initial_vert_position,
2135 strength,
2136 deform_target,
2137 position_data);
2138 bke::pbvh::update_node_bounds_mesh(position_data.eval, nodes[i]);
2139 },
2141 break;
2142 }
2144 SubdivCCG &subdiv_ccg = *object.runtime->sculpt_session->subdiv_ccg;
2145 MutableSpan<float3> positions = subdiv_ccg.positions;
2148 node_mask.foreach_index(
2149 [&](const int i) {
2150 LocalDataGrids &tls = all_tls.local();
2151 calc_grab_grids(depsgraph,
2152 sd,
2153 object,
2154 subdiv_ccg,
2155 boundary.edit_info.propagation_steps_num,
2156 boundary.edit_info.strength_factor,
2157 nodes[i],
2158 tls,
2160 boundary.initial_vert_position,
2161 strength,
2162 deform_target);
2163 bke::pbvh::update_node_bounds_grids(subdiv_ccg.grid_area, positions, nodes[i]);
2164 },
2166 break;
2167 }
2171 node_mask.foreach_index(
2172 [&](const int i) {
2173 LocalDataBMesh &tls = all_tls.local();
2174 calc_grab_bmesh(depsgraph,
2175 sd,
2176 object,
2177 boundary.edit_info.propagation_steps_num,
2178 boundary.edit_info.strength_factor,
2179 nodes[i],
2180 tls,
2182 boundary.initial_vert_position,
2183 strength,
2184 deform_target);
2186 },
2188 break;
2189 }
2190 }
2191 pbvh.tag_positions_changed(node_mask);
2192 pbvh.flush_bounds_to_parents();
2193}
2194
2196
2197/* -------------------------------------------------------------------- */
2200
2202 const float3 pivot_point,
2203 const float3 pivot_axis,
2204 const Span<float> factors,
2205 const MutableSpan<float3> new_positions)
2206{
2207 BLI_assert(positions.size() == factors.size());
2208 BLI_assert(positions.size() == new_positions.size());
2209
2210 for (const int i : positions.index_range()) {
2211 new_positions[i] = math::rotate_around_axis(positions[i], pivot_point, pivot_axis, factors[i]);
2212 }
2213}
2214
2215static void calc_twist_mesh(const Depsgraph &depsgraph,
2216 const Sculpt &sd,
2217 Object &object,
2218 const Span<int> vert_propagation_steps,
2219 const Span<float> vert_factors,
2221 const float3 twist_pivot_position,
2222 const float3 twist_axis,
2223 const float3 symmetry_pivot,
2224 const float strength,
2225 const eBrushDeformTarget deform_target,
2226 const PositionDeformData &position_data)
2227{
2228 SculptSession &ss = *object.runtime->sculpt_session;
2229 const StrokeCache &cache = *ss.cache;
2230
2231 const Span<int> verts = node.verts();
2232 const OrigPositionData orig_data = orig_position_data_get_mesh(object, node);
2233
2234 const ePaintSymmetryFlags symm = mesh_symmetry_xyz_get(object);
2235
2237 gather_data_mesh(vert_factors, verts, factors.as_mutable_span());
2238
2239 auto_mask::calc_vert_factors(depsgraph, object, cache.automasking.get(), node, verts, factors);
2240
2241 Array<int, bke::pbvh::MESH_LEAF_LIMIT> propagation_steps(verts.size());
2242 gather_data_mesh(vert_propagation_steps, verts, propagation_steps.as_mutable_span());
2243
2244 filter_uninitialized_verts(propagation_steps, factors);
2245 filter_verts_outside_symmetry_area(orig_data.positions, symmetry_pivot, symm, factors);
2246
2247 scale_factors(factors, strength);
2248
2249 Array<float3, bke::pbvh::MESH_LEAF_LIMIT> new_positions(verts.size());
2251 orig_data.positions, twist_pivot_position, twist_axis, factors, new_positions);
2252
2253 switch (eBrushDeformTarget(deform_target)) {
2255 Array<float3, bke::pbvh::MESH_LEAF_LIMIT> translations(verts.size());
2256 translations_from_new_positions(new_positions, verts, position_data.eval, translations);
2257 filter_translations(translations, factors);
2258 clip_and_lock_translations(sd, ss, position_data.eval, verts, translations);
2259 position_data.deform(translations, verts);
2260 break;
2261 }
2264 new_positions.as_span(), verts, cache.cloth_sim->deformation_pos.as_mutable_span());
2265 break;
2266 }
2267}
2268
2269static void calc_twist_grids(const Depsgraph &depsgraph,
2270 const Sculpt &sd,
2271 Object &object,
2272 SubdivCCG &subdiv_ccg,
2273 const Span<int> vert_propagation_steps,
2274 const Span<float> vert_factors,
2275 const float3 twist_pivot_position,
2276 const float3 twist_axis,
2278 LocalDataGrids &tls,
2279 const float3 symmetry_pivot,
2280 const float strength,
2281 const eBrushDeformTarget deform_target)
2282{
2283 SculptSession &ss = *object.runtime->sculpt_session;
2284 const StrokeCache &cache = *ss.cache;
2285 const CCGKey key = BKE_subdiv_ccg_key_top_level(subdiv_ccg);
2286
2287 const Span<int> grids = node.grids();
2288 const int grid_verts_num = grids.size() * key.grid_area;
2289 const OrigPositionData orig_data = orig_position_data_get_grids(object, node);
2290
2291 const ePaintSymmetryFlags symm = mesh_symmetry_xyz_get(object);
2292
2293 const MutableSpan<float> factors = gather_data_grids(
2294 subdiv_ccg, vert_factors, grids, tls.factors);
2295
2296 auto_mask::calc_grids_factors(depsgraph, object, cache.automasking.get(), node, grids, factors);
2297
2298 const Span<int> propagation_steps = gather_data_grids(
2299 subdiv_ccg, vert_propagation_steps, grids, tls.propagation_steps);
2300
2301 filter_uninitialized_verts(propagation_steps, factors);
2302 filter_verts_outside_symmetry_area(orig_data.positions, symmetry_pivot, symm, factors);
2303
2304 scale_factors(factors, strength);
2305
2306 tls.new_positions.resize(grid_verts_num);
2307 const MutableSpan<float3> new_positions = tls.new_positions;
2309 orig_data.positions, twist_pivot_position, twist_axis, factors, new_positions);
2310
2311 switch (eBrushDeformTarget(deform_target)) {
2313 tls.translations.resize(grid_verts_num);
2314 const MutableSpan<float3> translations = tls.translations;
2315 const Span<float3> positions = gather_grids_positions(subdiv_ccg, grids, tls.positions);
2316 translations_from_new_positions(new_positions, positions, translations);
2317 filter_translations(translations, factors);
2318
2319 clip_and_lock_translations(sd, ss, orig_data.positions, translations);
2320 apply_translations(translations, grids, subdiv_ccg);
2321 break;
2322 }
2324 scatter_data_grids(subdiv_ccg,
2325 new_positions.as_span(),
2326 grids,
2327 cache.cloth_sim->deformation_pos.as_mutable_span());
2328 break;
2329 }
2330}
2331
2332static void calc_twist_bmesh(const Depsgraph &depsgraph,
2333 const Sculpt &sd,
2334 Object &object,
2335 const Span<int> vert_propagation_steps,
2336 const Span<float> vert_factors,
2337 const float3 twist_pivot_position,
2338 const float3 twist_axis,
2340 LocalDataBMesh &tls,
2341 const float3 symmetry_pivot,
2342 const float strength,
2343 const eBrushDeformTarget deform_target)
2344
2345{
2346 SculptSession &ss = *object.runtime->sculpt_session;
2347 const StrokeCache &cache = *ss.cache;
2348
2350 Array<float3> orig_positions(verts.size());
2351 Array<float3> orig_normals(verts.size());
2352 orig_position_data_gather_bmesh(*ss.bm_log, verts, orig_positions, orig_normals);
2353
2354 const ePaintSymmetryFlags symm = mesh_symmetry_xyz_get(object);
2355
2356 const MutableSpan<float> factors = gather_data_bmesh(vert_factors, verts, tls.factors);
2357
2358 auto_mask::calc_vert_factors(depsgraph, object, cache.automasking.get(), node, verts, factors);
2359
2360 const Span<int> propagation_steps = gather_data_bmesh(
2361 vert_propagation_steps, verts, tls.propagation_steps);
2362
2363 filter_uninitialized_verts(propagation_steps, factors);
2364 filter_verts_outside_symmetry_area(orig_positions, symmetry_pivot, symm, factors);
2365
2366 scale_factors(factors, strength);
2367
2368 tls.new_positions.resize(verts.size());
2369 const MutableSpan<float3> new_positions = tls.new_positions;
2370 calc_twist_position(orig_positions, twist_pivot_position, twist_axis, factors, new_positions);
2371
2372 switch (eBrushDeformTarget(deform_target)) {
2374 const MutableSpan<float3> positions = gather_bmesh_positions(verts, tls.positions);
2375 tls.translations.resize(verts.size());
2376 const MutableSpan<float3> translations = tls.translations;
2377 translations_from_new_positions(new_positions, positions, translations);
2378 filter_translations(translations, factors);
2379
2380 clip_and_lock_translations(sd, ss, orig_positions, translations);
2381 apply_translations(translations, verts);
2382 break;
2383 }
2386 new_positions.as_span(), verts, cache.cloth_sim->deformation_pos.as_mutable_span());
2387 break;
2388 }
2389}
2390
2391static void do_twist_brush(const Depsgraph &depsgraph,
2392 const Sculpt &sd,
2393 Object &object,
2394 const IndexMask &node_mask,
2395 const SculptBoundary &boundary,
2396 const float strength,
2397 const eBrushDeformTarget deform_target)
2398{
2400 switch (pbvh.type()) {
2401 case bke::pbvh::Type::Mesh: {
2402 const PositionDeformData position_data(depsgraph, object);
2403
2405 node_mask.foreach_index(
2406 [&](const int i) {
2407 calc_twist_mesh(depsgraph,
2408 sd,
2409 object,
2410 boundary.edit_info.propagation_steps_num,
2411 boundary.edit_info.strength_factor,
2412 nodes[i],
2413 boundary.twist.pivot_position,
2414 boundary.twist.rotation_axis,
2415 boundary.initial_vert_position,
2416 strength,
2417 deform_target,
2418 position_data);
2419 bke::pbvh::update_node_bounds_mesh(position_data.eval, nodes[i]);
2420 },
2422 break;
2423 }
2425 SubdivCCG &subdiv_ccg = *object.runtime->sculpt_session->subdiv_ccg;
2426 MutableSpan<float3> positions = subdiv_ccg.positions;
2429 node_mask.foreach_index(
2430 [&](const int i) {
2431 LocalDataGrids &tls = all_tls.local();
2432 calc_twist_grids(depsgraph,
2433 sd,
2434 object,
2435 subdiv_ccg,
2436 boundary.edit_info.propagation_steps_num,
2437 boundary.edit_info.strength_factor,
2438 boundary.twist.pivot_position,
2439 boundary.twist.rotation_axis,
2440 nodes[i],
2441 tls,
2442 boundary.initial_vert_position,
2443 strength,
2444 deform_target);
2445 bke::pbvh::update_node_bounds_grids(subdiv_ccg.grid_area, positions, nodes[i]);
2446 },
2448 break;
2449 }
2453 node_mask.foreach_index(
2454 [&](const int i) {
2455 LocalDataBMesh &tls = all_tls.local();
2456 calc_twist_bmesh(depsgraph,
2457 sd,
2458 object,
2459 boundary.edit_info.propagation_steps_num,
2460 boundary.edit_info.strength_factor,
2461 boundary.twist.pivot_position,
2462 boundary.twist.rotation_axis,
2463 nodes[i],
2464 tls,
2465 boundary.initial_vert_position,
2466 strength,
2467 deform_target);
2469 },
2471 break;
2472 }
2473 }
2474 pbvh.tag_positions_changed(node_mask);
2475 pbvh.flush_bounds_to_parents();
2476}
2477
2479
2480/* -------------------------------------------------------------------- */
2483
2485 const Span<float3> average_position,
2486 const Span<float> factors,
2487 const MutableSpan<float3> new_positions)
2488{
2489 BLI_assert(positions.size() == average_position.size());
2490 BLI_assert(positions.size() == factors.size());
2491 BLI_assert(positions.size() == new_positions.size());
2492
2493 for (const int i : positions.index_range()) {
2494 const float3 to_smooth = average_position[i] - positions[i];
2495 new_positions[i] = positions[i] + (to_smooth * factors[i]);
2496 }
2497}
2498
2499BLI_NOINLINE static void calc_average_position(const Span<float3> vert_positions,
2500 const Span<int> vert_propagation_steps,
2501 const GroupedSpan<int> neighbors,
2502 const Span<int> propagation_steps,
2503 const MutableSpan<float> factors,
2504 const MutableSpan<float3> average_positions)
2505{
2506 BLI_assert(vert_positions.size() == vert_propagation_steps.size());
2507 BLI_assert(factors.size() == neighbors.size());
2508 BLI_assert(factors.size() == propagation_steps.size());
2509 BLI_assert(factors.size() == average_positions.size());
2510
2511 for (const int i : neighbors.index_range()) {
2512 average_positions[i] = float3(0.0f);
2513 int valid_neighbors = 0;
2514 for (const int neighbor : neighbors[i]) {
2515 if (propagation_steps[i] == vert_propagation_steps[neighbor]) {
2516 average_positions[i] += vert_positions[neighbor];
2517 valid_neighbors++;
2518 }
2519 }
2520 average_positions[i] *= math::safe_rcp(float(valid_neighbors));
2521 if (valid_neighbors == 0) {
2522 factors[i] = 0.0f;
2523 }
2524 }
2525}
2526
2527BLI_NOINLINE static void calc_average_position(const Span<int> vert_propagation_steps,
2528 const GroupedSpan<BMVert *> neighbors,
2529 const Span<int> propagation_steps,
2530 const MutableSpan<float> factors,
2531 const MutableSpan<float3> average_positions)
2532{
2533 BLI_assert(neighbors.size() == propagation_steps.size());
2534 BLI_assert(neighbors.size() == factors.size());
2535 BLI_assert(neighbors.size() == average_positions.size());
2536
2537 for (const int i : neighbors.index_range()) {
2538 average_positions[i] = float3(0.0f);
2539 int valid_neighbors = 0;
2540 for (BMVert *neighbor : neighbors[i]) {
2541 const int neighbor_idx = BM_elem_index_get(neighbor);
2542 if (propagation_steps[i] == vert_propagation_steps[neighbor_idx]) {
2543 average_positions[i] += neighbor->co;
2544 valid_neighbors++;
2545 }
2546 }
2547 average_positions[i] *= math::safe_rcp(float(valid_neighbors));
2548 if (valid_neighbors == 0) {
2549 factors[i] = 0.0f;
2550 }
2551 }
2552}
2553
2554static void calc_smooth_mesh(const Sculpt &sd,
2555 Object &object,
2556 const OffsetIndices<int> faces,
2557 const Span<int> corner_verts,
2558 const GroupedSpan<int> vert_to_face,
2559 const Span<bool> hide_poly,
2560 const Span<int> vert_propagation_steps,
2561 const Span<float> vert_factors,
2563 LocalDataMesh &tls,
2564 const float3 symmetry_pivot,
2565 const float strength,
2566 const eBrushDeformTarget deform_target,
2567 const PositionDeformData &position_data)
2568{
2569 SculptSession &ss = *object.runtime->sculpt_session;
2570 const StrokeCache &cache = *ss.cache;
2571
2572 const Span<int> verts = node.verts();
2573 const OrigPositionData orig_data = orig_position_data_get_mesh(object, node);
2574
2575 const ePaintSymmetryFlags symm = mesh_symmetry_xyz_get(object);
2576
2578 gather_data_mesh(vert_factors, verts, factors.as_mutable_span());
2579
2580 Array<int, bke::pbvh::MESH_LEAF_LIMIT> propagation_steps(verts.size());
2581 gather_data_mesh(vert_propagation_steps, verts, propagation_steps.as_mutable_span());
2582
2583 filter_uninitialized_verts(propagation_steps, factors);
2584 filter_verts_outside_symmetry_area(orig_data.positions, symmetry_pivot, symm, factors);
2585
2586 scale_factors(factors, strength);
2587
2588 const GroupedSpan<int> neighbors = calc_vert_neighbors(faces,
2589 corner_verts,
2590 vert_to_face,
2591 hide_poly,
2592 verts,
2593 tls.neighbor_offsets,
2594 tls.neighbor_data);
2595
2597 gather_data_mesh(position_data.eval, verts, positions.as_mutable_span());
2598
2599 Array<float3, bke::pbvh::MESH_LEAF_LIMIT> average_positions(verts.size());
2600 calc_average_position(position_data.eval,
2601 vert_propagation_steps,
2602 neighbors,
2603 propagation_steps,
2604 factors,
2605 average_positions);
2606
2607 Array<float3, bke::pbvh::MESH_LEAF_LIMIT> new_positions(verts.size());
2608 calc_smooth_position(positions, average_positions, factors, new_positions);
2609
2610 switch (eBrushDeformTarget(deform_target)) {
2612 Array<float3, bke::pbvh::MESH_LEAF_LIMIT> translations(verts.size());
2613 translations_from_new_positions(new_positions, verts, position_data.eval, translations);
2614 clip_and_lock_translations(sd, ss, position_data.eval, verts, translations);
2615 position_data.deform(translations, verts);
2616 break;
2617 }
2620 new_positions.as_span(), verts, cache.cloth_sim->deformation_pos.as_mutable_span());
2621 break;
2622 }
2623}
2624
2625static void calc_smooth_grids(const Sculpt &sd,
2626 Object &object,
2627 SubdivCCG &subdiv_ccg,
2628 const Span<int> vert_propagation_steps,
2629 const Span<float> vert_factors,
2631 LocalDataGrids &tls,
2632 const float3 symmetry_pivot,
2633 const float strength,
2634 const eBrushDeformTarget deform_target)
2635{
2636 SculptSession &ss = *object.runtime->sculpt_session;
2637 const StrokeCache &cache = *ss.cache;
2638 const CCGKey key = BKE_subdiv_ccg_key_top_level(subdiv_ccg);
2639
2640 const Span<int> grids = node.grids();
2641 const int grid_verts_num = grids.size() * key.grid_area;
2642 const OrigPositionData orig_data = orig_position_data_get_grids(object, node);
2643
2644 const ePaintSymmetryFlags symm = mesh_symmetry_xyz_get(object);
2645
2646 const MutableSpan<float> factors = gather_data_grids(
2647 subdiv_ccg, vert_factors, grids, tls.factors);
2648
2649 const Span<int> propagation_steps = gather_data_grids(
2650 subdiv_ccg, vert_propagation_steps, grids, tls.propagation_steps);
2651
2652 filter_uninitialized_verts(propagation_steps, factors);
2653 filter_verts_outside_symmetry_area(orig_data.positions, symmetry_pivot, symm, factors);
2654
2655 scale_factors(factors, strength);
2656
2657 const GroupedSpan<int> neighbors = calc_vert_neighbors(
2658 subdiv_ccg, grids, tls.neighbor_offsets, tls.neighbor_data);
2659
2660 tls.average_positions.resize(grid_verts_num);
2661 const MutableSpan<float3> average_positions = tls.average_positions;
2663 vert_propagation_steps,
2664 neighbors,
2665 propagation_steps,
2666 factors,
2667 average_positions);
2668
2669 const Span<float3> positions = gather_grids_positions(subdiv_ccg, grids, tls.positions);
2670
2671 tls.new_positions.resize(grid_verts_num);
2672 const MutableSpan<float3> new_positions = tls.new_positions;
2673 calc_smooth_position(positions, average_positions, factors, new_positions);
2674
2675 switch (eBrushDeformTarget(deform_target)) {
2677 tls.translations.resize(grid_verts_num);
2678 const MutableSpan<float3> translations = tls.translations;
2679 translations_from_new_positions(new_positions, positions, translations);
2680
2681 clip_and_lock_translations(sd, ss, orig_data.positions, translations);
2682 apply_translations(translations, grids, subdiv_ccg);
2683 break;
2684 }
2686 scatter_data_grids(subdiv_ccg,
2687 new_positions.as_span(),
2688 grids,
2689 cache.cloth_sim->deformation_pos.as_mutable_span());
2690 break;
2691 }
2692}
2693
2694static void calc_smooth_bmesh(const Sculpt &sd,
2695 Object &object,
2696 const Span<int> vert_propagation_steps,
2697 const Span<float> vert_factors,
2699 LocalDataBMesh &tls,
2700 const float3 symmetry_pivot,
2701 const float strength,
2702 const eBrushDeformTarget deform_target)
2703
2704{
2705 SculptSession &ss = *object.runtime->sculpt_session;
2706 const StrokeCache &cache = *ss.cache;
2707
2709 Array<float3> orig_positions(verts.size());
2710 Array<float3> orig_normals(verts.size());
2711 orig_position_data_gather_bmesh(*ss.bm_log, verts, orig_positions, orig_normals);
2712
2713 const ePaintSymmetryFlags symm = mesh_symmetry_xyz_get(object);
2714
2715 const MutableSpan<float> factors = gather_data_bmesh(vert_factors, verts, tls.factors);
2716
2717 const Span<int> propagation_steps = gather_data_bmesh(
2718 vert_propagation_steps, verts, tls.propagation_steps);
2719
2720 filter_uninitialized_verts(propagation_steps, factors);
2721 filter_verts_outside_symmetry_area(orig_positions, symmetry_pivot, symm, factors);
2722
2723 scale_factors(factors, strength);
2724
2726 verts, tls.neighbor_offsets, tls.neighbor_data);
2727
2728 tls.average_positions.resize(verts.size());
2729 const MutableSpan<float3> average_positions = tls.average_positions;
2731 vert_propagation_steps, neighbors, propagation_steps, factors, average_positions);
2732 const Span<float3> positions = gather_bmesh_positions(verts, tls.positions);
2733
2734 tls.new_positions.resize(verts.size());
2735 const MutableSpan<float3> new_positions = tls.new_positions;
2736 calc_smooth_position(positions, average_positions, factors, new_positions);
2737
2738 switch (eBrushDeformTarget(deform_target)) {
2740 tls.translations.resize(verts.size());
2741 const MutableSpan<float3> translations = tls.translations;
2742 translations_from_new_positions(new_positions, positions, translations);
2743
2744 clip_and_lock_translations(sd, ss, orig_positions, translations);
2745 apply_translations(translations, verts);
2746 break;
2747 }
2750 new_positions.as_span(), verts, cache.cloth_sim->deformation_pos.as_mutable_span());
2751 break;
2752 }
2753}
2754
2755static void do_smooth_brush(const Depsgraph &depsgraph,
2756 const Sculpt &sd,
2757 Object &object,
2758 const IndexMask &node_mask,
2759 const SculptBoundary &boundary,
2760 const float strength,
2761 const eBrushDeformTarget deform_target)
2762{
2764 switch (pbvh.type()) {
2765 case bke::pbvh::Type::Mesh: {
2766 Mesh &mesh = *id_cast<Mesh *>(object.data);
2767 const PositionDeformData position_data(depsgraph, object);
2768 const OffsetIndices<int> faces = mesh.faces();
2769 const Span<int> corner_verts = mesh.corner_verts();
2770 const GroupedSpan<int> vert_to_face_map = mesh.vert_to_face_map();
2771 bke::MutableAttributeAccessor attributes = mesh.attributes_for_write();
2772 const VArraySpan hide_poly = *attributes.lookup<bool>(".hide_poly", bke::AttrDomain::Face);
2773
2776 node_mask.foreach_index(
2777 [&](const int i) {
2778 LocalDataMesh &tls = all_tls.local();
2780 object,
2781 faces,
2782 corner_verts,
2783 vert_to_face_map,
2784 hide_poly,
2785 boundary.edit_info.propagation_steps_num,
2786 boundary.edit_info.strength_factor,
2787 nodes[i],
2788 tls,
2789 boundary.initial_vert_position,
2790 strength,
2791 deform_target,
2792 position_data);
2793 bke::pbvh::update_node_bounds_mesh(position_data.eval, nodes[i]);
2794 },
2796 break;
2797 }
2799 SubdivCCG &subdiv_ccg = *object.runtime->sculpt_session->subdiv_ccg;
2800 MutableSpan<float3> positions = subdiv_ccg.positions;
2803 node_mask.foreach_index(
2804 [&](const int i) {
2805 LocalDataGrids &tls = all_tls.local();
2807 object,
2808 subdiv_ccg,
2809 boundary.edit_info.propagation_steps_num,
2810 boundary.edit_info.strength_factor,
2811 nodes[i],
2812 tls,
2813 boundary.initial_vert_position,
2814 strength,
2815 deform_target);
2816 bke::pbvh::update_node_bounds_grids(subdiv_ccg.grid_area, positions, nodes[i]);
2817 },
2819 break;
2820 }
2824 node_mask.foreach_index(
2825 [&](const int i) {
2826 LocalDataBMesh &tls = all_tls.local();
2828 object,
2829 boundary.edit_info.propagation_steps_num,
2830 boundary.edit_info.strength_factor,
2831 nodes[i],
2832 tls,
2833 boundary.initial_vert_position,
2834 strength,
2835 deform_target);
2837 },
2839 break;
2840 }
2841 }
2842 pbvh.tag_positions_changed(node_mask);
2843 pbvh.flush_bounds_to_parents();
2844}
2845
2847
2848/* -------------------------------------------------------------------- */
2851
2853 const SculptBoundary &boundary)
2854{
2855 float4 plane;
2856 const float3 normal = math::normalize(ss.cache->initial_location_symm - boundary.pivot_position);
2858
2860 return dist_signed_to_plane_v3(pos, plane);
2861}
2862
2863static std::pair<float, float> calc_boundary_falloff(const SculptBoundary &boundary,
2864 const Brush &brush,
2865 const float radius,
2866 const int index)
2867{
2868 const float boundary_distance = boundary.distance.lookup_default(index, 0.0f);
2869 float falloff_distance = 0.0f;
2870 float direction = 1.0f;
2871
2872 switch (brush.boundary_falloff_type) {
2874 falloff_distance = boundary_distance;
2875 break;
2877 const int div = boundary_distance / radius;
2878 const float mod = fmodf(boundary_distance, radius);
2879 falloff_distance = div % 2 == 0 ? mod : radius - mod;
2880 break;
2881 }
2883 const int div = boundary_distance / radius;
2884 const float mod = fmodf(boundary_distance, radius);
2885 falloff_distance = div % 2 == 0 ? mod : radius - mod;
2886 /* Inverts the falloff in the intervals 1 2 5 6 9 10 ... etc. */
2887 if (((div - 1) & 2) == 0) {
2888 direction = -1.0f;
2889 }
2890 break;
2891 }
2893 /* For constant falloff distances are not allocated, so this should never happen. */
2895 break;
2896 }
2897
2898 return {falloff_distance, direction};
2899}
2900
2906 const Brush &brush,
2907 const float radius,
2909{
2910 BLI_assert(boundary.edit_info.original_vertex_i.size() ==
2911 boundary.edit_info.propagation_steps_num.size());
2912 BLI_assert(boundary.edit_info.original_vertex_i.size() ==
2913 boundary.edit_info.strength_factor.size());
2914
2915 const int num_elements = boundary.edit_info.strength_factor.size();
2916 BKE_curvemapping_init(brush.curve_distance_falloff);
2917
2918 for (const int i : IndexRange(num_elements)) {
2919 if (boundary.edit_info.propagation_steps_num[i] != BOUNDARY_STEPS_NONE) {
2920 const float mask_factor = mask.is_empty() ? 1.0f : 1.0f - mask[i];
2921 boundary.edit_info.strength_factor[i] = mask_factor *
2923 &brush,
2924 boundary.edit_info.propagation_steps_num[i],
2925 boundary.max_propagation_steps);
2926 }
2927
2928 if (boundary.edit_info.original_vertex_i[i] == boundary.initial_vert_i) {
2929 /* All vertices that are propagated from the original vertex won't be affected by the
2930 * boundary falloff, so there is no need to calculate anything else. */
2931 continue;
2932 }
2933
2934 const bool use_boundary_distances = brush.boundary_falloff_type !=
2936
2937 if (!use_boundary_distances) {
2938 /* There are falloff modes that do not require to modify the previously calculated falloff
2939 * based on boundary distances. */
2940 continue;
2941 }
2942
2943 auto [falloff_distance, direction] = calc_boundary_falloff(
2944 boundary, brush, radius, boundary.edit_info.original_vertex_i[i]);
2945 boundary.edit_info.strength_factor[i] *= direction * BKE_brush_curve_strength(
2946 &brush, falloff_distance, radius);
2947 }
2948}
2949
2950static void init_falloff_grids(const SubdivCCG &subdiv_ccg,
2951 const Brush &brush,
2952 const float radius,
2954{
2955 BLI_assert(boundary.edit_info.original_vertex_i.size() ==
2956 boundary.edit_info.propagation_steps_num.size());
2957 BLI_assert(boundary.edit_info.original_vertex_i.size() ==
2958 boundary.edit_info.strength_factor.size());
2959
2960 const CCGKey key = BKE_subdiv_ccg_key_top_level(subdiv_ccg);
2961
2962 BKE_curvemapping_init(brush.curve_distance_falloff);
2963
2964 for (const int grid : IndexRange(subdiv_ccg.grids_num)) {
2965 for (const int index : bke::ccg::grid_range(key, grid)) {
2966 if (boundary.edit_info.propagation_steps_num[index] != BOUNDARY_STEPS_NONE) {
2967 const float mask_factor = subdiv_ccg.masks.is_empty() ? 1.0f :
2968 1.0f - subdiv_ccg.masks[index];
2969 boundary.edit_info.strength_factor[index] =
2970 mask_factor * BKE_brush_curve_strength(&brush,
2971 boundary.edit_info.propagation_steps_num[index],
2972 boundary.max_propagation_steps);
2973 }
2974
2975 if (boundary.edit_info.original_vertex_i[index] == boundary.initial_vert_i) {
2976 /* All vertices that are propagated from the original vertex won't be affected by the
2977 * boundary falloff, so there is no need to calculate anything else. */
2978 continue;
2979 }
2980
2981 const bool use_boundary_distances = brush.boundary_falloff_type !=
2983
2984 if (!use_boundary_distances) {
2985 /* There are falloff modes that do not require to modify the previously calculated falloff
2986 * based on boundary distances. */
2987 continue;
2988 }
2989
2990 auto [falloff_distance, direction] = calc_boundary_falloff(
2991 boundary, brush, radius, boundary.edit_info.original_vertex_i[index]);
2992 boundary.edit_info.strength_factor[index] *= direction *
2994 &brush, falloff_distance, radius);
2995 }
2996 }
2997}
2998
3000 const Brush &brush,
3001 const float radius,
3003{
3004 BLI_assert(boundary.edit_info.original_vertex_i.size() ==
3005 boundary.edit_info.propagation_steps_num.size());
3006 BLI_assert(boundary.edit_info.original_vertex_i.size() ==
3007 boundary.edit_info.strength_factor.size());
3008
3009 const int num_elements = boundary.edit_info.strength_factor.size();
3010
3011 BKE_curvemapping_init(brush.curve_distance_falloff);
3012
3013 for (const int i : IndexRange(num_elements)) {
3014 if (boundary.edit_info.propagation_steps_num[i] != BOUNDARY_STEPS_NONE) {
3015 BMVert *vert = BM_vert_at_index(bm, i);
3016 const int mask_offset = CustomData_get_offset_named(
3017 &bm->vdata, CD_PROP_FLOAT, ".sculpt_mask");
3018 const float mask_factor = mask_offset == -1 ? 1.0f :
3019 1.0f - BM_ELEM_CD_GET_FLOAT(vert, mask_offset);
3020
3021 boundary.edit_info.strength_factor[i] = mask_factor *
3023 &brush,
3024 boundary.edit_info.propagation_steps_num[i],
3025 boundary.max_propagation_steps);
3026 }
3027
3028 if (boundary.edit_info.original_vertex_i[i] == boundary.initial_vert_i) {
3029 /* All vertices that are propagated from the original vertex won't be affected by the
3030 * boundary falloff, so there is no need to calculate anything else. */
3031 continue;
3032 }
3033
3034 const bool use_boundary_distances = brush.boundary_falloff_type !=
3036
3037 if (!use_boundary_distances) {
3038 /* There are falloff modes that do not require to modify the previously calculated falloff
3039 * based on boundary distances. */
3040 continue;
3041 }
3042
3043 auto [falloff_distance, direction] = calc_boundary_falloff(
3044 boundary, brush, radius, boundary.edit_info.original_vertex_i[i]);
3045 boundary.edit_info.strength_factor[i] *= direction * BKE_brush_curve_strength(
3046 &brush, falloff_distance, radius);
3047 }
3048}
3049
3050static void init_boundary_mesh(const Depsgraph &depsgraph,
3051 Object &object,
3052 const Brush &brush,
3053 const ePaintSymmetryFlags symm_area)
3054{
3055 const SculptSession &ss = *object.runtime->sculpt_session;
3057
3058 const Mesh &mesh = *id_cast<const Mesh *>(object.data);
3059 const bke::AttributeAccessor attributes = mesh.attributes();
3060 VArraySpan<bool> hide_vert = *attributes.lookup<bool>(".hide_vert", bke::AttrDomain::Point);
3061 VArraySpan<float> mask = *attributes.lookup<float>(".sculpt_mask", bke::AttrDomain::Point);
3062
3063 const Span<float3> positions_eval = bke::pbvh::vert_positions_eval(depsgraph, object);
3064 const Span<float3> vert_normals = bke::pbvh::vert_normals_eval(depsgraph, object);
3065
3066 ActiveVert initial_vert_ref = ss.active_vert();
3067 if (std::holds_alternative<std::monostate>(initial_vert_ref)) {
3068 return;
3069 }
3070
3071 std::optional<int> initial_vert;
3072 if (ss.cache->mirror_symmetry_pass == 0) {
3073 initial_vert = std::get<int>(initial_vert_ref);
3074 }
3075 else {
3076 float3 location = symmetry_flip(positions_eval[std::get<int>(initial_vert_ref)], symm_area);
3077 initial_vert = nearest_vert_calc_mesh(
3078 pbvh, positions_eval, hide_vert, location, ss.cache->radius_squared, false);
3079 }
3080
3081 if (!initial_vert) {
3082 return;
3083 }
3084
3085 ss.cache->boundaries[symm_area] = boundary::data_init_mesh(
3086 depsgraph, object, &brush, *initial_vert, ss.cache->initial_radius);
3087
3088 if (ss.cache->boundaries[symm_area]) {
3089 switch (brush.boundary_deform_type) {
3091 bend_data_init_mesh(positions_eval, vert_normals, *ss.cache->boundaries[symm_area]);
3092 break;
3094 slide_data_init_mesh(positions_eval, *ss.cache->boundaries[symm_area]);
3095 break;
3097 twist_data_init_mesh(positions_eval, *ss.cache->boundaries[symm_area]);
3098 break;
3102 /* Do nothing. These deform modes don't need any extra data to be precomputed. */
3103 break;
3104 }
3105
3107 }
3108}
3109
3110static void init_boundary_grids(Object &object,
3111 const Brush &brush,
3112 const ePaintSymmetryFlags symm_area)
3113{
3114 const SculptSession &ss = *object.runtime->sculpt_session;
3115 const bke::pbvh::Tree &pbvh = *bke::object::pbvh_get(object);
3116
3117 const SubdivCCG &subdiv_ccg = *ss.subdiv_ccg;
3118 const CCGKey &key = BKE_subdiv_ccg_key_top_level(subdiv_ccg);
3119 const Span<float3> positions = subdiv_ccg.positions;
3120
3121 ActiveVert initial_vert_ref = ss.active_vert();
3122 if (std::holds_alternative<std::monostate>(initial_vert_ref)) {
3123 return;
3124 }
3125
3126 std::optional<SubdivCCGCoord> initial_vert;
3127 if (ss.cache->mirror_symmetry_pass == 0) {
3128 initial_vert = SubdivCCGCoord::from_index(key, std::get<int>(initial_vert_ref));
3129 }
3130 else {
3131 const int active_vert = std::get<int>(initial_vert_ref);
3132 float3 location = symmetry_flip(positions[active_vert], symm_area);
3133 initial_vert = nearest_vert_calc_grids(
3134 pbvh, subdiv_ccg, location, ss.cache->radius_squared, false);
3135 }
3136
3137 if (!initial_vert) {
3138 return;
3139 }
3140
3142 object, &brush, *initial_vert, ss.cache->initial_radius);
3143
3144 if (ss.cache->boundaries[symm_area]) {
3145 switch (brush.boundary_deform_type) {
3147 bend_data_init_grids(subdiv_ccg, *ss.cache->boundaries[symm_area]);
3148 break;
3150 slide_data_init_grids(subdiv_ccg, *ss.cache->boundaries[symm_area]);
3151 break;
3153 twist_data_init_grids(subdiv_ccg, *ss.cache->boundaries[symm_area]);
3154 break;
3158 /* Do nothing. These deform modes don't need any extra data to be precomputed. */
3159 break;
3160 }
3161
3163 subdiv_ccg, brush, ss.cache->initial_radius, *ss.cache->boundaries[symm_area]);
3164 }
3165}
3166
3167static void init_boundary_bmesh(Object &object,
3168 const Brush &brush,
3169 const ePaintSymmetryFlags symm_area)
3170{
3171 const SculptSession &ss = *object.runtime->sculpt_session;
3172 const bke::pbvh::Tree &pbvh = *bke::object::pbvh_get(object);
3173
3174 BMesh *bm = ss.bm;
3175
3176 ActiveVert initial_vert_ref = ss.active_vert();
3177 if (std::holds_alternative<std::monostate>(initial_vert_ref)) {
3178 return;
3179 }
3180
3181 std::optional<BMVert *> initial_vert;
3182 if (ss.cache->mirror_symmetry_pass == 0) {
3183 initial_vert = std::get<BMVert *>(initial_vert_ref);
3184 }
3185 else {
3186 BMVert *active_vert = std::get<BMVert *>(initial_vert_ref);
3187 float3 location = symmetry_flip(active_vert->co, symm_area);
3188 initial_vert = nearest_vert_calc_bmesh(pbvh, location, ss.cache->radius_squared, false);
3189 }
3190
3191 if (!initial_vert) {
3192 return;
3193 }
3194
3196 object, &brush, *initial_vert, ss.cache->initial_radius);
3197
3198 if (ss.cache->boundaries[symm_area]) {
3199 switch (brush.boundary_deform_type) {
3201 bend_data_init_bmesh(bm, *ss.cache->boundaries[symm_area]);
3202 break;
3204 slide_data_init_bmesh(bm, *ss.cache->boundaries[symm_area]);
3205 break;
3207 twist_data_init_bmesh(bm, *ss.cache->boundaries[symm_area]);
3208 break;
3212 /* Do nothing. These deform modes don't need any extra data to be precomputed. */
3213 break;
3214 }
3215
3217 }
3218}
3219
3220static float get_mesh_strength(const SculptSession &ss, const Brush &brush)
3221{
3222 const int symm_area = ss.cache->mirror_symmetry_pass;
3223 SculptBoundary &boundary = *ss.cache->boundaries[symm_area];
3224
3225 const float strength = ss.cache->bstrength;
3226
3227 switch (brush.boundary_deform_type) {
3229 const float disp = strength * displacement_from_grab_delta_get(ss, boundary);
3230 float angle_factor = disp / ss.cache->radius;
3231 /* Angle Snapping when inverting the brush. */
3232 if (ss.cache->toggle_settings.invert) {
3233 angle_factor = floorf(angle_factor * 10) / 10.0f;
3234 }
3235 return angle_factor * M_PI;
3236 }
3238 return strength * displacement_from_grab_delta_get(ss, boundary);
3239 }
3241 return strength * displacement_from_grab_delta_get(ss, boundary);
3242 }
3244 return strength;
3246 const float disp = strength * displacement_from_grab_delta_get(ss, boundary);
3247 float angle_factor = disp / ss.cache->radius;
3248 /* Angle Snapping when inverting the brush. */
3249 if (ss.cache->toggle_settings.invert) {
3250 angle_factor = floorf(angle_factor * 10) / 10.0f;
3251 }
3252 return angle_factor * M_PI;
3253 }
3255 return strength;
3256 }
3257
3259 return 0.0f;
3260}
3261
3262void do_boundary_brush(const Depsgraph &depsgraph,
3263 const Sculpt &sd,
3264 Object &ob,
3265 const IndexMask &node_mask)
3266{
3271
3272 const ePaintSymmetryFlags symm_area = ss.cache->mirror_symmetry_pass;
3274 switch (pbvh.type()) {
3276 init_boundary_mesh(depsgraph, ob, brush, symm_area);
3277 break;
3279 init_boundary_grids(ob, brush, symm_area);
3280 break;
3282 init_boundary_bmesh(ob, brush, symm_area);
3283 break;
3284 }
3285 }
3286
3287 /* No active boundary under the cursor. */
3288 if (!ss.cache->boundaries[symm_area]) {
3289 return;
3290 }
3291
3292 const float strength = get_mesh_strength(ss, brush);
3293
3294 switch (brush.boundary_deform_type) {
3296 do_bend_brush(depsgraph,
3297 sd,
3298 ob,
3299 node_mask,
3300 *ss.cache->boundaries[symm_area],
3301 strength,
3302 eBrushDeformTarget(brush.deform_target));
3303 break;
3305 do_slide_brush(depsgraph,
3306 sd,
3307 ob,
3308 node_mask,
3309 *ss.cache->boundaries[symm_area],
3310 strength,
3311 eBrushDeformTarget(brush.deform_target));
3312 break;
3314 do_inflate_brush(depsgraph,
3315 sd,
3316 ob,
3317 node_mask,
3318 *ss.cache->boundaries[symm_area],
3319 strength,
3320 eBrushDeformTarget(brush.deform_target));
3321 break;
3323 do_grab_brush(depsgraph,
3324 sd,
3325 ob,
3326 node_mask,
3327 *ss.cache->boundaries[symm_area],
3328 strength,
3329 eBrushDeformTarget(brush.deform_target));
3330 break;
3332 do_twist_brush(depsgraph,
3333 sd,
3334 ob,
3335 node_mask,
3336 *ss.cache->boundaries[symm_area],
3337 strength,
3338 eBrushDeformTarget(brush.deform_target));
3339 break;
3341 do_smooth_brush(depsgraph,
3342 sd,
3343 ob,
3344 node_mask,
3345 *ss.cache->boundaries[symm_area],
3346 strength,
3347 eBrushDeformTarget(brush.deform_target));
3348 break;
3349 }
3350}
3351
3353
3354/* -------------------------------------------------------------------- */
3357
3358std::unique_ptr<SculptBoundary> data_init(const Depsgraph &depsgraph,
3359 Object &object,
3360 const Brush *brush,
3361 const int initial_vert,
3362 const float radius)
3363{
3364 /* TODO: Temporary bridge method to help in refactoring, this method should be deprecated
3365 * entirely. */
3366 const SculptSession &ss = *object.runtime->sculpt_session;
3368
3369 switch (pbvh.type()) {
3370 case (bke::pbvh::Type::Mesh): {
3371 return data_init_mesh(depsgraph, object, brush, initial_vert, radius);
3372 }
3373 case (bke::pbvh::Type::Grids): {
3375 const SubdivCCGCoord vert = SubdivCCGCoord::from_index(key, initial_vert);
3376 return data_init_grids(object, brush, vert, radius);
3377 }
3378 case (bke::pbvh::Type::BMesh): {
3379 BMVert *vert = BM_vert_at_index(ss.bm, initial_vert);
3380 return data_init_bmesh(object, brush, vert, radius);
3381 }
3382 }
3383
3385 return nullptr;
3386}
3387
3388std::unique_ptr<SculptBoundary> data_init_mesh(const Depsgraph &depsgraph,
3389 Object &object,
3390 const Brush *brush,
3391 const int initial_vert,
3392 const float radius)
3393{
3395 SculptSession &ss = *object.runtime->sculpt_session;
3396
3398
3399 Mesh &mesh = *id_cast<Mesh *>(object.data);
3400 const OffsetIndices faces = mesh.faces();
3401 const Span<int> corner_verts = mesh.corner_verts();
3402 const bke::AttributeAccessor attributes = mesh.attributes();
3403 const GroupedSpan<int> vert_to_face_map = mesh.vert_to_face_map();
3404 const VArraySpan hide_poly = *attributes.lookup<bool>(".hide_poly", bke::AttrDomain::Face);
3405 const VArraySpan hide_vert = *attributes.lookup<bool>(".hide_vert", bke::AttrDomain::Point);
3406
3407 const Span<float3> positions_eval = bke::pbvh::vert_positions_eval(depsgraph, object);
3408
3409 const std::optional<int> boundary_initial_vert = get_closest_boundary_vert_mesh(
3410 object,
3411 vert_to_face_map,
3412 positions_eval,
3413 hide_vert,
3414 hide_poly,
3415 ss.boundary_info_cache->verts,
3416 initial_vert,
3417 radius);
3418
3419 if (!boundary_initial_vert) {
3420 return nullptr;
3421 }
3422
3423 /* Starting from a vertex that is the limit of a boundary is ambiguous, so return nullptr instead
3424 * of forcing a random active boundary from a corner. */
3425 /* TODO: Investigate whether initial_vert should actually be boundary_initial_vert. If
3426 * initial_vert is correct, the above comment and the docstring for the relevant function should
3427 * be fixed. */
3429 corner_verts,
3430 vert_to_face_map,
3431 hide_vert,
3432 hide_poly,
3433 ss.boundary_info_cache->verts,
3434 initial_vert))
3435 {
3436 return nullptr;
3437 }
3438
3439 std::unique_ptr<SculptBoundary> boundary = std::make_unique<SculptBoundary>();
3440 *boundary = {};
3441
3442 const int boundary_initial_vert_index = *boundary_initial_vert;
3443 boundary->initial_vert_i = boundary_initial_vert_index;
3444 boundary->initial_vert_position = positions_eval[boundary_initial_vert_index];
3445
3446 indices_init_mesh(object,
3447 faces,
3448 corner_verts,
3449 vert_to_face_map,
3450 hide_vert,
3451 hide_poly,
3452 ss.boundary_info_cache->verts,
3453 positions_eval,
3454 *boundary_initial_vert,
3455 *boundary);
3456
3457 const float boundary_radius = brush ? radius * (1.0f + brush->boundary_offset) : radius;
3458 edit_data_init_mesh(faces,
3459 corner_verts,
3460 vert_to_face_map,
3461 positions_eval,
3462 hide_vert,
3463 hide_poly,
3464 boundary_initial_vert_index,
3465 boundary_radius,
3466 *boundary);
3467
3468 return boundary;
3469}
3470
3471std::unique_ptr<SculptBoundary> data_init_grids(Object &object,
3472 const Brush *brush,
3473 const SubdivCCGCoord initial_vert,
3474 const float radius)
3475{
3477 SculptSession &ss = *object.runtime->sculpt_session;
3478
3480
3481 Mesh &mesh = *id_cast<Mesh *>(object.data);
3482 const OffsetIndices faces = mesh.faces();
3483 const Span<int> corner_verts = mesh.corner_verts();
3484 const SubdivCCG &subdiv_ccg = *ss.subdiv_ccg;
3485 const Span<float3> positions = subdiv_ccg.positions;
3486 const CCGKey &key = BKE_subdiv_ccg_key_top_level(subdiv_ccg);
3487
3488 const std::optional<SubdivCCGCoord> boundary_initial_vert = get_closest_boundary_vert_grids(
3489 object,
3490 faces,
3491 corner_verts,
3492 subdiv_ccg,
3493 ss.boundary_info_cache->verts,
3494 ss.boundary_info_cache->edges,
3495 initial_vert,
3496 radius);
3497
3498 if (!boundary_initial_vert) {
3499 return nullptr;
3500 }
3501
3502 /* Starting from a vertex that is the limit of a boundary is ambiguous, so return nullptr instead
3503 * of forcing a random active boundary from a corner. */
3505 corner_verts,
3506 subdiv_ccg,
3507 ss.boundary_info_cache->verts,
3508 ss.boundary_info_cache->edges,
3509 initial_vert))
3510 {
3511 return nullptr;
3512 }
3513
3514 std::unique_ptr<SculptBoundary> boundary = std::make_unique<SculptBoundary>();
3515 *boundary = {};
3516
3517 SubdivCCGCoord boundary_vert = *boundary_initial_vert;
3518 const int boundary_initial_vert_index = boundary_vert.to_index(key);
3519 boundary->initial_vert_i = boundary_initial_vert_index;
3520 boundary->initial_vert_position = positions[boundary_initial_vert_index];
3521
3522 indices_init_grids(object,
3523 faces,
3524 corner_verts,
3525 subdiv_ccg,
3526 ss.boundary_info_cache->verts,
3527 ss.boundary_info_cache->edges,
3528 boundary_vert,
3529 *boundary);
3530
3531 const float boundary_radius = brush ? radius * (1.0f + brush->boundary_offset) : radius;
3532 edit_data_init_grids(subdiv_ccg, boundary_initial_vert_index, boundary_radius, *boundary);
3533
3534 return boundary;
3535}
3536
3537std::unique_ptr<SculptBoundary> data_init_bmesh(Object &object,
3538 const Brush *brush,
3539 BMVert *initial_vert,
3540 const float radius)
3541{
3543 SculptSession &ss = *object.runtime->sculpt_session;
3544
3547
3548 const std::optional<BMVert *> boundary_initial_vert = get_closest_boundary_vert_bmesh(
3549 object, ss.bm, *initial_vert, radius);
3550
3551 if (!boundary_initial_vert) {
3552 return nullptr;
3553 }
3554
3555 /* Starting from a vertex that is the limit of a boundary is ambiguous, so return nullptr instead
3556 * of forcing a random active boundary from a corner. */
3557 if (!is_vert_in_editable_boundary_bmesh(*initial_vert)) {
3558 return nullptr;
3559 }
3560
3561 std::unique_ptr<SculptBoundary> boundary = std::make_unique<SculptBoundary>();
3562 *boundary = {};
3563
3564 const int boundary_initial_vert_index = BM_elem_index_get(*boundary_initial_vert);
3565 boundary->initial_vert_i = boundary_initial_vert_index;
3566 boundary->initial_vert_position = (*boundary_initial_vert)->co;
3567
3568 indices_init_bmesh(object, ss.bm, **boundary_initial_vert, *boundary);
3569
3570 const float boundary_radius = brush ? radius * (1.0f + brush->boundary_offset) : radius;
3571 edit_data_init_bmesh(ss.bm, boundary_initial_vert_index, boundary_radius, *boundary);
3572
3573 return boundary;
3574}
3575
3577
3578/* -------------------------------------------------------------------- */
3583
3584std::unique_ptr<SculptBoundaryPreview> preview_data_init(const Depsgraph &depsgraph,
3585 Object &object,
3586 const Brush *brush,
3587 const float radius)
3588{
3589 const SculptSession &ss = *object.runtime->sculpt_session;
3590 ActiveVert initial_vert = ss.active_vert();
3591
3592 if (std::holds_alternative<std::monostate>(initial_vert)) {
3593 return nullptr;
3594 }
3595
3597
3598 std::unique_ptr<SculptBoundary> boundary = nullptr;
3599 switch (pbvh.type()) {
3601 boundary = data_init_mesh(depsgraph, object, brush, std::get<int>(initial_vert), radius);
3602 break;
3604 const SubdivCCG &subdiv_ccg = *ss.subdiv_ccg;
3605 const CCGKey key = BKE_subdiv_ccg_key_top_level(subdiv_ccg);
3607 object, brush, SubdivCCGCoord::from_index(key, std::get<int>(initial_vert)), radius);
3608 break;
3609 }
3611 boundary = data_init_bmesh(object, brush, std::get<BMVert *>(initial_vert), radius);
3612 break;
3613 }
3614
3615 if (boundary == nullptr) {
3616 return nullptr;
3617 }
3618 std::unique_ptr<SculptBoundaryPreview> preview = std::make_unique<SculptBoundaryPreview>();
3619 preview->edges = boundary->edges;
3620 preview->pivot_position = boundary->pivot_position;
3621 preview->initial_vert_position = boundary->initial_vert_position;
3622
3623 return preview;
3624}
3625
3626void edges_preview_draw(const uint gpuattr,
3627 SculptSession &ss,
3628 const float outline_col[3],
3629 const float outline_alpha)
3630{
3631 if (!ss.boundary_preview) {
3632 return;
3633 }
3634 immUniformColor3fvAlpha(outline_col, outline_alpha);
3635 GPU_line_width(2.0f);
3636 immBegin(GPU_PRIM_LINES, ss.boundary_preview->edges.size() * 2);
3637 for (const int i : ss.boundary_preview->edges.index_range()) {
3638 immVertex3fv(gpuattr, ss.boundary_preview->edges[i].first);
3639 immVertex3fv(gpuattr, ss.boundary_preview->edges[i].second);
3640 }
3641 immEnd();
3642}
3643
3645{
3646 if (!ss.boundary_preview) {
3647 return;
3648 }
3649 immUniformColor4f(1.0f, 1.0f, 1.0f, 0.8f);
3650 GPU_line_width(2.0f);
3652 immVertex3fv(gpuattr, ss.boundary_preview->pivot_position);
3653 immVertex3fv(gpuattr, ss.boundary_preview->initial_vert_position);
3654 immEnd();
3655}
3656
3658
3659} // namespace blender::ed::sculpt_paint::boundary
A BVH for high poly meshes.
#define M_PI
Object is a sort of wrapper for general info.
#define PRF_scope(category)
#define BLI_assert_unreachable()
#define BLI_NOINLINE
#define BM_ELEM_CD_GET_FLOAT(ele, offset)
#define BM_elem_index_get(ele)
#define BM_elem_flag_test(ele, hflag)
Span< T > as_span() const
Definition BLI_array.hh:254
MutableSpan< T > as_mutable_span()
Definition BLI_array.hh:259
IndexRange index_range() const
Definition BLI_array.hh:371
bool is_empty() const
Definition BLI_array.hh:275
constexpr IndexRange()=default
constexpr int64_t size() const
Definition BLI_span.hh:499
constexpr Span< T > as_span() const
Definition BLI_span.hh:667
constexpr IndexRange index_range() const
Definition BLI_span.hh:676
int64_t size() const
Definition BLI_set.hh:606
bool add(const Key &key)
Definition BLI_set.hh:248
constexpr int64_t size() const
Definition BLI_span.hh:256
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
constexpr bool is_empty() const
Definition BLI_span.hh:264
GAttributeReader lookup(const StringRef name) const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
#define fmodf(x, y)
#define position
VecBase< float, D > constexpr mod(VecOp< float, D >, VecOp< float, D >) RET
float distance(float, float) RET
void gather(const GVArray &src, const IndexMask &indices, GMutableSpan dst, exec_mode::Mode mode=exec_mode::parallel)
IndexRange grid_range(const int grid_area, const int grid)
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
Span< float3 > vert_positions_eval(const Depsgraph &depsgraph, const Object &object_orig)
Definition pbvh.cc:933
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)
static void slide_data_init_bmesh(BMesh *bm, SculptBoundary &boundary)
static BLI_NOINLINE void calc_inflate_position(const Span< float3 > positions, const Span< float3 > normals, const Span< float > factors, const MutableSpan< float3 > new_positions)
static void slide_data_init_grids(const SubdivCCG &subdiv_ccg, SculptBoundary &boundary)
static void twist_data_init_grids(const SubdivCCG &subdiv_ccg, SculptBoundary &boundary)
static void calc_slide_bmesh(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const Span< int > vert_propagation_steps, const Span< float > vert_factors, const Span< float3 > vert_slide_directions, bke::pbvh::BMeshNode &node, LocalDataBMesh &tls, const float3 symmetry_pivot, const float strength, const eBrushDeformTarget deform_target)
static BLI_NOINLINE void calc_slide_position(const Span< float3 > positions, const Span< float3 > directions, const Span< float > factors, const MutableSpan< float3 > new_positions)
static void calc_twist_mesh(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const Span< int > vert_propagation_steps, const Span< float > vert_factors, const bke::pbvh::MeshNode &node, const float3 twist_pivot_position, const float3 twist_axis, const float3 symmetry_pivot, const float strength, const eBrushDeformTarget deform_target, const PositionDeformData &position_data)
static void calc_twist_bmesh(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const Span< int > vert_propagation_steps, const Span< float > vert_factors, const float3 twist_pivot_position, const float3 twist_axis, bke::pbvh::BMeshNode &node, LocalDataBMesh &tls, const float3 symmetry_pivot, const float strength, const eBrushDeformTarget deform_target)
void pivot_line_preview_draw(const uint gpuattr, SculptSession &ss)
static void indices_init_bmesh(Object &object, BMesh *bm, BMVert &initial_boundary_vert, SculptBoundary &boundary)
static void init_boundary_grids(Object &object, const Brush &brush, const ePaintSymmetryFlags symm_area)
static void edit_data_init_grids(const SubdivCCG &subdiv_ccg, const int initial_vert_i, const float radius, SculptBoundary &boundary)
static BLI_NOINLINE void calc_average_position(const Span< float3 > vert_positions, const Span< int > vert_propagation_steps, const GroupedSpan< int > neighbors, const Span< int > propagation_steps, const MutableSpan< float > factors, const MutableSpan< float3 > average_positions)
std::unique_ptr< SculptBoundary > data_init_bmesh(Object &object, const Brush *brush, BMVert *initial_vert, const float radius)
static void init_falloff_bmesh(BMesh *bm, const Brush &brush, const float radius, SculptBoundary &boundary)
static bool check_counts(const int neighbor_count, const int boundary_vertex_count)
static void calc_inflate_mesh(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const Span< int > vert_propagation_steps, const Span< float > vert_factors, const bke::pbvh::MeshNode &node, const float3 symmetry_pivot, const float strength, const eBrushDeformTarget deform_target, const PositionDeformData &position_data)
std::unique_ptr< SculptBoundaryPreview > preview_data_init(const Depsgraph &depsgraph, Object &object, const Brush *brush, const float radius)
static void indices_init_mesh(Object &object, const OffsetIndices< int > faces, const Span< int > corner_verts, const GroupedSpan< int > vert_to_face, const Span< bool > hide_vert, const Span< bool > hide_poly, const BitSpan boundary_verts, const Span< float3 > vert_positions, const int initial_boundary_vert, SculptBoundary &boundary)
static void calc_smooth_bmesh(const Sculpt &sd, Object &object, const Span< int > vert_propagation_steps, const Span< float > vert_factors, bke::pbvh::BMeshNode &node, LocalDataBMesh &tls, const float3 symmetry_pivot, const float strength, const eBrushDeformTarget deform_target)
static void twist_data_init_bmesh(BMesh *bm, SculptBoundary &boundary)
static BLI_NOINLINE void calc_smooth_position(const Span< float3 > positions, const Span< float3 > average_position, const Span< float > factors, const MutableSpan< float3 > new_positions)
static float get_mesh_strength(const SculptSession &ss, const Brush &brush)
static void calc_smooth_grids(const Sculpt &sd, Object &object, SubdivCCG &subdiv_ccg, const Span< int > vert_propagation_steps, const Span< float > vert_factors, const bke::pbvh::GridsNode &node, LocalDataGrids &tls, const float3 symmetry_pivot, const float strength, const eBrushDeformTarget deform_target)
static void do_slide_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask, const SculptBoundary &boundary, const float strength, const eBrushDeformTarget deform_target)
static void init_boundary_mesh(const Depsgraph &depsgraph, Object &object, const Brush &brush, const ePaintSymmetryFlags symm_area)
static BLI_NOINLINE void calc_twist_position(const Span< float3 > positions, const float3 pivot_point, const float3 pivot_axis, const Span< float > factors, const MutableSpan< float3 > new_positions)
static void bend_data_init_grids(const SubdivCCG &subdiv_ccg, SculptBoundary &boundary)
static void calc_slide_mesh(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const Span< int > vert_propagation_steps, const Span< float > vert_factors, const Span< float3 > vert_slide_directions, const bke::pbvh::MeshNode &node, const float3 symmetry_pivot, const float strength, const eBrushDeformTarget deform_target, const PositionDeformData &position_data)
static void indices_init_grids(Object &object, const OffsetIndices< int > faces, const Span< int > corner_verts, const SubdivCCG &subdiv_ccg, const BitSpan boundary_verts, const Set< OrderedEdge > &boundary_edges, const SubdivCCGCoord initial_vert, SculptBoundary &boundary)
static void calc_bend_mesh(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const Span< int > vert_propagation_steps, const Span< float > vert_factors, const Span< float3 > vert_pivot_positions, const Span< float3 > vert_pivot_axes, const bke::pbvh::MeshNode &node, const float3 symmetry_pivot, const float strength, const eBrushDeformTarget deform_target, const PositionDeformData &position_data)
static void calc_bend_grids(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, SubdivCCG &subdiv_ccg, const Span< int > vert_propagation_steps, const Span< float > vert_factors, const Span< float3 > vert_pivot_positions, const Span< float3 > vert_pivot_axes, const bke::pbvh::GridsNode &node, LocalDataGrids &tls, const float3 symmetry_pivot, const float strength, const eBrushDeformTarget deform_target)
static bool is_vert_in_editable_boundary_bmesh(BMVert &initial_vert)
static void init_boundary_bmesh(Object &object, const Brush &brush, const ePaintSymmetryFlags symm_area)
static bool is_vert_in_editable_boundary_mesh(const OffsetIndices< int > faces, const Span< int > corner_verts, const GroupedSpan< int > vert_to_face, const Span< bool > hide_vert, const Span< bool > hide_poly, const BitSpan boundary_verts, const int initial_vert)
static BLI_NOINLINE void calc_bend_position(const Span< float3 > positions, const Span< float3 > pivot_positions, const Span< float3 > pivot_axes, const Span< float > factors, const MutableSpan< float3 > new_positions)
static BLI_NOINLINE void filter_uninitialized_verts(const Span< int > propagation_steps, const MutableSpan< float > factors)
static void bend_data_init_mesh(const Span< float3 > vert_positions, const Span< float3 > vert_normals, SculptBoundary &boundary)
static void edit_data_init_bmesh(BMesh *bm, const int initial_vert_i, const float radius, SculptBoundary &boundary)
static void calc_inflate_grids(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, SubdivCCG &subdiv_ccg, const Span< int > vert_propagation_steps, const Span< float > vert_factors, const bke::pbvh::GridsNode &node, LocalDataGrids &tls, const float3 symmetry_pivot, const float strength, const eBrushDeformTarget deform_target)
static void populate_twist_data(const Span< float3 > positions, SculptBoundary &boundary)
static std::pair< float, float > calc_boundary_falloff(const SculptBoundary &boundary, const Brush &brush, const float radius, const int index)
static void twist_data_init_mesh(const Span< float3 > vert_positions, SculptBoundary &boundary)
static void calc_grab_bmesh(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const Span< int > vert_propagation_steps, const Span< float > vert_factors, bke::pbvh::BMeshNode &node, LocalDataBMesh &tls, const float3 grab_delta_symmetry, const float3 symmetry_pivot, const float strength, const eBrushDeformTarget deform_target)
std::unique_ptr< SculptBoundary > data_init(const Depsgraph &depsgraph, Object &object, const Brush *brush, const int initial_vert, const float radius)
static void do_grab_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask, const SculptBoundary &boundary, const float strength, const eBrushDeformTarget deform_target)
static void do_bend_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask, const SculptBoundary &boundary, const float strength, const eBrushDeformTarget deform_target)
void edges_preview_draw(const uint gpuattr, SculptSession &ss, const float outline_col[3], const float outline_alpha)
static float displacement_from_grab_delta_get(const SculptSession &ss, const SculptBoundary &boundary)
static void calc_twist_grids(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, SubdivCCG &subdiv_ccg, const Span< int > vert_propagation_steps, const Span< float > vert_factors, const float3 twist_pivot_position, const float3 twist_axis, const bke::pbvh::GridsNode &node, LocalDataGrids &tls, const float3 symmetry_pivot, const float strength, const eBrushDeformTarget deform_target)
static bool is_vert_in_editable_boundary_grids(const OffsetIndices< int > faces, const Span< int > corner_verts, const SubdivCCG &subdiv_ccg, const BitSpan boundary_verts, const Set< OrderedEdge > &boundary_edges, const SubdivCCGCoord initial_vert)
static std::optional< BMVert * > get_closest_boundary_vert_bmesh(Object &object, BMesh *bm, BMVert &initial_vert, const float radius)
std::unique_ptr< SculptBoundary > data_init_mesh(const Depsgraph &depsgraph, Object &object, const Brush *brush, const int initial_vert, const float radius)
static void calc_grab_mesh(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const Span< int > vert_propagation_steps, const Span< float > vert_factors, const bke::pbvh::MeshNode &node, const float3 grab_delta_symmetry, const float3 symmetry_pivot, const float strength, const eBrushDeformTarget deform_target, const PositionDeformData &position_data)
static void bend_data_init_bmesh(BMesh *bm, SculptBoundary &boundary)
static void calc_inflate_bmesh(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const Span< int > vert_propagation_steps, const Span< float > vert_factors, bke::pbvh::BMeshNode &node, LocalDataBMesh &tls, const float3 symmetry_pivot, const float strength, const eBrushDeformTarget deform_target)
static void calc_bend_bmesh(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const Span< int > vert_propagation_steps, const Span< float > vert_factors, const Span< float3 > vert_pivot_positions, const Span< float3 > vert_pivot_axes, bke::pbvh::BMeshNode &node, LocalDataBMesh &tls, const float3 symmetry_pivot, const float strength, const eBrushDeformTarget deform_target)
static void calc_grab_grids(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, SubdivCCG &subdiv_ccg, const Span< int > vert_propagation_steps, const Span< float > vert_factors, const bke::pbvh::GridsNode &node, LocalDataGrids &tls, const float3 grab_delta_symmetry, const float3 symmetry_pivot, const float strength, const eBrushDeformTarget deform_target)
void do_boundary_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &ob, const IndexMask &node_mask)
static std::optional< SubdivCCGCoord > get_closest_boundary_vert_grids(Object &object, const OffsetIndices< int > faces, const Span< int > corner_verts, const SubdivCCG &subdiv_ccg, const BitSpan boundary_verts, const Set< OrderedEdge > &boundary_edges, const SubdivCCGCoord initial_vert, const float radius)
static void calc_smooth_mesh(const Sculpt &sd, Object &object, const OffsetIndices< int > faces, const Span< int > corner_verts, const GroupedSpan< int > vert_to_face, const Span< bool > hide_poly, const Span< int > vert_propagation_steps, const Span< float > vert_factors, const bke::pbvh::MeshNode &node, LocalDataMesh &tls, const float3 symmetry_pivot, const float strength, const eBrushDeformTarget deform_target, const PositionDeformData &position_data)
static void edit_data_init_mesh(OffsetIndices< int > faces, Span< int > corner_verts, GroupedSpan< int > vert_to_face, Span< float3 > vert_positions, Span< bool > hide_vert, Span< bool > hide_poly, const int initial_vert_i, const float radius, SculptBoundary &boundary)
static void do_inflate_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask, const SculptBoundary &boundary, const float strength, const eBrushDeformTarget deform_target)
static void calc_slide_grids(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, SubdivCCG &subdiv_ccg, const Span< int > vert_propagation_steps, const Span< float > vert_factors, const Span< float3 > vert_slide_directions, const bke::pbvh::GridsNode &node, LocalDataGrids &tls, const float3 symmetry_pivot, const float strength, const eBrushDeformTarget deform_target)
static void do_twist_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask, const SculptBoundary &boundary, const float strength, const eBrushDeformTarget deform_target)
void ensure_boundary_info(Object &object)
Definition sculpt.cc:588
static void init_falloff_mesh(const Span< float > mask, const Brush &brush, const float radius, SculptBoundary &boundary)
static void init_falloff_grids(const SubdivCCG &subdiv_ccg, const Brush &brush, const float radius, SculptBoundary &boundary)
static void do_smooth_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask, const SculptBoundary &boundary, const float strength, const eBrushDeformTarget deform_target)
static void add_index(SculptBoundary &boundary, const int new_index, const float distance, Set< int, BOUNDARY_INDICES_BLOCK_SIZE > &included_verts)
static std::optional< int > get_closest_boundary_vert_mesh(Object &object, const GroupedSpan< int > vert_to_face, const Span< float3 > vert_positions, const Span< bool > hide_vert, const Span< bool > hide_poly, const BitSpan boundary_verts, const int initial_vert, const float radius)
static BLI_NOINLINE void calc_grab_position(const Span< float3 > positions, const float3 grab_delta, const Span< float > factors, const MutableSpan< float3 > new_positions)
std::unique_ptr< SculptBoundary > data_init_grids(Object &object, const Brush *brush, const SubdivCCGCoord initial_vert, const float radius)
bool vert_is_boundary(const GroupedSpan< int > vert_to_face_map, const Span< bool > hide_poly, const BitSpan boundary_verts, const int vert)
Definition sculpt.cc:620
static void slide_data_init_mesh(const Span< float3 > vert_positions, SculptBoundary &boundary)
MutableSpan< float3 > gather_grids_positions(const SubdivCCG &subdiv_ccg, const Span< int > grids, Vector< float3 > &positions)
void scatter_data_bmesh(Span< T > node_data, const Set< BMVert *, 0 > &verts, MutableSpan< T > dst)
Definition sculpt.cc:6577
void gather_bmesh_positions(const Set< BMVert *, 0 > &verts, MutableSpan< float3 > positions)
Definition sculpt.cc:6497
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
std::optional< int > nearest_vert_calc_mesh(const bke::pbvh::Tree &pbvh, const Span< float3 > vert_positions, const Span< bool > hide_vert, const float3 &location, const float max_distance, const bool use_original)
Definition sculpt.cc:730
GroupedSpan< int > calc_vert_neighbors(OffsetIndices< int > faces, Span< int > corner_verts, GroupedSpan< int > vert_to_face, Span< bool > hide_poly, Span< int > verts, Vector< int > &r_offset_data, Vector< int > &r_data)
Definition sculpt.cc:7949
void filter_translations(MutableSpan< float3 > translations, Span< float > factors)
Definition sculpt.cc:7827
Vector< BMVert *, 64 > BMeshNeighborVerts
void gather_data_bmesh(Span< T > src, const Set< BMVert *, 0 > &verts, MutableSpan< T > node_data)
Definition sculpt.cc:6545
bool stroke_is_first_brush_step_of_symmetry_pass(const StrokeCache &cache)
Definition sculpt.cc:667
float3 symmetry_flip(const float3 &src, const ePaintSymmetryFlags symm)
void orig_position_data_gather_bmesh(const BMLog &bm_log, const Set< BMVert *, 0 > &verts, MutableSpan< float3 > positions, MutableSpan< float3 > normals)
ePaintSymmetryFlags mesh_symmetry_xyz_get(const Object &object)
Definition sculpt.cc:192
void filter_verts_outside_symmetry_area(Span< float3 > positions, const float3 &pivot, ePaintSymmetryFlags symm, MutableSpan< float > factors)
Definition sculpt.cc:8216
void scale_factors(MutableSpan< float > factors, float strength)
Definition sculpt.cc:7856
void translations_from_new_positions(Span< float3 > new_positions, Span< int > verts, Span< float3 > old_positions, MutableSpan< float3 > translations)
Definition sculpt.cc:7889
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 scatter_data_mesh(Span< T > src, Span< int > indices, MutableSpan< T > dst)
Span< BMVert * > vert_neighbors_get_bmesh(BMVert &vert, BMeshNeighborVerts &r_neighbors)
Definition sculpt.cc:490
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)
void gather_data_mesh(Span< T > src, Span< int > indices, MutableSpan< T > dst)
OrigPositionData orig_position_data_get_grids(const Object &object, const bke::pbvh::GridsNode &node)
std::optional< BMVert * > nearest_vert_calc_bmesh(const bke::pbvh::Tree &pbvh, const float3 &location, const float max_distance, const bool use_original)
Definition sculpt.cc:831
std::optional< SubdivCCGCoord > nearest_vert_calc_grids(const bke::pbvh::Tree &pbvh, const SubdivCCG &subdiv_ccg, const float3 &location, const float max_distance, const bool use_original)
Definition sculpt.cc:777
Span< int > vert_neighbors_get_mesh(const OffsetIndices< int > faces, const Span< int > corner_verts, const GroupedSpan< int > vert_to_face, const Span< bool > hide_poly, const int vert, Vector< int > &r_neighbors)
Definition sculpt.cc:534
void scatter_data_grids(const SubdivCCG &subdiv_ccg, Span< T > node_data, Span< int > grids, MutableSpan< T > dst)
Definition sculpt.cc:6560
constexpr ParallelGrainSize grain_size(int grain_size)
T safe_rcp(const T &a)
T distance(const T &a, const T &b)
AxisSigned cross(const AxisSigned a, const AxisSigned b)
MatBase< T, NumCol, NumRow > normalize(const MatBase< T, NumCol, NumRow > &a)
T distance_squared(const VecBase< T, Size > &a, const VecBase< T, Size > &b)
float3 rotate_around_axis(const float3 &vector, const float3 &center, const float3 &axis, float angle)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
@ BRUSH_BOUNDARY_DEFORM_GRAB
@ BRUSH_BOUNDARY_DEFORM_SMOOTH
@ BRUSH_BOUNDARY_DEFORM_TWIST
@ BRUSH_BOUNDARY_DEFORM_EXPAND
@ BRUSH_BOUNDARY_DEFORM_BEND
@ BRUSH_BOUNDARY_DEFORM_INFLATE
void immEnd()
std::variant< std::monostate, int, BMVert * > ActiveVert
Definition BKE_paint.hh:357
unsigned int uint
Definition BKE_text.h:55
float dist_signed_to_plane_v3(const float p[3], const float plane[4])
Definition math_geom.cc:511
void immBegin(GPUPrimType, uint vertex_len)
@ BRUSH_BOUNDARY_FALLOFF_LOOP
@ BRUSH_BOUNDARY_FALLOFF_CONSTANT
@ BRUSH_BOUNDARY_FALLOFF_RADIUS
@ BRUSH_BOUNDARY_FALLOFF_LOOP_INVERT
void plane_from_point_normal_v3(float r_plane[4], const float plane_co[3], const float plane_no[3])
Definition math_geom.cc:225
void GPU_line_width(float width)
Definition gpu_state.cc:151
CCGKey BKE_subdiv_ccg_key_top_level(const SubdivCCG &subdiv_ccg)
VecBase< float, 4 > float4
void BKE_subdiv_ccg_neighbor_coords_get(const SubdivCCG &subdiv_ccg, const SubdivCCGCoord &coord, bool include_duplicates, SubdivCCGNeighbors &r_neighbors)
void BKE_curvemapping_init(CurveMapping *cumap)
BMesh const char void * data
int CustomData_get_offset_named(const CustomData *data, eCustomDataType type, StringRef name)
int BM_mesh_elem_count(BMesh *bm, const char htype)
void immUniformColor4f(float r, float g, float b, float a)
float BKE_brush_curve_strength(eBrushCurvePreset preset, const CurveMapping *cumap, float distance, float brush_radius)
Definition brush.cc:1691
BLI_INLINE BMVert * BM_vert_at_index(BMesh *bm, const int index)
int CCG_grid_xy_to_index(const int grid_size, const int x, const int y)
Definition BKE_ccg.hh:75
const Brush * BKE_paint_brush_for_read(const Paint *paint)
void immVertex3fv(uint attr_id, const float data[3])
@ BRUSH_DEFORM_TARGET_CLOTH_SIM
@ BRUSH_DEFORM_TARGET_GEOMETRY
VecBase< float, 3 > float3
MINLINE float len_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
void immUniformColor3fvAlpha(const float rgb[3], float a)
const Set< BMVert *, 0 > & BKE_pbvh_bmesh_node_unique_verts(bke::pbvh::BMeshNode *node)
void rotate_v3_v3v3fl(float r[3], const float p[3], const float axis[3], float angle)
#define floorf
#define BOUNDARY_STEPS_NONE
#define BOUNDARY_VERTEX_NONE
CustomData vdata
bke::ObjectRuntime * runtime
std::unique_ptr< SculptBoundaryInfoCache > boundary_info_cache
Definition BKE_paint.hh:458
ed::sculpt_paint::StrokeCache * cache
Definition BKE_paint.hh:409
std::unique_ptr< SculptBoundaryPreview > boundary_preview
Definition BKE_paint.hh:438
static SubdivCCGCoord from_index(const CCGKey &key, int index)
int to_index(const CCGKey &key) const
Span< SubdivCCGCoord > duplicates() const
SubdivCCGNeighborCoords coords
Span< SubdivCCGCoord > unique() const
Array< float3 > positions
Array< float3 > normals
BitGroupVector grid_hidden
Array< float > masks
std::unique_ptr< auto_mask::Cache > automasking
std::unique_ptr< cloth::SimulationData > cloth_sim
std::array< std::unique_ptr< boundary::SculptBoundary >, PAINT_SYMM_AREAS > boundaries