Blender V5.3
scene_project.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2025 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
24
25#include <cfloat>
26
28
29#include "DNA_brush_types.h"
30#include "DNA_mesh_types.h"
31#include "DNA_object_types.h"
32#include "DNA_scene_types.h"
33
34#include "BKE_bvh.hh"
35#include "BKE_mesh.hh"
36#include "BKE_object_types.hh"
37#include "BKE_paint.hh"
38#include "BKE_paint_bvh.hh"
39#include "BKE_subdiv_ccg.hh"
40
42#include "BLI_math_matrix.hh"
43#include "BLI_math_vector.hh"
44#include "BLI_task.hh"
45
49
50#include "bmesh.hh"
51
53
54inline namespace scene_project_cc {
55
64
65static inline float absolute_min_distance(const float d1, const float d2)
66{
67 return math::abs(d1) < math::abs(d2) ? d1 : d2;
68}
69
102static void object_raycast(const ProjectBrushTarget &project_target,
103 const bool bidirectional,
104 const float3 &normal,
105 const Span<float3> positions,
106 const Span<float> factors,
107 const MutableSpan<float3> ray_origins,
108 const MutableSpan<float> best_hit_distances)
109{
111 /* Positions and normal are in the coordinate system of the active object. Convert them to the
112 * coordinate system of the target. */
113 const float3 ray_direction = math::transform_direction(project_target.active_to_target_matrix,
114 normal);
115
116 math::transform_points(positions, project_target.active_to_target_matrix, ray_origins, false);
117
119 threading::parallel_for(positions.index_range(), 256, [&](IndexRange range) {
120 std::optional<bke::bvh::RayHit> hit;
121
122 for (const int i : range) {
123 if (factors[i] == 0.0f) {
124 continue;
125 }
126
127 hit = project_target.tree_data->ray_intersect(
128 bke::bvh::Ray(ray_origins[i], ray_direction));
129 if (hit) {
130 best_hit_distances[i] = absolute_min_distance(best_hit_distances[i], hit->distance);
131 }
132 }
133
134 if (bidirectional) {
135 for (const int i : range) {
136 if (factors[i] == 0.0f) {
137 continue;
138 }
139
140 hit = project_target.tree_data->ray_intersect(
141 bke::bvh::Ray(ray_origins[i], -ray_direction));
142 if (hit) {
143 best_hit_distances[i] = absolute_min_distance(best_hit_distances[i], -hit->distance);
144 }
145 }
146 }
147 });
148 });
149}
150
155static void scene_raycast(const Span<ProjectBrushTarget> project_targets,
156 const bool bidirectional,
157 const float minimum_distance,
158 const float3 &normal,
159 const Span<float3> positions,
160 const Span<float> factors,
161 const MutableSpan<float3> ray_origins,
162 const MutableSpan<float> r_hit_distances)
163{
165 r_hit_distances.fill(BVH_RAYCAST_DIST_MAX);
166
167 for (const int i : project_targets.index_range()) {
168 object_raycast(project_targets[i],
169 bidirectional,
170 normal,
171 positions,
172 factors,
173 ray_origins,
174 r_hit_distances);
175 }
176
177 /* Set hit distances to zero for vertices with no hits, preventing displacement. */
178 for (const int i : r_hit_distances.index_range()) {
179 if (math::abs(r_hit_distances[i]) == BVH_RAYCAST_DIST_MAX) {
180 r_hit_distances[i] = 0.0f;
181 }
182 else {
183 r_hit_distances[i] = r_hit_distances[i] - minimum_distance;
184 }
185 }
186}
187
188static void calc_translations(const float3 &normal,
189 const Span<float> factors,
190 const Span<float> hit_distances,
191 const MutableSpan<float3> r_translations)
192{
194 for (const int i : factors.index_range()) {
195 r_translations[i] = normal * hit_distances[i] * factors[i];
196 }
197}
198
199static float3 calc_normal(const Brush &brush, const StrokeCache &cache)
200{
201 switch (brush.project_ray_direction_type) {
203 return -cache.view_normal_symm;
205 return -cache.sculpt_normal_symm;
206 default:
208 return float3(0.0f);
209 }
210}
211
212static void calc_faces(const Depsgraph &depsgraph,
213 const Sculpt &sd,
214 const Brush &brush,
215 const bool bidirectional,
216 const float3 &normal,
217 const MeshAttributeData &attribute_data,
218 const Span<float3> vert_normals,
220 Object &object,
221 const PositionDeformData &position_data)
222{
223 SculptSession &ss = *object.runtime->sculpt_session;
224 const Span<int> verts = node.verts();
225
229 brush,
230 object,
231 attribute_data,
232 position_data.eval,
233 vert_normals,
234 node,
235 factors,
236 distances);
237
239 gather_data_mesh<float3>(position_data.eval, verts, positions);
240
242 Array<float, bke::pbvh::MESH_LEAF_LIMIT> hit_distances(verts.size());
243
245 bidirectional,
246 brush.minimum_distance,
247 normal,
248 positions,
249 factors,
250 ray_origins,
251 hit_distances);
252
254 calc_translations(normal, factors, hit_distances, translations);
255 scale_translations(translations, ss.cache->bstrength);
256
257 clip_and_lock_translations(sd, ss, position_data.eval, verts, translations);
258 position_data.deform(translations, verts);
259}
260
261static void calc_grids(const Depsgraph &depsgraph,
262 const Sculpt &sd,
263 Object &object,
264 const Brush &brush,
265 const bool bidirectional,
266 const float3 &normal,
268 LocalData &tls)
269{
270 SculptSession &ss = *object.runtime->sculpt_session;
271 SubdivCCG &subdiv_ccg = *ss.subdiv_ccg;
272
273 const Span<int> grids = node.grids();
274 const MutableSpan<float3> positions = gather_grids_positions(subdiv_ccg, grids, tls.positions);
275
276 calc_factors_common_grids(depsgraph, brush, object, positions, node, tls.factors, tls.distances);
277
278 tls.ray_origins.resize(positions.size());
279 tls.hit_distances.resize(positions.size());
280 const MutableSpan<float> hit_distances = tls.hit_distances;
282 bidirectional,
283 brush.minimum_distance,
284 normal,
285 positions,
286 tls.factors,
287 tls.ray_origins,
288 hit_distances);
289
290 tls.translations.resize(positions.size());
291 const MutableSpan<float3> translations = tls.translations;
292 calc_translations(normal, tls.factors, hit_distances, translations);
293 scale_translations(translations, ss.cache->bstrength);
294
295 clip_and_lock_translations(sd, ss, positions, translations);
296 apply_translations(translations, grids, subdiv_ccg);
297}
298
299static void calc_bmesh(const Depsgraph &depsgraph,
300 const Sculpt &sd,
301 Object &object,
302 const Brush &brush,
303 const bool bidirectional,
304 const float3 &normal,
306 LocalData &tls)
307{
308 SculptSession &ss = *object.runtime->sculpt_session;
309
311 const MutableSpan positions = gather_bmesh_positions(verts, tls.positions);
312
313 calc_factors_common_bmesh(depsgraph, brush, object, positions, node, tls.factors, tls.distances);
314
315 tls.ray_origins.resize(positions.size());
316 tls.hit_distances.resize(positions.size());
317 const MutableSpan<float> hit_distances = tls.hit_distances;
319 bidirectional,
320 brush.minimum_distance,
321 normal,
322 positions,
323 tls.factors,
324 tls.ray_origins,
325 hit_distances);
326
327 tls.translations.resize(positions.size());
328 const MutableSpan<float3> translations = tls.translations;
329 calc_translations(normal, tls.factors, hit_distances, translations);
330 scale_translations(translations, ss.cache->bstrength);
331
332 clip_and_lock_translations(sd, ss, positions, translations);
333 apply_translations(translations, verts);
334}
335
336} // namespace scene_project_cc
337
338void do_scene_project_brush(const Depsgraph &depsgraph,
339 const Sculpt &sd,
340 Object &object,
341 const IndexMask &node_mask)
342{
346 const StrokeCache &cache = *object.runtime->sculpt_session->cache;
347
348 const bool bidirectional = brush.flag2 & BRUSH_PROJECT_USE_BIDIRECTIONAL;
349 const float3 normal = calc_normal(brush, cache);
350
352 switch (pbvh.type()) {
354 const Mesh &mesh = *id_cast<Mesh *>(object.data);
355 const MeshAttributeData attribute_data(mesh);
356 const PositionDeformData position_data(depsgraph, object);
357 const Span<float3> vert_normals = bke::pbvh::vert_normals_eval(depsgraph, object);
359
360 node_mask.foreach_index(
361 [&](const int i) {
362 calc_faces(depsgraph,
363 sd,
364 brush,
365 bidirectional,
366 normal,
367 attribute_data,
368 vert_normals,
369 nodes[i],
370 object,
371 position_data);
372 bke::pbvh::update_node_bounds_mesh(position_data.eval, nodes[i]);
373 },
375 break;
376 }
378 SubdivCCG &subdiv_ccg = *object.runtime->sculpt_session->subdiv_ccg;
379 MutableSpan<float3> positions = subdiv_ccg.positions;
381 node_mask.foreach_index(
382 [&](const int i) {
383 LocalData &tls = all_tls.local();
384 calc_grids(depsgraph, sd, object, brush, bidirectional, normal, nodes[i], tls);
385 bke::pbvh::update_node_bounds_grids(subdiv_ccg.grid_area, positions, nodes[i]);
386 },
388 break;
389 }
392 node_mask.foreach_index(
393 [&](const int i) {
394 LocalData &tls = all_tls.local();
395 calc_bmesh(depsgraph, sd, object, brush, bidirectional, normal, nodes[i], tls);
397 },
399 break;
400 }
401 }
402 pbvh.tag_positions_changed(node_mask);
403 pbvh.flush_bounds_to_parents();
404}
405
406} // namespace blender::ed::sculpt_paint::brushes
A BVH for high poly meshes.
#define BVH_RAYCAST_DIST_MAX
Object is a sort of wrapper for general info.
#define PRF_scope(category)
#define BLI_assert_unreachable()
constexpr int64_t size() const
Definition BLI_span.hh:499
constexpr void fill(const T &value) const
Definition BLI_span.hh:523
constexpr IndexRange index_range() const
Definition BLI_span.hh:676
constexpr int64_t size() const
Definition BLI_span.hh:256
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
std::optional< RayHit > ray_intersect(const Ray &ray) const
Definition bvh.cc:439
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
pbvh::Tree * pbvh_get(Object &object)
void update_node_bounds_bmesh(BMeshNode &node)
Definition pbvh.cc:1216
void update_node_bounds_mesh(Span< float3 > positions, MeshNode &node)
Definition pbvh.cc:1196
Span< float3 > vert_normals_eval(const Depsgraph &depsgraph, const Object &object_orig)
Definition pbvh.cc:952
void update_node_bounds_grids(int grid_area, Span< float3 > positions, GridsNode &node)
Definition pbvh.cc:1205
static void calc_bmesh(const Depsgraph &depsgraph, const Sculpt &sd, const Brush &brush, Object &object, bke::pbvh::BMeshNode &node, LocalData &tls, MutableSpan< float > layer_displacement_factor)
static void calc_grids(const Depsgraph &depsgraph, const Sculpt &sd, const Brush &brush, Object &object, const bool use_persistent_base, const Span< float3 > persistent_base_positions, const Span< float3 > persistent_base_normals, bke::pbvh::GridsNode &node, LocalData &tls, MutableSpan< float > layer_displacement_factor)
static BLI_NOINLINE void calc_translations(const Span< float3 > orig_positions, const Span< float3 > orig_normals, const Span< float3 > positions, const Span< float > displacement_factors, const Span< float > factors, const float height, const MutableSpan< float3 > r_translations)
static void calc_faces(const Depsgraph &depsgraph, const Sculpt &sd, const Brush &brush, const MeshAttributeData &attribute_data, const Span< float3 > vert_normals, const bool use_persistent_base, const Span< float3 > persistent_base_positions, const Span< float3 > persistent_base_normals, Object &object, bke::pbvh::MeshNode &node, MutableSpan< float > layer_displacement_factor, const PositionDeformData &position_data)
static void object_raycast(const ProjectBrushTarget &project_target, const bool bidirectional, const float3 &normal, const Span< float3 > positions, const Span< float > factors, const MutableSpan< float3 > ray_origins, const MutableSpan< float > best_hit_distances)
static float absolute_min_distance(const float d1, const float d2)
static float3 calc_normal(const Brush &brush, const StrokeCache &cache)
static void scene_raycast(const Span< ProjectBrushTarget > project_targets, const bool bidirectional, const float minimum_distance, const float3 &normal, const Span< float3 > positions, const Span< float > factors, const MutableSpan< float3 > ray_origins, const MutableSpan< float > r_hit_distances)
void do_scene_project_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask)
MutableSpan< float3 > gather_grids_positions(const SubdivCCG &subdiv_ccg, const Span< int > grids, Vector< float3 > &positions)
void gather_bmesh_positions(const Set< BMVert *, 0 > &verts, MutableSpan< float3 > positions)
Definition sculpt.cc:6497
void calc_factors_common_grids(const Depsgraph &depsgraph, const Brush &brush, const Object &object, Span< float3 > positions, const bke::pbvh::GridsNode &node, Vector< float > &r_factors, Vector< float > &r_distances)
Definition sculpt.cc:6804
void scale_translations(MutableSpan< float3 > translations, Span< float > factors)
Definition sculpt.cc:7837
void calc_factors_common_mesh_indexed(const Depsgraph &depsgraph, const Brush &brush, const Object &object, const MeshAttributeData &attribute_data, Span< float3 > vert_positions, Span< float3 > vert_normals, const bke::pbvh::MeshNode &node, MutableSpan< float > factors, MutableSpan< float > distances)
Definition sculpt.cc:6739
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 apply_translations(Span< float3 > translations, Span< int > verts, MutableSpan< float3 > positions)
Definition sculpt.cc:7592
void gather_data_mesh(Span< T > src, Span< int > indices, MutableSpan< T > dst)
void calc_factors_common_bmesh(const Depsgraph &depsgraph, const Brush &brush, const Object &object, Span< float3 > positions, bke::pbvh::BMeshNode &node, Vector< float > &r_factors, Vector< float > &r_distances)
Definition sculpt.cc:6891
constexpr ParallelGrainSize grain_size(int grain_size)
T abs(const T &a)
VecBase< T, 3 > transform_direction(const MatBase< T, 3, 3 > &mat, const VecBase< T, 3 > &direction)
void transform_points(const float4x4 &transform, MutableSpan< float3 > points, bool use_threading=true)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
Definition BLI_task.hh:69
auto isolate_task(const Function &function)
Definition BLI_task.hh:224
@ BRUSH_PROJECT_USE_BIDIRECTIONAL
BMesh const char void * data
const Brush * BKE_paint_brush_for_read(const Paint *paint)
@ BRUSH_PROJECT_RAY_DIRECTION_PLANE_NORMAL
@ BRUSH_PROJECT_RAY_DIRECTION_VIEW_NORMAL
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
Array< float3 > positions
Vector< ProjectBrushTarget > project_targets