Blender V5.3
sculpt_transform.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
9#include "MEM_guardedalloc.h"
10
11#include "BLI_array_utils.hh"
13#include "BLI_math_matrix.hh"
14#include "BLI_math_matrix_c.hh"
16#include "BLI_math_vector_c.hh"
18#include "BLI_span.hh"
19
20#include "BKE_attribute.hh"
21#include "BKE_brush.hh"
22#include "BKE_context.hh"
23#include "BKE_kelvinlet.h"
24#include "BKE_layer.hh"
25#include "BKE_mesh.hh"
26#include "BKE_object_types.hh"
27#include "BKE_paint.hh"
28#include "BKE_paint_bvh.hh"
29#include "BKE_paint_types.hh"
30#include "BKE_subdiv_ccg.hh"
31
32#include "WM_api.hh"
33#include "WM_types.hh"
34
35#include "ED_screen.hh"
36#include "ED_sculpt.hh"
37#include "ED_view3d.hh"
38
39#include "../paint_intern.hh"
40#include "mesh_brush_common.hh"
41#include "paint_mask.hh"
42#include "sculpt_filter.hh"
43#include "sculpt_intern.hh"
44#include "sculpt_undo.hh"
45
46#include "RNA_access.hh"
47#include "RNA_define.hh"
48
49#include "bmesh.hh"
50
51#include <cmath>
52#include <cstdlib>
53
55
56void init_transform(bContext *C, Object &ob, const float mval_fl[2], const char *undo_name)
57{
58 const Scene &scene = *CTX_data_scene(C);
60 Sculpt &sd = *(ts.sculpt);
62 Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
63
67
71
72 /* Pivot only transformations don't push undo steps */
74 return;
75 }
76
77 BKE_sculptsession_update_for_edit(depsgraph, &ob, false);
78 undo::push_begin_ex(scene, ob, undo_name);
79
81
82 filter::cache_init(C, ob, sd, undo::Type::Position, mval_fl, 5.0, 1.0f);
83
86 }
87 else {
89 }
90}
91
93{
95 ARegion *region = CTX_wm_region(C);
96
97 /* Update the viewport navigation rotation origin. */
100
101 ED_region_tag_redraw(region);
103}
104
105static std::array<float4x4, 8> transform_matrices_init(const SculptSession &ss,
106 const ePaintSymmetryFlags symm,
107 const TransformDisplacementMode t_mode)
108{
109 std::array<float4x4, 8> mats;
110
111 float3 final_pivot_pos, d_t, d_s;
112 float d_r[4];
113 float t_mat[4][4], r_mat[4][4], s_mat[4][4], pivot_mat[4][4], pivot_imat[4][4],
114 transform_mat[4][4];
115
116 float start_pivot_pos[3], start_pivot_rot[4], start_pivot_scale[3];
117 switch (t_mode) {
119 copy_v3_v3(start_pivot_pos, ss.init_pivot_pos);
120 copy_v4_v4(start_pivot_rot, ss.init_pivot_rot);
121 copy_v3_v3(start_pivot_scale, ss.init_pivot_scale);
122 break;
124 copy_v3_v3(start_pivot_pos, ss.prev_pivot_pos);
125 copy_v4_v4(start_pivot_rot, ss.prev_pivot_rot);
126 copy_v3_v3(start_pivot_scale, ss.prev_pivot_scale);
127 break;
128 }
129
130 for (int i = 0; i < PAINT_SYMM_AREAS; i++) {
132
133 copy_v3_v3(final_pivot_pos, ss.pivot_pos);
134
135 unit_m4(pivot_mat);
136
137 unit_m4(t_mat);
138 unit_m4(r_mat);
139 unit_m4(s_mat);
140
141 /* Translation matrix. */
142 sub_v3_v3v3(d_t, ss.pivot_pos, start_pivot_pos);
143 d_t = flip_v3_by_symm_area(d_t, symm, v_symm, ss.init_pivot_pos);
144 translate_m4(t_mat, d_t[0], d_t[1], d_t[2]);
145
146 /* Rotation matrix. */
147 sub_qt_qtqt(d_r, ss.pivot_rot, start_pivot_rot);
148 normalize_qt(d_r);
149 flip_quat_by_symm_area(d_r, symm, v_symm, ss.init_pivot_pos);
150 quat_to_mat4(r_mat, d_r);
151
152 /* Scale matrix. */
153 sub_v3_v3v3(d_s, ss.pivot_scale, start_pivot_scale);
154 add_v3_fl(d_s, 1.0f);
155 size_to_mat4(s_mat, d_s);
156
157 /* Pivot matrix. */
158 final_pivot_pos = flip_v3_by_symm_area(final_pivot_pos, symm, v_symm, start_pivot_pos);
159 translate_m4(pivot_mat, final_pivot_pos[0], final_pivot_pos[1], final_pivot_pos[2]);
160 invert_m4_m4(pivot_imat, pivot_mat);
161
162 /* Final transform matrix. */
163 mul_m4_m4m4(transform_mat, r_mat, t_mat);
164 mul_m4_m4m4(transform_mat, transform_mat, s_mat);
165 mul_m4_m4m4(mats[i].ptr(), transform_mat, pivot_imat);
166 mul_m4_m4m4(mats[i].ptr(), pivot_mat, mats[i].ptr());
167 }
168
169 return mats;
170}
171
172static constexpr float transform_mirror_max_distance_eps = 0.00002f;
173
179
181 const Span<float3> positions,
182 const std::array<float4x4, 8> &transform_mats,
183 const MutableSpan<float3> translations)
184{
185 for (const int i : positions.index_range()) {
186 const ePaintSymmetryAreas symm_area = get_vertex_symm_area(positions[i]);
187 const float3 transformed = math::transform_point(transform_mats[symm_area], positions[i]);
188 translations[i] = transformed - positions[i];
189 }
190}
191
193 const ePaintSymmetryFlags symm,
194 const MutableSpan<float3> translations)
195{
196 if ((symm & (PAINT_SYMM_X | PAINT_SYMM_Y | PAINT_SYMM_Z)) == 0) {
197 return;
198 }
199 for (const int i : positions.index_range()) {
200 if ((symm & PAINT_SYMM_X) && (std::abs(positions[i].x) < transform_mirror_max_distance_eps)) {
201 translations[i].x = 0.0f;
202 }
203 if ((symm & PAINT_SYMM_Y) && (std::abs(positions[i].y) < transform_mirror_max_distance_eps)) {
204 translations[i].y = 0.0f;
205 }
206 if ((symm & PAINT_SYMM_Z) && (std::abs(positions[i].z) < transform_mirror_max_distance_eps)) {
207 translations[i].z = 0.0f;
208 }
209 }
210}
211
212static void transform_node_mesh(const Sculpt &sd,
213 const std::array<float4x4, 8> &transform_mats,
214 const MeshAttributeData &attribute_data,
216 Object &object,
218 const PositionDeformData &position_data)
219{
220 SculptSession &ss = *object.runtime->sculpt_session;
221
222 const Span<int> verts = node.verts();
223 const OrigPositionData orig_data = orig_position_data_get_mesh(object, node);
224
225 tls.factors.resize(verts.size());
226 const MutableSpan<float> factors = tls.factors;
227 fill_factor_from_hide_and_mask(attribute_data.hide_vert, attribute_data.mask, verts, factors);
228
229 tls.translations.resize(verts.size());
230 const MutableSpan<float3> translations = tls.translations;
231 calc_symm_area_transform_translations(orig_data.positions, transform_mats, translations);
232 scale_translations(translations, factors);
233
234 const ePaintSymmetryFlags symm = mesh_symmetry_xyz_get(object);
235 filter_translations_with_symmetry(orig_data.positions, symm, translations);
236
237 clip_and_lock_translations(sd, ss, position_data.eval, verts, translations);
238 position_data.deform(translations, verts);
239}
240
241static void transform_node_grids(const Sculpt &sd,
242 const std::array<float4x4, 8> &transform_mats,
244 Object &object,
246{
247 SculptSession &ss = *object.runtime->sculpt_session;
248 SubdivCCG &subdiv_ccg = *ss.subdiv_ccg;
249 const CCGKey key = BKE_subdiv_ccg_key_top_level(subdiv_ccg);
250
251 const Span<int> grids = node.grids();
252 const int grid_verts_num = grids.size() * key.grid_area;
253
254 const OrigPositionData orig_data = orig_position_data_get_grids(object, node);
255
256 tls.factors.resize(grid_verts_num);
257 const MutableSpan<float> factors = tls.factors;
258 fill_factor_from_hide_and_mask(subdiv_ccg, grids, factors);
259
260 tls.translations.resize(grid_verts_num);
261 const MutableSpan<float3> translations = tls.translations;
262 calc_symm_area_transform_translations(orig_data.positions, transform_mats, translations);
263
264 scale_translations(translations, factors);
265
266 const ePaintSymmetryFlags symm = mesh_symmetry_xyz_get(object);
267 filter_translations_with_symmetry(orig_data.positions, symm, translations);
268
269 clip_and_lock_translations(sd, ss, orig_data.positions, translations);
270 apply_translations(translations, grids, subdiv_ccg);
271}
272
273static void transform_node_bmesh(const Sculpt &sd,
274 const std::array<float4x4, 8> &transform_mats,
276 Object &object,
278{
279 SculptSession &ss = *object.runtime->sculpt_session;
280
282
283 Array<float3> orig_positions(verts.size());
284 Array<float3> orig_normals(verts.size());
285 orig_position_data_gather_bmesh(*ss.bm_log, verts, orig_positions, orig_normals);
286
287 tls.factors.resize(verts.size());
288 const MutableSpan<float> factors = tls.factors;
289 fill_factor_from_hide_and_mask(*ss.bm, verts, factors);
290
291 tls.translations.resize(verts.size());
292 const MutableSpan<float3> translations = tls.translations;
293 calc_symm_area_transform_translations(orig_positions, transform_mats, translations);
294
295 scale_translations(translations, factors);
296
297 const ePaintSymmetryFlags symm = mesh_symmetry_xyz_get(object);
298 filter_translations_with_symmetry(orig_positions, symm, translations);
299
300 clip_and_lock_translations(sd, ss, orig_positions, translations);
301 apply_translations(translations, verts);
302}
303
304static void sculpt_transform_all_vertices(const Depsgraph &depsgraph, const Sculpt &sd, Object &ob)
305{
307
310
311 std::array<float4x4, 8> transform_mats = transform_matrices_init(
313
314 /* Regular transform applies all symmetry passes at once as it is split by symmetry areas
315 * (each vertex can only be transformed once by the transform matrix of its area). */
317 const IndexMask &node_mask = ss.filter_cache->node_mask;
318
320 switch (pbvh.type()) {
322 Mesh &mesh = *id_cast<Mesh *>(ob.data);
323 const MeshAttributeData attribute_data(mesh);
325 const PositionDeformData position_data(depsgraph, ob);
326 node_mask.foreach_index(
327 [&](const int i) {
328 TransformLocalData &tls = all_tls.local();
330 sd, transform_mats, attribute_data, nodes[i], ob, tls, position_data);
331 bke::pbvh::update_node_bounds_mesh(position_data.eval, nodes[i]);
332 },
334 break;
335 }
337 SubdivCCG &subdiv_ccg = *ob.runtime->sculpt_session->subdiv_ccg;
338 MutableSpan<float3> positions = subdiv_ccg.positions;
340 node_mask.foreach_index(
341 [&](const int i) {
342 TransformLocalData &tls = all_tls.local();
343 transform_node_grids(sd, transform_mats, nodes[i], ob, tls);
344 bke::pbvh::update_node_bounds_grids(subdiv_ccg.grid_area, positions, nodes[i]);
345 },
347 break;
348 }
351 node_mask.foreach_index(
352 [&](const int i) {
353 TransformLocalData &tls = all_tls.local();
354 transform_node_bmesh(sd, transform_mats, nodes[i], ob, tls);
356 },
358 break;
359 }
360 }
361 pbvh.tag_positions_changed(node_mask);
362 pbvh.flush_bounds_to_parents();
363}
364
365BLI_NOINLINE static void calc_transform_translations(const float4x4 &elastic_transform_mat,
366 const Span<float3> positions,
367 const MutableSpan<float3> r_translations)
368{
369 for (const int i : positions.index_range()) {
370 const float3 transformed = math::transform_point(elastic_transform_mat, positions[i]);
371 r_translations[i] = transformed - positions[i];
372 }
373}
374
376 const float3 &elastic_transform_pivot,
377 const Span<float3> positions,
378 const MutableSpan<float3> translations)
379{
380 for (const int i : positions.index_range()) {
382 translations[i], &params, positions[i], elastic_transform_pivot, translations[i]);
383 }
384}
385
387 const KelvinletParams &params,
388 const float4x4 &elastic_transform_mat,
389 const float3 &elastic_transform_pivot,
390 const MeshAttributeData &attribute_data,
392 Object &object,
394 const PositionDeformData &position_data)
395{
396 const SculptSession &ss = *object.runtime->sculpt_session;
397
398 const Span<int> verts = node.verts();
399 const MutableSpan positions = gather_data_mesh(position_data.eval, verts, tls.positions);
400
401 /* TODO: Using the factors array is unnecessary when there are no hidden vertices and no mask. */
402 tls.factors.resize(verts.size());
403 const MutableSpan<float> factors = tls.factors;
404 fill_factor_from_hide_and_mask(attribute_data.hide_vert, attribute_data.mask, verts, factors);
405 scale_factors(factors, 20.0f);
406
407 tls.translations.resize(verts.size());
408 const MutableSpan<float3> translations = tls.translations;
409 calc_transform_translations(elastic_transform_mat, positions, translations);
410 apply_kelvinet_to_translations(params, elastic_transform_pivot, positions, translations);
411
412 scale_translations(translations, factors);
413
414 clip_and_lock_translations(sd, ss, position_data.eval, verts, translations);
415 position_data.deform(translations, verts);
416}
417
419 const KelvinletParams &params,
420 const float4x4 &elastic_transform_mat,
421 const float3 &elastic_transform_pivot,
423 Object &object,
425{
426 SculptSession &ss = *object.runtime->sculpt_session;
427 SubdivCCG &subdiv_ccg = *ss.subdiv_ccg;
428
429 const Span<int> grids = node.grids();
430 const MutableSpan positions = gather_grids_positions(subdiv_ccg, grids, tls.positions);
431
432 /* TODO: Using the factors array is unnecessary when there are no hidden vertices and no mask. */
433 tls.factors.resize(positions.size());
434 const MutableSpan<float> factors = tls.factors;
435 fill_factor_from_hide_and_mask(subdiv_ccg, grids, factors);
436 scale_factors(factors, 20.0f);
437
438 tls.translations.resize(positions.size());
439 const MutableSpan<float3> translations = tls.translations;
440 calc_transform_translations(elastic_transform_mat, positions, translations);
441 apply_kelvinet_to_translations(params, elastic_transform_pivot, positions, translations);
442
443 scale_translations(translations, factors);
444
445 clip_and_lock_translations(sd, ss, positions, translations);
446 apply_translations(translations, grids, subdiv_ccg);
447}
448
450 const KelvinletParams &params,
451 const float4x4 &elastic_transform_mat,
452 const float3 &elastic_transform_pivot,
454 Object &object,
456{
457 SculptSession &ss = *object.runtime->sculpt_session;
458
460 const MutableSpan positions = gather_bmesh_positions(verts, tls.positions);
461
462 tls.factors.resize(verts.size());
463 const MutableSpan<float> factors = tls.factors;
464 fill_factor_from_hide_and_mask(*ss.bm, verts, factors);
465 scale_factors(factors, 20.0f);
466
467 tls.translations.resize(verts.size());
468 const MutableSpan<float3> translations = tls.translations;
469 calc_transform_translations(elastic_transform_mat, positions, translations);
470 apply_kelvinet_to_translations(params, elastic_transform_pivot, positions, translations);
471
472 scale_translations(translations, factors);
473
474 clip_and_lock_translations(sd, ss, positions, translations);
475 apply_translations(translations, verts);
476}
477
478static void transform_radius_elastic(const Depsgraph &depsgraph,
479 const Sculpt &sd,
480 Object &ob,
481 const float transform_radius)
482{
486
488
489 std::array<float4x4, 8> transform_mats = transform_matrices_init(
491
493 const IndexMask &node_mask = ss.filter_cache->node_mask;
494
495 KelvinletParams params;
496 /* TODO(pablodp606): These parameters can be exposed if needed as transform strength and volume
497 * preservation like in the elastic deform brushes. Setting them to the same default as elastic
498 * deform triscale grab because they work well in most cases. */
499 const float force = 1.0f;
500 const float shear_modulus = 1.0f;
501 const float poisson_ratio = 0.4f;
502 BKE_kelvinlet_init_params(&params, transform_radius, force, shear_modulus, poisson_ratio);
503
505 for (ePaintSymmetryFlags symmpass = PAINT_SYMM_NONE; symmpass <= symm; symmpass++) {
506 if (!is_symmetry_iteration_valid(symmpass, symm)) {
507 continue;
508 }
509
510 const float3 elastic_transform_pivot = symmetry_flip(ss.pivot_pos, symmpass);
511
512 const int symm_area = get_vertex_symm_area(elastic_transform_pivot);
513 float4x4 elastic_transform_mat = transform_mats[symm_area];
514 switch (pbvh.type()) {
516 Mesh &mesh = *id_cast<Mesh *>(ob.data);
518 const PositionDeformData position_data(depsgraph, ob);
519 const MeshAttributeData attribute_data(mesh);
520 node_mask.foreach_index(
521 [&](const int i) {
522 TransformLocalData &tls = all_tls.local();
524 params,
525 elastic_transform_mat,
526 elastic_transform_pivot,
527 attribute_data,
528 nodes[i],
529 ob,
530 tls,
531 position_data);
532 bke::pbvh::update_node_bounds_mesh(position_data.eval, nodes[i]);
533 },
535 break;
536 }
538 SubdivCCG &subdiv_ccg = *ob.runtime->sculpt_session->subdiv_ccg;
539 MutableSpan<float3> positions = subdiv_ccg.positions;
541 node_mask.foreach_index(
542 [&](const int i) {
543 TransformLocalData &tls = all_tls.local();
545 sd, params, elastic_transform_mat, elastic_transform_pivot, nodes[i], ob, tls);
546 bke::pbvh::update_node_bounds_grids(subdiv_ccg.grid_area, positions, nodes[i]);
547 },
549 break;
550 }
553 node_mask.foreach_index(
554 [&](const int i) {
555 TransformLocalData &tls = all_tls.local();
557 sd, params, elastic_transform_mat, elastic_transform_pivot, nodes[i], ob, tls);
559 },
561 break;
562 }
563 }
564 }
565 pbvh.tag_positions_changed(node_mask);
566 pbvh.flush_bounds_to_parents();
567}
568
570{
572 Sculpt &sd = *(ts.sculpt);
574 Depsgraph *depsgraph = CTX_data_depsgraph_pointer(C);
575
576 if ((ts.transform_flag & SCE_XFORM_SCULPT_PIVOT) == 0) {
578 BKE_sculptsession_update_for_edit(depsgraph, &ob, false);
579
580 switch (sd.transform_mode) {
582 sculpt_transform_all_vertices(*depsgraph, sd, ob);
583 break;
584 }
587 float transform_radius;
588
590 transform_radius = BKE_brush_unprojected_radius_get(&sd.paint, &brush);
591 }
592 else {
594
595 transform_radius = paint_calc_object_space_radius(
597 }
598
599 transform_radius_elastic(*depsgraph, sd, ob, transform_radius);
600 break;
601 }
602 }
603 }
604 else {
605 /* Intentional no-op */
606 }
607
611
612 if ((ts.transform_flag & SCE_XFORM_SCULPT_PIVOT) == 0) {
614 }
615}
616
618{
619 /* Canceling "Elastic" transforms (due to its #TransformDisplacementMode::Incremental nature),
620 * requires restoring positions from undo. For "All Vertices" there is no benefit in using the
621 * transform system to update to original positions either. */
622 Depsgraph &depsgraph = *CTX_data_depsgraph_pointer(C);
624
626 bke::pbvh::update_normals(depsgraph, ob, pbvh);
627 pbvh.update_bounds(depsgraph, ob);
628}
629
631{
634 /* Pivot only transformations don't push undo steps */
636 BLI_assert(ss.filter_cache == nullptr);
638 return;
639 }
640 MEM_delete(ss.filter_cache);
641 ss.filter_cache = nullptr;
642 undo::push_end(ob);
644}
645
653
656 "ORIGIN",
657 0,
658 "Origin",
659 "Sets the pivot to the origin of the sculpt"},
661 "UNMASKED",
662 0,
663 "Unmasked",
664 "Sets the pivot position to the average position of the unmasked vertices"},
666 "BORDER",
667 0,
668 "Mask Border",
669 "Sets the pivot position to the center of the border of the mask"},
671 "ACTIVE",
672 0,
673 "Active Vertex",
674 "Sets the pivot position to the active vertex position"},
676 "SURFACE",
677 0,
678 "Surface",
679 "Sets the pivot position to the surface under the cursor"},
680 {0, nullptr, 0, nullptr, nullptr},
681};
682
684{
685 if (!ptr) {
686 return true;
687 }
688 const PivotPositionMode mode = PivotPositionMode(RNA_enum_get(ptr, "mode"));
690}
691
696
702
704 const Span<float> factors,
706{
707 BLI_assert(positions.size() == factors.size());
708
709 for (const int i : positions.index_range()) {
710 total.position += double3(positions[i] * factors[i]);
711 total.weight_total += factors[i];
712 }
713}
714
715static float3 average_unmasked_position(const Depsgraph &depsgraph,
716 const Object &object,
717 const float3 &pivot,
718 const ePaintSymmetryFlags symm)
719{
720 const SculptSession &ss = *object.runtime->sculpt_session;
722
723 IndexMaskMemory memory;
724 const IndexMask node_mask = bke::pbvh::search_nodes(
725 pbvh, memory, [&](const bke::pbvh::Node &node) {
727 });
728
729 struct LocalData {
730 Vector<float> factors;
731 Vector<float3> positions;
732 };
733
735 switch (pbvh.type()) {
738 const Mesh &mesh = *id_cast<const Mesh *>(object.data);
739 const MeshAttributeData attribute_data(mesh);
740 const Span<float3> vert_positions = bke::pbvh::vert_positions_eval(depsgraph, object);
742 node_mask.index_range(),
743 1,
745 [&](const IndexRange range, AveragePositionAccumulation sum) {
746 LocalData &tls = all_tls.local();
747 threading::isolate_task([&]() {
748 node_mask.slice(range).foreach_index([&](const int i) {
749 const Span<int> verts = nodes[i].verts();
750
751 tls.positions.resize(verts.size());
752 const MutableSpan<float3> positions = tls.positions;
753 array_utils::gather(vert_positions, verts, positions);
754
755 tls.factors.resize(verts.size());
756 const MutableSpan<float> factors = tls.factors;
757 fill_factor_from_hide_and_mask(
758 attribute_data.hide_vert, attribute_data.mask, verts, factors);
759 filter_verts_outside_symmetry_area(positions, pivot, symm, factors);
760
761 accumulate_weighted_average_position(positions, factors, sum);
762 });
763 });
764 return sum;
765 },
767 return float3(math::safe_divide(total.position, total.weight_total));
768 }
771 const SubdivCCG &subdiv_ccg = *ss.subdiv_ccg;
773 node_mask.index_range(),
774 1,
776 [&](const IndexRange range, AveragePositionAccumulation sum) {
777 LocalData &tls = all_tls.local();
778 node_mask.slice(range).foreach_index([&](const int i) {
779 const Span<int> grids = nodes[i].grids();
780 const MutableSpan positions = gather_grids_positions(
781 subdiv_ccg, grids, tls.positions);
782
783 tls.factors.resize(positions.size());
784 const MutableSpan<float> factors = tls.factors;
785 fill_factor_from_hide_and_mask(subdiv_ccg, grids, factors);
786 filter_verts_outside_symmetry_area(positions, pivot, symm, factors);
787
788 accumulate_weighted_average_position(positions, factors, sum);
789 });
790 return sum;
791 },
793 return float3(math::safe_divide(total.position, total.weight_total));
794 }
798 node_mask.index_range(),
799 1,
801 [&](const IndexRange range, AveragePositionAccumulation sum) {
802 LocalData &tls = all_tls.local();
803 node_mask.slice(range).foreach_index([&](const int i) {
804 const Set<BMVert *, 0> &verts = BKE_pbvh_bmesh_node_unique_verts(
805 &const_cast<bke::pbvh::BMeshNode &>(nodes[i]));
806 const MutableSpan positions = gather_bmesh_positions(verts, tls.positions);
807
808 tls.factors.resize(verts.size());
809 const MutableSpan<float> factors = tls.factors;
810 fill_factor_from_hide_and_mask(*ss.bm, verts, factors);
811 filter_verts_outside_symmetry_area(positions, pivot, symm, factors);
812
813 accumulate_weighted_average_position(positions, factors, sum);
814 });
815 return sum;
816 },
818 return float3(math::safe_divide(total.position, total.weight_total));
819 }
820 }
822 return float3(0);
823}
824
826 const MutableSpan<float> factors)
827{
828 constexpr float threshold = 0.2f;
829
830 for (const int i : masks.index_range()) {
831 if (std::abs(masks[i] - 0.5f) > threshold) {
832 factors[i] = 0.0f;
833 }
834 }
835};
836
837static float3 average_mask_border_position(const Depsgraph &depsgraph,
838 const Object &object,
839 const float3 &pivot,
840 const ePaintSymmetryFlags symm)
841{
842 const SculptSession &ss = *object.runtime->sculpt_session;
844
845 IndexMaskMemory memory;
846 const IndexMask node_mask = bke::pbvh::search_nodes(
847 pbvh, memory, [&](const bke::pbvh::Node &node) {
849 });
850
851 struct LocalData {
852 Vector<float> factors;
853 Vector<float> masks;
854 Vector<float3> positions;
855 };
856
858 switch (pbvh.type()) {
861 const Mesh &mesh = *id_cast<const Mesh *>(object.data);
862 const Span<float3> vert_positions = bke::pbvh::vert_positions_eval(depsgraph, object);
863 const bke::AttributeAccessor attributes = mesh.attributes();
864 const VArraySpan mask_attr = *attributes.lookup_or_default<float>(
865 ".sculpt_mask", bke::AttrDomain::Point, 0.0f);
866 const VArraySpan hide_vert = *attributes.lookup<bool>(".hide_vert", bke::AttrDomain::Point);
868 node_mask.index_range(),
869 1,
871 [&](const IndexRange range, AveragePositionAccumulation sum) {
872 LocalData &tls = all_tls.local();
873 node_mask.slice(range).foreach_index([&](const int i) {
874 const Span<int> verts = nodes[i].verts();
875 MutableSpan positions = gather_data_mesh(vert_positions, verts, tls.positions);
876 MutableSpan masks = gather_data_mesh(mask_attr, verts, tls.masks);
877
878 tls.factors.resize(verts.size());
879 const MutableSpan<float> factors = tls.factors;
880 fill_factor_from_hide(hide_vert, verts, factors);
881
882 mask_border_weight_calc(masks, factors);
883 filter_verts_outside_symmetry_area(positions, pivot, symm, factors);
884
885 accumulate_weighted_average_position(positions, factors, sum);
886 });
887 return sum;
888 },
890 return float3(math::safe_divide(total.position, total.weight_total));
891 }
894 const SubdivCCG &subdiv_ccg = *ss.subdiv_ccg;
896 node_mask.index_range(),
897 1,
899 [&](const IndexRange range, AveragePositionAccumulation sum) {
900 LocalData &tls = all_tls.local();
901 node_mask.slice(range).foreach_index([&](const int i) {
902 const Span<int> grids = nodes[i].grids();
903 const MutableSpan positions = gather_grids_positions(
904 subdiv_ccg, grids, tls.positions);
905
906 tls.masks.resize(positions.size());
907 const MutableSpan<float> masks = tls.masks;
908 mask::gather_mask_grids(subdiv_ccg, grids, masks);
909
910 tls.factors.resize(positions.size());
911 const MutableSpan<float> factors = tls.factors;
912 fill_factor_from_hide(subdiv_ccg, grids, factors);
913 mask_border_weight_calc(masks, factors);
914 filter_verts_outside_symmetry_area(positions, pivot, symm, factors);
915
916 accumulate_weighted_average_position(positions, factors, sum);
917 });
918 return sum;
919 },
921 return float3(math::safe_divide(total.position, total.weight_total));
922 }
926 node_mask.index_range(),
927 1,
929 [&](const IndexRange range, AveragePositionAccumulation sum) {
930 LocalData &tls = all_tls.local();
931 node_mask.slice(range).foreach_index([&](const int i) {
932 const Set<BMVert *, 0> &verts = BKE_pbvh_bmesh_node_unique_verts(
933 &const_cast<bke::pbvh::BMeshNode &>(nodes[i]));
934 const MutableSpan positions = gather_bmesh_positions(verts, tls.positions);
935
936 tls.masks.resize(verts.size());
937 const MutableSpan<float> masks = tls.masks;
938 mask::gather_mask_bmesh(*ss.bm, verts, masks);
939
940 tls.factors.resize(verts.size());
941 const MutableSpan<float> factors = tls.factors;
942 fill_factor_from_hide(verts, factors);
943 mask_border_weight_calc(masks, factors);
944 filter_verts_outside_symmetry_area(positions, pivot, symm, factors);
945
946 accumulate_weighted_average_position(positions, factors, sum);
947 });
948 return sum;
949 },
951 return float3(math::safe_divide(total.position, total.weight_total));
952 }
953 }
955 return float3(0);
956}
957
959{
962 Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
964
965 const PivotPositionMode mode = PivotPositionMode(RNA_enum_get(op->ptr, "mode"));
966
967 const View3D *v3d = CTX_wm_view3d(C);
968 const Base *base = CTX_data_active_base(C);
969 if (!BKE_base_is_visible(v3d, base)) {
970 return OPERATOR_CANCELLED;
971 }
972
973 BKE_sculptsession_update_for_edit(depsgraph, &ob, false);
974
975 switch (mode) {
977 ss.pivot_pos = float3(0.0f);
978 break;
980 ss.pivot_pos = average_unmasked_position(*depsgraph, ob, ss.pivot_pos, symm);
981 break;
983 ss.pivot_pos = average_mask_border_position(*depsgraph, ob, ss.pivot_pos, symm);
984 break;
986 const float2 mval(RNA_float_get(op->ptr, "mouse_x"), RNA_float_get(op->ptr, "mouse_y"));
987 if (cursor_geometry_info_update(C, mval, false)) {
988 ss.pivot_pos = ss.active_vert_position(*depsgraph, ob);
989 }
990 break;
991 }
993 const float2 mval(RNA_float_get(op->ptr, "mouse_x"), RNA_float_get(op->ptr, "mouse_y"));
994 if (std::optional<float3> stroke_location = stroke_get_location_bvh(C, mval, false)) {
995 ss.pivot_pos = *stroke_location;
996 }
997 break;
998 }
999 }
1000
1002
1003 return OPERATOR_FINISHED;
1004}
1005
1007 wmOperator *op,
1008 const wmEvent *event)
1009{
1010 RNA_float_set(op->ptr, "mouse_x", event->mval[0]);
1011 RNA_float_set(op->ptr, "mouse_y", event->mval[1]);
1012 return set_pivot_position_exec(C, op);
1013}
1014
1016 wmOperator *op,
1017 const PropertyRNA *prop)
1018{
1019 if (STRPREFIX(RNA_property_identifier(prop), "mouse_")) {
1020 const PivotPositionMode mode = PivotPositionMode(RNA_enum_get(op->ptr, "mode"));
1022 }
1023 return true;
1024}
1025
1027{
1028 ot->name = "Set Pivot Position";
1029 ot->idname = "SCULPT_OT_set_pivot_position";
1030 ot->description = "Sets the sculpt transform pivot position";
1031
1037
1039 RNA_def_enum(ot->srna,
1040 "mode",
1043 "Mode",
1044 "");
1045
1046 RNA_def_float(ot->srna,
1047 "mouse_x",
1048 0.0f,
1049 0.0f,
1050 FLT_MAX,
1051 "Mouse Position X",
1052 "Position of the mouse used for \"Surface\" and \"Active Vertex\" mode",
1053 0.0f,
1054 10000.0f);
1055 RNA_def_float(ot->srna,
1056 "mouse_y",
1057 0.0f,
1058 0.0f,
1059 FLT_MAX,
1060 "Mouse Position Y",
1061 "Position of the mouse used for \"Surface\" and \"Active Vertex\" mode",
1062 0.0f,
1063 10000.0f);
1064}
1065
1066} // namespace blender::ed::sculpt_paint
#define PAINT_SYMM_AREAS
Definition BKE_paint.hh:109
A BVH for high poly meshes.
Read Blender memory allocation and freeing.
#define C
Definition RandGen.cpp:29
#define NC_GEOM
Definition WM_types.hh:406
#define ND_SELECT
Definition WM_types.hh:551
#define STRPREFIX(a, b)
#define BLI_assert_unreachable()
#define BLI_NOINLINE
#define ELEM(...)
SIMD_FORCE_INLINE const btScalar & z() const
Return the z value.
Definition btQuadWord.h:117
constexpr int64_t size() const
Definition BLI_span.hh:499
int64_t size() const
Definition BLI_set.hh:606
constexpr int64_t size() const
Definition BLI_span.hh:256
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
GAttributeReader lookup_or_default(StringRef name, AttrDomain domain, AttrType data_type, const void *default_value=nullptr) const
GAttributeReader lookup(const StringRef name) const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
#define FLT_MAX
pbvh::Tree * pbvh_get(Object &object)
void stroke_set_location(Paint &paint, float3 location)
IndexMask search_nodes(const Tree &pbvh, IndexMaskMemory &memory, FunctionRef< bool(const Node &)> filter_fn)
Definition pbvh.cc:2556
void update_normals(const Depsgraph &depsgraph, Object &object_orig, Tree &pbvh)
Definition pbvh.cc:1179
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
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 cache_init(bContext *C, Object &ob, Sculpt &sd, undo::Type undo_type, const float mval_fl[2], float area_normal_radius, float start_strength)
void push_begin_ex(const Scene &, Object &ob, const char *name)
void restore_position_from_undo_step(const Depsgraph &depsgraph, Object &object)
Definition sculpt.cc:1181
static void elastic_transform_node_bmesh(const Sculpt &sd, const KelvinletParams &params, const float4x4 &elastic_transform_mat, const float3 &elastic_transform_pivot, bke::pbvh::BMeshNode &node, Object &object, TransformLocalData &tls)
void fill_factor_from_hide_and_mask(Span< bool > hide_vert, Span< float > mask, Span< int > verts, MutableSpan< float > r_factors)
Definition sculpt.cc:7128
static BLI_NOINLINE void mask_border_weight_calc(const Span< float > masks, const MutableSpan< float > factors)
MutableSpan< float3 > gather_grids_positions(const SubdivCCG &subdiv_ccg, const Span< int > grids, Vector< float3 > &positions)
static wmOperatorStatus set_pivot_position_invoke(bContext *C, wmOperator *op, const wmEvent *event)
void gather_bmesh_positions(const Set< BMVert *, 0 > &verts, MutableSpan< float3 > positions)
Definition sculpt.cc:6497
static std::array< float4x4, 8 > transform_matrices_init(const SculptSession &ss, const ePaintSymmetryFlags symm, const TransformDisplacementMode t_mode)
static bool set_pivot_position_poll_property(const bContext *, wmOperator *op, const PropertyRNA *prop)
void update_modal_transform(bContext *C, Object &ob)
void vert_random_access_ensure(Object &object)
Definition sculpt.cc:154
static void transform_node_mesh(const Sculpt &sd, const std::array< float4x4, 8 > &transform_mats, const MeshAttributeData &attribute_data, const bke::pbvh::MeshNode &node, Object &object, TransformLocalData &tls, const PositionDeformData &position_data)
bool node_fully_masked_or_hidden(const bke::pbvh::Node &node)
Definition sculpt.cc:2500
ePaintSymmetryAreas get_vertex_symm_area(const float co[3])
Definition sculpt.cc:2979
static void finish_pivot_change(bContext *C, Object &ob)
static void transform_node_grids(const Sculpt &sd, const std::array< float4x4, 8 > &transform_mats, const bke::pbvh::GridsNode &node, Object &object, TransformLocalData &tls)
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)
static BLI_NOINLINE void calc_symm_area_transform_translations(const Span< float3 > positions, const std::array< float4x4, 8 > &transform_mats, const MutableSpan< float3 > translations)
void scale_translations(MutableSpan< float3 > translations, Span< float > factors)
Definition sculpt.cc:7837
void end_transform(bContext *C, Object &ob)
ePaintSymmetryFlags mesh_symmetry_xyz_get(const Object &object)
Definition sculpt.cc:192
static void elastic_transform_node_mesh(const Sculpt &sd, const KelvinletParams &params, const float4x4 &elastic_transform_mat, const float3 &elastic_transform_pivot, const MeshAttributeData &attribute_data, const bke::pbvh::MeshNode &node, Object &object, TransformLocalData &tls, const PositionDeformData &position_data)
void init_transform(bContext *C, Object &ob, const float mval_fl[2], const char *undo_name)
static wmOperatorStatus set_pivot_position_exec(bContext *C, wmOperator *op)
void scale_factors(MutableSpan< float > factors, float strength)
Definition sculpt.cc:7856
float3 flip_v3_by_symm_area(const float3 &vector, const ePaintSymmetryFlags symm, const ePaintSymmetryAreas symmarea, const float3 &pivot)
Definition sculpt.cc:3022
void cancel_modal_transform(bContext *C, Object &ob)
static BLI_NOINLINE void filter_translations_with_symmetry(const Span< float3 > positions, const ePaintSymmetryFlags symm, const MutableSpan< float3 > translations)
void clip_and_lock_translations(const Sculpt &sd, const SculptSession &ss, Span< float3 > positions, Span< int > verts, MutableSpan< float3 > translations)
Definition sculpt.cc:7664
static BLI_NOINLINE void accumulate_weighted_average_position(const Span< float3 > positions, const Span< float > factors, AveragePositionAccumulation &total)
std::optional< float3 > stroke_get_location_bvh(Depsgraph &depsgraph, ViewContext &vc, const Sculpt &sd, const Brush *brush, const float mval[2], const bool force_original)
Definition sculpt.cc:4855
bool sculpt_mode_poll_view3d(bContext *C)
Definition sculpt.cc:3806
static void elastic_transform_node_grids(const Sculpt &sd, const KelvinletParams &params, const float4x4 &elastic_transform_mat, const float3 &elastic_transform_pivot, const bke::pbvh::GridsNode &node, Object &object, TransformLocalData &tls)
static void transform_node_bmesh(const Sculpt &sd, const std::array< float4x4, 8 > &transform_mats, bke::pbvh::BMeshNode &node, Object &object, TransformLocalData &tls)
static constexpr float transform_mirror_max_distance_eps
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 flush_update_step(bContext *C, const UpdateType update_type)
Definition sculpt.cc:5090
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)
void flush_update_done(bContext *C, Object &ob, const UpdateType update_type)
Definition sculpt.cc:5131
static void sculpt_transform_all_vertices(const Depsgraph &depsgraph, const Sculpt &sd, Object &ob)
static float3 average_unmasked_position(const Depsgraph &depsgraph, const Object &object, const float3 &pivot, const ePaintSymmetryFlags symm)
static BLI_NOINLINE void apply_kelvinet_to_translations(const KelvinletParams &params, const float3 &elastic_transform_pivot, const Span< float3 > positions, const MutableSpan< float3 > translations)
std::optional< CursorGeometryInfo > cursor_geometry_info_update(bContext *C, const float2 &mval, const bool use_sampled_normal)
Definition sculpt.cc:4584
void flip_quat_by_symm_area(float quat[4], const ePaintSymmetryFlags symm, const ePaintSymmetryAreas symmarea, const float pivot[3])
Definition sculpt.cc:3043
static void transform_radius_elastic(const Depsgraph &depsgraph, const Sculpt &sd, Object &ob, const float transform_radius)
static BLI_NOINLINE void calc_transform_translations(const float4x4 &elastic_transform_mat, const Span< float3 > positions, const MutableSpan< float3 > r_translations)
static AveragePositionAccumulation combine_average_position_accumulation(const AveragePositionAccumulation &a, const AveragePositionAccumulation &b)
static float3 average_mask_border_position(const Depsgraph &depsgraph, const Object &object, const float3 &pivot, const ePaintSymmetryFlags symm)
static bool set_pivot_depends_on_cursor(bContext &, wmOperatorType &, PointerRNA *ptr)
static EnumPropertyItem prop_sculpt_pivot_position_types[]
void SCULPT_OT_set_pivot_position(wmOperatorType *ot)
bool is_symmetry_iteration_valid(const char i, const char symm)
constexpr ParallelGrainSize grain_size(int grain_size)
T safe_divide(const T &a, const T &b)
VecBase< T, 3 > transform_point(const CartesianBasis &basis, const VecBase< T, 3 > &v)
Value parallel_reduce(IndexRange range, int64_t grain_size, const Value &identity, const Function &function, const Reduction &reduction)
Definition BLI_task.hh:127
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
int RNA_enum_get(PointerRNA *ptr, const char *name)
void BKE_kelvinlet_init_params(KelvinletParams *params, float radius, float force, float shear_modulus, float poisson_ratio)
Definition kelvinlet.cc:18
std::variant< std::monostate, int, BMVert * > ActiveVert
Definition BKE_paint.hh:357
ViewContext ED_view3d_viewcontext_init(bContext *C, Depsgraph *depsgraph)
MINLINE void copy_v3_v3(float r[3], const float a[3])
ePaintSymmetryAreas
Definition BKE_paint.hh:102
bool BKE_base_is_visible(const View3D *v3d, const Base *base)
Depsgraph * CTX_data_depsgraph_pointer(const bContext *C)
const char * RNA_property_identifier(const PropertyRNA *prop)
float BKE_brush_radius_get(const Paint *paint, const Brush *brush)
Definition brush.cc:1366
float normalize_qt(float q[4])
bool invert_m4_m4(float inverse[4][4], const float mat[4][4])
PropertyRNA * RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items, const int default_value, const char *ui_name, const char *ui_description)
MINLINE void add_v3_fl(float r[3], float f)
void mul_m4_m4m4(float R[4][4], const float A[4][4], const float B[4][4])
void translate_m4(float mat[4][4], float Tx, float Ty, float Tz)
MatBase< float, 4, 4 > float4x4
void ED_region_tag_redraw(ARegion *region)
Definition area.cc:681
Base * CTX_data_active_base(const bContext *C)
CCGKey BKE_subdiv_ccg_key_top_level(const SubdivCCG &subdiv_ccg)
float BKE_brush_unprojected_radius_get(const Paint *paint, const Brush *brush)
Definition brush.cc:1412
void size_to_mat4(float R[4][4], const float size[3])
VecBase< float, 2 > float2
void sub_qt_qtqt(float q[4], const float a[4], const float b[4])
BMesh const char void * data
Depsgraph * CTX_data_ensure_evaluated_depsgraph(const bContext *C, bool rna_write_check=false)
void BKE_kelvinlet_grab_triscale(float radius_elem_disp[3], const KelvinletParams *params, const float elem_orig_co[3], const float brush_location[3], const float brush_delta[3])
Definition kelvinlet.cc:92
@ SCULPT_TRANSFORM_MODE_RADIUS_ELASTIC
@ SCULPT_TRANSFORM_MODE_ALL_VERTICES
void unit_m4(float m[4][4])
ToolSettings * CTX_data_tool_settings(const bContext *C)
VecBase< double, 3 > double3
bool BKE_brush_use_locked_size(const Paint *paint, const Brush *brush)
Definition brush.cc:1371
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
void RNA_float_set(PointerRNA *ptr, const char *name, float value)
const Brush * BKE_paint_brush_for_read(const Paint *paint)
MINLINE void sub_v3_v3v3(float r[3], const float a[3], const float b[3])
Paint * BKE_paint_get_active_from_context(const bContext *C)
float paint_calc_object_space_radius(const ViewContext &vc, const float3 &center, float pixel_radius)
void BKE_sculptsession_update_for_edit(Depsgraph *depsgraph, Object *ob_orig, bool is_paint_tool)
Scene * CTX_data_scene(const bContext *C)
MINLINE void copy_v4_v4(float r[4], const float a[4])
@ OPTYPE_REGISTER
Definition WM_types.hh:188
@ OPTYPE_UNDO
Definition WM_types.hh:190
VecBase< float, 3 > float3
PropertyRNA * RNA_def_float(StructOrFunctionRNA *cont_, const char *identifier, const float default_value, const float hardmin, const float hardmax, const char *ui_name, const char *ui_description, const float softmin, const float softmax)
Object * CTX_data_active_object(const bContext *C)
const Set< BMVert *, 0 > & BKE_pbvh_bmesh_node_unique_verts(bke::pbvh::BMeshNode *node)
ARegion * CTX_wm_region(const bContext *C)
float RNA_float_get(PointerRNA *ptr, const char *name)
View3D * CTX_wm_view3d(const bContext *C)
void quat_to_mat4(float m[4][4], const float q[4])
bke::ObjectRuntime * runtime
float3 active_vert_position(const Depsgraph &depsgraph, const Object &object) const
ed::sculpt_paint::filter::Cache * filter_cache
Definition BKE_paint.hh:410
eSculptTransformMode transform_mode
Array< float3 > positions
TransformDisplacementMode transform_displacement_mode
wmOperatorStatus(*) exec(bContext *C, wmOperator *op) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1125
bool(*) poll_property(const bContext *C, wmOperator *op, const PropertyRNA *prop) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1171
const char * description
Definition WM_types.hh:1115
bool(*) depends_on_cursor(bContext &C, wmOperatorType &ot, PointerRNA *ptr)
Definition WM_types.hh:1200
bool(*) poll(bContext *C) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1165
wmOperatorStatus(*) invoke(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1141
void resize(int new_size)
Definition vector.hh:94