Blender V5.3
surface_smooth.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2024 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
10
11#include "DNA_brush_types.h"
12#include "DNA_mesh_types.h"
13#include "DNA_object_types.h"
14#include "DNA_scene_types.h"
15
16#include "BKE_mesh.hh"
17#include "BKE_object_types.hh"
18#include "BKE_paint.hh"
19#include "BKE_paint_bvh.hh"
20#include "BKE_subdiv_ccg.hh"
21
22#include "BLI_array.hh"
24#include "BLI_task.hh"
25
30
31#include "bmesh.hh"
32
34
35inline namespace surface_smooth_cc {
36
47
49{
51 for (float &factor : factors) {
52 factor = std::clamp(factor, 0.0f, 1.0f);
53 }
54}
55
56BLI_NOINLINE static void do_surface_smooth_brush_mesh(const Depsgraph &depsgraph,
57 const Sculpt &sd,
58 const Brush &brush,
59 const IndexMask &node_mask,
60 Object &object,
61 const MutableSpan<float3> all_laplacian_disp)
62{
63 const SculptSession &ss = *object.runtime->sculpt_session;
65 const StrokeCache &cache = *ss.cache;
66 const float alpha = brush.surface_smooth_shape_preservation;
67 const float beta = brush.surface_smooth_current_vertex;
69
70 Mesh &mesh = *id_cast<Mesh *>(object.data);
71 const OffsetIndices faces = mesh.faces();
72 const Span<int> corner_verts = mesh.corner_verts();
73 const GroupedSpan<int> vert_to_face_map = mesh.vert_to_face_map();
74 const MeshAttributeData attribute_data(mesh);
75
76 const PositionDeformData position_data(depsgraph, object);
77 const Span<float3> vert_normals = bke::pbvh::vert_normals_eval(depsgraph, object);
78
79 Array<int> node_offset_data;
80 const OffsetIndices node_offsets = create_node_vert_offsets(nodes, node_mask, node_offset_data);
81 Array<float> all_factors(node_offsets.total_size());
82
84 node_mask.foreach_index(
85 [&](const int i, const int pos) {
86 LocalData &tls = all_tls.local();
87 const Span<int> verts = nodes[i].verts();
88
89 const MutableSpan<float> factors = all_factors.as_mutable_span().slice(node_offsets[pos]);
91 attribute_data.hide_vert, attribute_data.mask, verts, factors);
92 filter_region_clip_factors(ss, position_data.eval, verts, factors);
93 if (brush.flag & BRUSH_FRONTFACE) {
94 calc_front_face(cache.view_normal_symm, vert_normals, verts, factors);
95 }
96
97 tls.distances.resize(verts.size());
98 const MutableSpan<float> distances = tls.distances;
100 ss, position_data.eval, verts, eBrushFalloffShape(brush.falloff_shape), distances);
101 filter_distances_with_radius(cache.radius, distances, factors);
102 apply_hardness_to_distances(cache, distances);
103 calc_brush_strength_factors(cache, brush, distances, factors);
104
106 depsgraph, object, cache.automasking.get(), nodes[i], verts, factors);
107
109 PaintMode::Sculpt, ss, brush, position_data.eval, verts, factors);
110
111 scale_factors(factors, cache.bstrength);
112 clamp_factors(factors);
113 },
115
116 for ([[maybe_unused]] const int iteration : IndexRange(brush.surface_smooth_iterations)) {
117 node_mask.foreach_index(
118 [&](const int i, const int pos) {
119 LocalData &tls = all_tls.local();
120 const Span<int> verts = nodes[i].verts();
121 const MutableSpan positions = gather_data_mesh(position_data.eval, verts, tls.positions);
122 const OrigPositionData orig_data = orig_position_data_get_mesh(object, nodes[i]);
123 const Span<float> factors = all_factors.as_span().slice(node_offsets[pos]);
124
125 const GroupedSpan<int> neighbors = calc_vert_neighbors(faces,
126 corner_verts,
127 vert_to_face_map,
128 attribute_data.hide_poly,
129 verts,
130 tls.neighbor_offsets,
131 tls.neighbor_data);
132
133 tls.average_positions.resize(verts.size());
134 const MutableSpan<float3> average_positions = tls.average_positions;
135 smooth::neighbor_data_average_mesh(position_data.eval, neighbors, average_positions);
136
137 tls.laplacian_disp.resize(verts.size());
138 const MutableSpan<float3> laplacian_disp = tls.laplacian_disp;
139 tls.translations.resize(verts.size());
140 const MutableSpan<float3> translations = tls.translations;
142 orig_data.positions,
143 average_positions,
144 alpha,
145 laplacian_disp,
146 translations);
147 scale_translations(translations, factors);
148
149 scatter_data_mesh(laplacian_disp.as_span(), verts, all_laplacian_disp);
150
151 clip_and_lock_translations(sd, ss, position_data.eval, verts, translations);
152 position_data.deform(translations, verts);
153 },
155
156 node_mask.foreach_index(
157 [&](const int i, const int pos) {
158 LocalData &tls = all_tls.local();
159 const Span<int> verts = nodes[i].verts();
160 const Span<float> factors = all_factors.as_span().slice(node_offsets[pos]);
161
162 const MutableSpan<float3> laplacian_disp = gather_data_mesh(
163 all_laplacian_disp.as_span(), verts, tls.laplacian_disp);
164
165 const GroupedSpan<int> neighbors = calc_vert_neighbors(faces,
166 corner_verts,
167 vert_to_face_map,
168 attribute_data.hide_poly,
169 verts,
170 tls.neighbor_offsets,
171 tls.neighbor_data);
172
173 tls.average_positions.resize(verts.size());
174 const MutableSpan<float3> average_laplacian_disps = tls.average_positions;
176 all_laplacian_disp.as_span(), neighbors, average_laplacian_disps);
177
178 tls.translations.resize(verts.size());
179 const MutableSpan<float3> translations = tls.translations;
181 laplacian_disp, average_laplacian_disps, beta, translations);
182 scale_translations(translations, factors);
183
184 clip_and_lock_translations(sd, ss, position_data.eval, verts, translations);
185 position_data.deform(translations, verts);
186 },
188 }
189}
190
192 const Depsgraph &depsgraph,
193 const Sculpt &sd,
194 const Brush &brush,
195 const IndexMask &node_mask,
196 Object &object,
197 const MutableSpan<float3> all_laplacian_disp)
198{
199 const SculptSession &ss = *object.runtime->sculpt_session;
201 const StrokeCache &cache = *ss.cache;
202 const float alpha = brush.surface_smooth_shape_preservation;
203 const float beta = brush.surface_smooth_current_vertex;
205
206 SubdivCCG &subdiv_ccg = *ss.subdiv_ccg;
207
208 Array<int> node_offset_data;
209 const OffsetIndices node_offsets = create_node_vert_offsets(
210 BKE_subdiv_ccg_key_top_level(subdiv_ccg), nodes, node_mask, node_offset_data);
211 Array<float> all_factors(node_offsets.total_size());
212
214 node_mask.foreach_index(
215 [&](const int i, const int pos) {
216 LocalData &tls = all_tls.local();
217 const Span<int> grids = nodes[i].grids();
218 const MutableSpan positions = gather_grids_positions(subdiv_ccg, grids, tls.positions);
219
220 const MutableSpan<float> factors = all_factors.as_mutable_span().slice(node_offsets[pos]);
221 fill_factor_from_hide_and_mask(subdiv_ccg, grids, factors);
222 filter_region_clip_factors(ss, positions, factors);
223 if (brush.flag & BRUSH_FRONTFACE) {
224 calc_front_face(cache.view_normal_symm, subdiv_ccg, grids, factors);
225 }
226
227 tls.distances.resize(positions.size());
228 const MutableSpan<float> distances = tls.distances;
229 calc_brush_distances(ss, positions, eBrushFalloffShape(brush.falloff_shape), distances);
230 filter_distances_with_radius(cache.radius, distances, factors);
231 apply_hardness_to_distances(cache, distances);
232 calc_brush_strength_factors(cache, brush, distances, factors);
233
235 depsgraph, object, cache.automasking.get(), nodes[i], grids, factors);
236
237 calc_brush_texture_factors(PaintMode::Sculpt, ss, brush, positions, factors);
238
239 scale_factors(factors, cache.bstrength);
240 clamp_factors(factors);
241 },
243
244 for ([[maybe_unused]] const int iteration : IndexRange(brush.surface_smooth_iterations)) {
245 node_mask.foreach_index(
246 [&](const int i, const int pos) {
247 LocalData &tls = all_tls.local();
248 const Span<int> grids = nodes[i].grids();
249 const MutableSpan positions = gather_grids_positions(subdiv_ccg, grids, tls.positions);
250 const OrigPositionData orig_data = orig_position_data_get_grids(object, nodes[i]);
251 const Span<float> factors = all_factors.as_span().slice(node_offsets[pos]);
252
253 tls.average_positions.resize(positions.size());
254 const MutableSpan<float3> average_positions = tls.average_positions;
256 subdiv_ccg, subdiv_ccg.positions.as_span(), grids, average_positions);
257
258 tls.laplacian_disp.resize(positions.size());
259 const MutableSpan<float3> laplacian_disp = tls.laplacian_disp;
260 tls.translations.resize(positions.size());
261 const MutableSpan<float3> translations = tls.translations;
263 orig_data.positions,
264 average_positions,
265 alpha,
266 laplacian_disp,
267 translations);
268 scale_translations(translations, factors);
269
270 scatter_data_grids(subdiv_ccg, laplacian_disp.as_span(), grids, all_laplacian_disp);
271
272 clip_and_lock_translations(sd, ss, positions, translations);
273 apply_translations(translations, grids, subdiv_ccg);
274 },
276
277 node_mask.foreach_index(
278 [&](const int i, const int pos) {
279 LocalData &tls = all_tls.local();
280 const Span<int> grids = nodes[i].grids();
281 const MutableSpan positions = gather_grids_positions(subdiv_ccg, grids, tls.positions);
282 const Span<float> factors = all_factors.as_span().slice(node_offsets[pos]);
283
284 const MutableSpan<float3> laplacian_disp = gather_data_grids(
285 subdiv_ccg, all_laplacian_disp.as_span(), grids, tls.laplacian_disp);
286
287 tls.average_positions.resize(positions.size());
288 const MutableSpan<float3> average_laplacian_disps = tls.average_positions;
290 subdiv_ccg, all_laplacian_disp.as_span(), grids, average_laplacian_disps);
291
292 tls.translations.resize(positions.size());
293 const MutableSpan<float3> translations = tls.translations;
295 laplacian_disp, average_laplacian_disps, beta, translations);
296 scale_translations(translations, factors);
297
298 clip_and_lock_translations(sd, ss, positions, translations);
299 apply_translations(translations, grids, subdiv_ccg);
300 },
302 }
303}
304
306 const Depsgraph &depsgraph,
307 const Sculpt &sd,
308 const Brush &brush,
309 const IndexMask &node_mask,
310 Object &object,
311 const MutableSpan<float3> all_laplacian_disp)
312{
313 const SculptSession &ss = *object.runtime->sculpt_session;
315 const StrokeCache &cache = *ss.cache;
316 const float alpha = brush.surface_smooth_shape_preservation;
317 const float beta = brush.surface_smooth_current_vertex;
319
320 Array<int> node_offset_data;
322 nodes, node_mask, node_offset_data);
323 Array<float> all_factors(node_offsets.total_size());
324
326 node_mask.foreach_index(
327 [&](const int i, const int pos) {
328 LocalData &tls = all_tls.local();
330 const MutableSpan positions = gather_bmesh_positions(verts, tls.positions);
331
332 const MutableSpan<float> factors = all_factors.as_mutable_span().slice(node_offsets[pos]);
333 fill_factor_from_hide_and_mask(*ss.bm, verts, factors);
334 filter_region_clip_factors(ss, positions, factors);
335 if (brush.flag & BRUSH_FRONTFACE) {
336 calc_front_face(cache.view_normal_symm, verts, factors);
337 }
338
339 tls.distances.resize(positions.size());
340 const MutableSpan<float> distances = tls.distances;
341 calc_brush_distances(ss, positions, eBrushFalloffShape(brush.falloff_shape), distances);
342 filter_distances_with_radius(cache.radius, distances, factors);
343 apply_hardness_to_distances(cache, distances);
344 calc_brush_strength_factors(cache, brush, distances, factors);
345
347 depsgraph, object, cache.automasking.get(), nodes[i], verts, factors);
348
349 calc_brush_texture_factors(PaintMode::Sculpt, ss, brush, positions, factors);
350
351 scale_factors(factors, cache.bstrength);
352 clamp_factors(factors);
353 },
355
356 for ([[maybe_unused]] const int iteration : IndexRange(brush.surface_smooth_iterations)) {
357 node_mask.foreach_index(
358 [&](const int i, const int pos) {
359 LocalData &tls = all_tls.local();
361 const MutableSpan positions = gather_bmesh_positions(verts, tls.positions);
362 Array<float3> orig_positions(verts.size());
363 Array<float3> orig_normals(verts.size());
364 orig_position_data_gather_bmesh(*ss.bm_log, verts, orig_positions, orig_normals);
365 const Span<float> factors = all_factors.as_span().slice(node_offsets[pos]);
366
367 tls.average_positions.resize(positions.size());
368 const MutableSpan<float3> average_positions = tls.average_positions;
369 smooth::neighbor_position_average_bmesh(verts, average_positions);
370
371 tls.laplacian_disp.resize(positions.size());
372 const MutableSpan<float3> laplacian_disp = tls.laplacian_disp;
373 tls.translations.resize(positions.size());
374 const MutableSpan<float3> translations = tls.translations;
376 positions, orig_positions, average_positions, alpha, laplacian_disp, translations);
377 scale_translations(translations, factors);
378
379 scatter_data_bmesh(laplacian_disp.as_span(), verts, all_laplacian_disp);
380
381 clip_and_lock_translations(sd, ss, positions, translations);
382 apply_translations(translations, verts);
383 },
385
386 node_mask.foreach_index(
387 [&](const int i, const int pos) {
388 LocalData &tls = all_tls.local();
390 const MutableSpan positions = gather_bmesh_positions(verts, tls.positions);
391 const Span<float> factors = all_factors.as_span().slice(node_offsets[pos]);
392
393 const MutableSpan<float3> laplacian_disp = gather_data_bmesh(
394 all_laplacian_disp.as_span(), verts, tls.laplacian_disp);
395
396 tls.average_positions.resize(positions.size());
397 const MutableSpan<float3> average_laplacian_disps = tls.average_positions;
398 smooth::average_data_bmesh(all_laplacian_disp.as_span(), verts, average_laplacian_disps);
399
400 tls.translations.resize(positions.size());
401 const MutableSpan<float3> translations = tls.translations;
403 laplacian_disp, average_laplacian_disps, beta, translations);
404 scale_translations(translations, factors);
405
406 clip_and_lock_translations(sd, ss, positions, translations);
407 apply_translations(translations, verts);
408 },
410 }
411}
412
413} // namespace surface_smooth_cc
414
415void do_surface_smooth_brush(const Depsgraph &depsgraph,
416 const Sculpt &sd,
417 Object &object,
418 const IndexMask &node_mask)
419{
421 SculptSession &ss = *object.runtime->sculpt_session;
424
427 "Should only be allocated on the first step");
429 }
430
431 switch (pbvh.type()) {
434 depsgraph, sd, brush, node_mask, object, ss.cache->surface_smooth_laplacian_disp);
435 break;
438 depsgraph, sd, brush, node_mask, object, ss.cache->surface_smooth_laplacian_disp);
439 break;
440 }
444 depsgraph, sd, brush, node_mask, object, ss.cache->surface_smooth_laplacian_disp);
445 break;
446 }
447 }
448 pbvh.tag_positions_changed(node_mask);
449 pbvh.update_bounds(depsgraph, object);
450}
451
452} // namespace blender::ed::sculpt_paint::brushes
A BVH for high poly meshes.
Object is a sort of wrapper for general info.
#define PRF_scope(category)
#define BLI_NOINLINE
#define BLI_assert_msg(a, msg)
Span< T > as_span() const
Definition BLI_array.hh:254
MutableSpan< T > as_mutable_span()
Definition BLI_array.hh:259
bool is_empty() const
Definition BLI_array.hh:275
constexpr IndexRange()=default
constexpr int64_t size() const
Definition BLI_span.hh:499
constexpr Span< T > as_span() const
Definition BLI_span.hh:667
int64_t size() const
Definition BLI_set.hh:606
constexpr int64_t size() const
Definition BLI_span.hh:256
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
ccl_device_inline float beta(const float x, const float y)
Definition math_base.h:708
pbvh::Tree * pbvh_get(Object &object)
Span< float3 > vert_normals_eval(const Depsgraph &depsgraph, const Object &object_orig)
Definition pbvh.cc:952
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 BLI_NOINLINE void do_surface_smooth_brush_mesh(const Depsgraph &depsgraph, const Sculpt &sd, const Brush &brush, const IndexMask &node_mask, Object &object, const MutableSpan< float3 > all_laplacian_disp)
static BLI_NOINLINE void do_surface_smooth_brush_grids(const Depsgraph &depsgraph, const Sculpt &sd, const Brush &brush, const IndexMask &node_mask, Object &object, const MutableSpan< float3 > all_laplacian_disp)
static BLI_NOINLINE void clamp_factors(const MutableSpan< float > factors)
static BLI_NOINLINE void do_surface_smooth_brush_bmesh(const Depsgraph &depsgraph, const Sculpt &sd, const Brush &brush, const IndexMask &node_mask, Object &object, const MutableSpan< float3 > all_laplacian_disp)
void do_surface_smooth_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask)
void average_data_bmesh(const Span< T > src, const Set< BMVert *, 0 > &verts, const MutableSpan< T > dst)
void neighbor_data_average_mesh(const Span< T > src, const GroupedSpan< int > vert_neighbors, const MutableSpan< T > dst)
void surface_smooth_laplacian_step(const Span< float3 > positions, const Span< float3 > orig_positions, const Span< float3 > average_positions, const float alpha, MutableSpan< float3 > laplacian_disp, MutableSpan< float3 > translations)
void surface_smooth_displace_step(const Span< float3 > laplacian_disp, const Span< float3 > average_laplacian_disp, const float beta, const MutableSpan< float3 > translations)
void average_data_grids(const SubdivCCG &subdiv_ccg, const Span< T > src, const Span< int > grids, const MutableSpan< T > dst)
void neighbor_position_average_bmesh(const Set< BMVert *, 0 > &verts, const MutableSpan< float3 > new_positions)
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
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 calc_brush_strength_factors(const StrokeCache &cache, const Brush &brush, Span< float > distances, MutableSpan< float > factors)
Definition sculpt.cc:7501
void gather_data_grids(const SubdivCCG &subdiv_ccg, Span< T > src, Span< int > grids, MutableSpan< T > node_data)
Definition sculpt.cc:6528
void vert_random_access_ensure(Object &object)
Definition sculpt.cc:154
void apply_hardness_to_distances(float radius, float hardness, MutableSpan< float > distances)
Definition sculpt.cc:7473
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_distances_with_radius(float radius, Span< float > distances, MutableSpan< float > factors)
Definition sculpt.cc:7422
int vertex_count_get(const Object &object)
Definition sculpt.cc:163
void filter_region_clip_factors(const SculptSession &ss, Span< float3 > vert_positions, Span< int > verts, MutableSpan< float > factors)
Definition sculpt.cc:7285
void gather_data_bmesh(Span< T > src, const Set< BMVert *, 0 > &verts, MutableSpan< T > node_data)
Definition sculpt.cc:6545
void orig_position_data_gather_bmesh(const BMLog &bm_log, const Set< BMVert *, 0 > &verts, MutableSpan< float3 > positions, MutableSpan< float3 > normals)
bool stroke_is_first_brush_step(const StrokeCache &cache)
Definition sculpt.cc:661
void scale_translations(MutableSpan< float3 > translations, Span< float > factors)
Definition sculpt.cc:7837
void scale_factors(MutableSpan< float > factors, float strength)
Definition sculpt.cc:7856
void clip_and_lock_translations(const Sculpt &sd, const SculptSession &ss, Span< float3 > positions, Span< int > verts, MutableSpan< float3 > translations)
Definition sculpt.cc:7664
void scatter_data_mesh(Span< T > src, Span< int > indices, MutableSpan< T > dst)
void calc_brush_distances(const SculptSession &ss, Span< float3 > vert_positions, Span< int > vert, eBrushFalloffShape falloff_shape, MutableSpan< float > r_distances)
Definition sculpt.cc:7370
OffsetIndices< int > create_node_vert_offsets(Span< bke::pbvh::MeshNode > nodes, const IndexMask &node_mask, Array< int > &node_data)
Definition sculpt.cc:7912
void apply_translations(Span< float3 > translations, Span< int > verts, MutableSpan< float3 > positions)
Definition sculpt.cc:7592
OrigPositionData orig_position_data_get_mesh(const Object &object, const bke::pbvh::MeshNode &node)
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 calc_front_face(const float3 &view_normal, Span< float3 > normals, MutableSpan< float > factors)
Definition sculpt.cc:7223
void calc_brush_texture_factors(PaintMode paint_mode, const SculptSession &ss, const Brush &brush, Span< float3 > vert_positions, Span< int > vert, MutableSpan< float > factors)
Definition sculpt.cc:7513
void scatter_data_grids(const SubdivCCG &subdiv_ccg, Span< T > node_data, Span< int > grids, MutableSpan< T > dst)
Definition sculpt.cc:6560
OffsetIndices< int > create_node_vert_offsets_bmesh(Span< bke::pbvh::BMeshNode > nodes, const IndexMask &node_mask, Array< int > &node_data)
Definition sculpt.cc:7936
constexpr ParallelGrainSize grain_size(int grain_size)
CCGKey BKE_subdiv_ccg_key_top_level(const SubdivCCG &subdiv_ccg)
BMesh const char void * data
const Brush * BKE_paint_brush_for_read(const Paint *paint)
VecBase< float, 3 > float3
const Set< BMVert *, 0 > & BKE_pbvh_bmesh_node_unique_verts(bke::pbvh::BMeshNode *node)
ed::sculpt_paint::StrokeCache * cache
Definition BKE_paint.hh:409
std::unique_ptr< auto_mask::Cache > automasking
void resize(int new_size)
Definition vector.hh:94