Blender V5.3
node_geo_distribute_points_on_faces.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#include "BLI_kdtree_new.hh"
6#include "BLI_math_geom_c.hh"
9#include "BLI_noise.hh"
10#include "BLI_rand.hh"
11#include "BLI_task.hh"
12
14
15#include "BKE_attribute_math.hh"
16#include "BKE_mesh.hh"
17#include "BKE_mesh_sample.hh"
18#include "BKE_pointcloud.hh"
19
21
23#include "UI_resources.hh"
24
26#include "GEO_randomize.hh"
27
28#include "node_geometry_util.hh"
29
31
33{
34 auto enable_random = [](bNode &node) {
36 };
37 auto enable_poisson = [](bNode &node) {
39 };
40
41 b.add_input<decl::Geometry>("Mesh"_ustr)
42 .supported_type(GeometryComponent::Type::Mesh)
43 .description("Mesh on whose faces to distribute points on");
44 b.add_input<decl::Bool>("Selection"_ustr)
45 .default_value(true)
46 .hide_value()
47 .evaluated_geometry_field();
48 auto &distance_min = b.add_input<decl::Float>("Distance Min"_ustr)
49 .min(0.0f)
50 .subtype(PROP_DISTANCE)
51 .make_available(enable_poisson)
52 .available(false);
53 auto &density_max = b.add_input<decl::Float>("Density Max"_ustr)
54 .default_value(10.0f)
55 .min(0.0f)
56 .make_available(enable_poisson)
57 .available(false);
58 auto &density = b.add_input<decl::Float>("Density"_ustr)
59 .default_value(10.0f)
60 .min(0.0f)
61 .evaluated_geometry_field()
62 .make_available(enable_random)
63 .available(false);
64 auto &density_factor = b.add_input<decl::Float>("Density Factor"_ustr)
65 .default_value(1.0f)
66 .min(0.0f)
67 .max(1.0f)
69 .evaluated_geometry_field()
70 .make_available(enable_poisson)
71 .available(false);
72 b.add_input<decl::Int>("Seed"_ustr);
73
74 b.add_output<decl::Geometry>("Points"_ustr).propagate_all_geometry();
75 b.add_output<decl::Vector>("Normal"_ustr).anonymous_attribute_output();
76 b.add_output<decl::Rotation>("Rotation"_ustr).anonymous_attribute_output();
77
78 const bNode *node = b.node_or_null();
79 if (node != nullptr) {
80 switch (node->custom1) {
82 distance_min.available(true);
83 density_max.available(true);
84 density_factor.available(true);
85 break;
87 density.available(true);
88 break;
89 }
90 }
91}
92
93static void node_layout(ui::Layout &layout, bContext * /*C*/, PointerRNA *ptr)
94{
95 layout.prop(ptr, "distribute_method", UI_ITEM_NONE, "", ICON_NONE);
96}
97
98static void node_layout_ex(ui::Layout &layout, bContext * /*C*/, PointerRNA *ptr)
99{
100 layout.prop(ptr, "use_legacy_normal", UI_ITEM_NONE, std::nullopt, ICON_NONE);
101}
102
107{
108 float quat[4];
109 vec_to_quat(quat, normal, OB_NEGZ, OB_POSY);
110 return math::normalize(math::Quaternion(quat));
111}
112
114 const Span<float> densities,
115 const int seed,
116 Array<int> &r_count_data)
117{
118 const Span<float3> positions = mesh.vert_positions();
119 const Span<int> corner_verts = mesh.corner_verts();
120 const Span<int3> corner_tris = mesh.corner_tris();
121
122 r_count_data = Array<int>(corner_tris.size() + 1);
123 threading::parallel_for(corner_tris.index_range(), 1024, [&](const IndexRange range) {
124 for (const int64_t tri_i : range) {
125 const int3 &tri = corner_tris[tri_i];
126 const float density = (densities[tri[0]] + densities[tri[1]] + densities[tri[2]]) / 3.0f;
127 const float area = area_tri_v3(positions[corner_verts[tri[0]]],
128 positions[corner_verts[tri[1]]],
129 positions[corner_verts[tri[2]]]);
130 const int corner_tri_seed = noise::hash(tri_i, seed);
131 RandomNumberGenerator corner_tri_rng(corner_tri_seed);
132 r_count_data[tri_i] = corner_tri_rng.round_probabilistic(area * density);
133 }
134 });
135
137}
138
140 const float density,
141 const int seed,
142 Array<int> &r_count_data)
143{
144 const Span<float3> positions = mesh.vert_positions();
145 const Span<int> corner_verts = mesh.corner_verts();
146 const Span<int3> corner_tris = mesh.corner_tris();
147
148 r_count_data = Array<int>(corner_tris.size() + 1);
149 threading::parallel_for(corner_tris.index_range(), 1024, [&](const IndexRange range) {
150 for (const int64_t tri_i : range) {
151 const int3 &tri = corner_tris[tri_i];
152 const float area = area_tri_v3(positions[corner_verts[tri[0]]],
153 positions[corner_verts[tri[1]]],
154 positions[corner_verts[tri[2]]]);
155 const int corner_tri_seed = noise::hash(tri_i, seed);
156 RandomNumberGenerator corner_tri_rng(corner_tri_seed);
157 r_count_data[tri_i] = corner_tri_rng.round_probabilistic(area * density);
158 }
159 });
160
162}
163
164static void sample_bary_coords(const Mesh &mesh,
165 const int seed,
166 const OffsetIndices<int> points_by_tri,
167 Vector<float3> &r_positions,
168 Vector<float3> &r_bary_coords,
169 Vector<int> &r_tri_indices)
170{
171 const Span<float3> positions = mesh.vert_positions();
172 const Span<int> corner_verts = mesh.corner_verts();
173 const Span<int3> corner_tris = mesh.corner_tris();
174
175 r_positions.resize(points_by_tri.total_size());
176 r_bary_coords.resize(points_by_tri.total_size());
177 r_tri_indices.resize(points_by_tri.total_size());
178
180 corner_tris.index_range(),
181 4096,
182 [&](const IndexRange range) {
183 for (const int64_t tri_i : range) {
184 const int3 &tri = corner_tris[tri_i];
185 const float3 &v0_pos = positions[corner_verts[tri[0]]];
186 const float3 &v1_pos = positions[corner_verts[tri[1]]];
187 const float3 &v2_pos = positions[corner_verts[tri[2]]];
188
189 const int corner_tri_seed = noise::hash(tri_i, seed);
190 RandomNumberGenerator corner_tri_rng(corner_tri_seed);
191
192 /* Retain legacy behavior. */
193 corner_tri_rng.skip(1);
194
195 for (const int i : points_by_tri[tri_i]) {
196 const float3 bary_coord = corner_tri_rng.get_barycentric_coordinates();
197 r_positions[i] = bke::attribute_math::mix3(bary_coord, v0_pos, v1_pos, v2_pos);
198 r_bary_coords[i] = bary_coord;
199 r_tri_indices[i] = tri_i;
200 }
201 }
202 },
204 [&](const IndexRange range) { return points_by_tri[range].size(); }));
205}
206
208 Span<float3> positions, const float minimum_distance, MutableSpan<bool> elimination_mask)
209{
210 if (minimum_distance <= 0.0f) {
211 return;
212 }
213
214 const KDTreeNew<float3> tree(positions);
215
216 for (const int i : positions.index_range()) {
217 if (elimination_mask[i]) {
218 continue;
219 }
220
222 positions[i], minimum_distance, [&](const int index, const float /*distance_sq*/) {
223 if (index != i) {
224 elimination_mask[index] = true;
225 }
226 });
227 }
228}
229
231 const Mesh &mesh,
232 const Span<float> density_factors,
233 const Span<float3> bary_coords,
234 const Span<int> tri_indices,
235 const MutableSpan<bool> elimination_mask)
236{
237 const Span<int3> corner_tris = mesh.corner_tris();
238 for (const int i : bary_coords.index_range()) {
239 if (elimination_mask[i]) {
240 continue;
241 }
242
243 const int3 &tri = corner_tris[tri_indices[i]];
244 const float3 bary_coord = bary_coords[i];
245
246 const float v0_density_factor = density_factors[tri[0]];
247 const float v1_density_factor = density_factors[tri[1]];
248 const float v2_density_factor = density_factors[tri[2]];
249
250 const float probability = v0_density_factor * bary_coord.x + v1_density_factor * bary_coord.y +
251 v2_density_factor * bary_coord.z;
252
254 if (hash > probability) {
255 elimination_mask[i] = true;
256 }
257 }
258}
259
260BLI_NOINLINE static void eliminate_points_based_on_mask(const Span<bool> elimination_mask,
261 Vector<float3> &positions,
262 Vector<float3> &bary_coords,
263 Vector<int> &tri_indices)
264{
265 for (int i = positions.size() - 1; i >= 0; i--) {
266 if (elimination_mask[i]) {
267 positions.remove_and_reorder(i);
268 bary_coords.remove_and_reorder(i);
269 tri_indices.remove_and_reorder(i);
270 }
271 }
272}
273
275 const Span<float3> bary_coords,
276 const Span<int> tri_indices,
277 const AttrDomain source_domain,
278 const GVArray &source_data,
279 GMutableSpan output_data)
280{
281 switch (source_domain) {
282 case AttrDomain::Point: {
284 mesh.corner_tris(),
285 tri_indices,
286 bary_coords,
287 source_data,
288 IndexMask(output_data.size()),
289 output_data);
290 break;
291 }
292 case AttrDomain::Corner: {
294 tri_indices,
295 bary_coords,
296 source_data,
297 IndexMask(output_data.size()),
298 output_data);
299 break;
300 }
301 case AttrDomain::Face: {
303 tri_indices,
304 source_data,
305 IndexMask(output_data.size()),
306 output_data);
307 break;
308 }
309 default: {
310 /* Not supported currently. */
311 return;
312 }
313 }
314}
315
318 PointCloud &points,
319 const Span<float3> bary_coords,
320 const Span<int> tri_indices)
321{
322 const AttributeAccessor mesh_attributes = mesh.attributes();
323 MutableAttributeAccessor point_attributes = points.attributes_for_write();
324
325 mesh_attributes.foreach_attribute([&](const bke::AttributeIter &iter) {
326 if (iter.domain == AttrDomain::Edge) {
327 return;
328 }
329 const StringRef name = iter.name;
330 if (iter.is_builtin && !point_attributes.is_builtin(name)) {
331 return;
332 }
333 if (ELEM(name, "position", ".select_vert")) {
334 return;
335 }
336 if (filter.allow_skip(name)) {
337 return;
338 }
339 const StringRef dst_name = name == ".select_poly" ? ".selection" : name;
340 GAttributeReader src = iter.get();
341 if (!src) {
342 return;
343 }
344 const CommonVArrayInfo info = src.varray.common_info();
347 if (point_attributes.add(dst_name, AttrDomain::Point, iter.data_type, init)) {
348 return;
349 }
350 }
352 dst_name, AttrDomain::Point, iter.data_type);
353 if (!dst) {
354 return;
355 }
356 interpolate_attribute(mesh, bary_coords, tri_indices, src.domain, src.varray, dst.span);
357 dst.finish();
358 });
359}
360
361namespace {
362struct AttributeOutputs {
363 std::optional<std::string> normal_id;
364 std::optional<std::string> rotation_id;
365};
366} // namespace
367
369 const Span<float3> bary_coords,
370 const Span<int> tri_indices,
371 MutableSpan<float3> r_normals)
372{
373 switch (mesh.normals_domain()) {
375 const Span<int> corner_verts = mesh.corner_verts();
376 const Span<int3> corner_tris = mesh.corner_tris();
377 const Span<float3> vert_normals = mesh.vert_normals();
378 threading::parallel_for(bary_coords.index_range(), 512, [&](const IndexRange range) {
379 bke::mesh_surface_sample::sample_point_normals(
380 corner_verts, corner_tris, tri_indices, bary_coords, vert_normals, range, r_normals);
381 });
382 break;
383 }
385 const Span<int> tri_faces = mesh.corner_tri_faces();
386 VArray<float3> face_normals = VArray<float3>::from_span(mesh.face_normals());
387 threading::parallel_for(bary_coords.index_range(), 512, [&](const IndexRange range) {
388 bke::mesh_surface_sample::sample_face_attribute(
389 tri_faces, tri_indices, face_normals, range, r_normals);
390 });
391 break;
392 }
394 const Span<int3> corner_tris = mesh.corner_tris();
395 const Span<float3> corner_normals = mesh.corner_normals();
396 threading::parallel_for(bary_coords.index_range(), 512, [&](const IndexRange range) {
397 bke::mesh_surface_sample::sample_corner_normals(
398 corner_tris, tri_indices, bary_coords, corner_normals, range, r_normals);
399 });
400 break;
401 }
402 }
403}
404
406 const Span<float3> bary_coords,
407 const Span<int> tri_indices,
408 MutableSpan<float3> r_normals)
409{
410 const Span<float3> positions = mesh.vert_positions();
411 const Span<int> corner_verts = mesh.corner_verts();
412 const Span<int3> corner_tris = mesh.corner_tris();
413
414 for (const int i : bary_coords.index_range()) {
415 const int tri_i = tri_indices[i];
416 const int3 &tri = corner_tris[tri_i];
417
418 const int v0_index = corner_verts[tri[0]];
419 const int v1_index = corner_verts[tri[1]];
420 const int v2_index = corner_verts[tri[2]];
421 const float3 v0_pos = positions[v0_index];
422 const float3 v1_pos = positions[v1_index];
423 const float3 v2_pos = positions[v2_index];
424
425 float3 normal;
426 normal_tri_v3(normal, v0_pos, v1_pos, v2_pos);
427 r_normals[i] = normal;
428 }
429}
430
431static void compute_rotation_output(const Span<float3> normals,
433{
434 threading::parallel_for(normals.index_range(), 512, [&](const IndexRange range) {
435 for (const int i : range) {
436 r_rotations[i] = normal_to_rotation(normals[i]);
437 }
438 });
439}
440
442 PointCloud &points,
443 const Span<float3> bary_coords,
444 const Span<int> tri_indices,
445 const AttributeOutputs &attribute_outputs,
446 const bool use_legacy_normal)
447{
448 MutableAttributeAccessor point_attributes = points.attributes_for_write();
449
451 "id", AttrDomain::Point);
452
455
456 if (attribute_outputs.normal_id) {
457 normals = point_attributes.lookup_or_add_for_write_only_span<float3>(
458 *attribute_outputs.normal_id, AttrDomain::Point);
459 }
460 if (attribute_outputs.rotation_id) {
461 rotations = point_attributes.lookup_or_add_for_write_only_span<math::Quaternion>(
462 *attribute_outputs.rotation_id, AttrDomain::Point);
463 }
464
465 threading::parallel_for(bary_coords.index_range(), 1024, [&](const IndexRange range) {
466 for (const int i : range) {
467 const int tri_i = tri_indices[i];
468 const float3 &bary_coord = bary_coords[i];
469 ids.span[i] = noise::hash(noise::hash_float(bary_coord), tri_i);
470 }
471 });
472
473 if (normals) {
474 if (use_legacy_normal) {
475 compute_legacy_normal_outputs(mesh, bary_coords, tri_indices, normals.span);
476 }
477 else {
478 compute_normal_outputs(mesh, bary_coords, tri_indices, normals.span);
479 }
480
481 if (rotations) {
482 compute_rotation_output(normals.span, rotations.span);
483 }
484 }
485
486 ids.finish();
487 normals.finish();
488 rotations.finish();
489}
490
492 const Field<float> &density_field,
493 const Field<bool> &selection_field)
494{
495 const AttrDomain domain = AttrDomain::Corner;
496 const int domain_size = mesh.attributes().domain_size(domain);
497 Array<float> densities(domain_size, 0.0f);
498
499 const bke::MeshFieldContext field_context{mesh, domain};
500 fn::FieldEvaluator evaluator{field_context, domain_size};
501 evaluator.set_selection(selection_field);
502 evaluator.add_with_destination(density_field, densities.as_mutable_span());
503 evaluator.evaluate();
504 return densities;
505}
506
508 const Field<bool> &selection_field,
509 const Field<float> &density_field,
510 const int seed,
511 const AttributeOutputs &attribute_outputs,
512 const bke::AttributeFilter &attribute_filter,
513 const bool use_legacy_normal)
514{
515 Array<int> count_data;
516 OffsetIndices<int> points_by_tri;
517 if (selection_field.depends_on_input() || density_field.depends_on_input()) {
519 mesh, density_field, selection_field);
520 points_by_tri = calc_tri_point_offsets(mesh, densities, seed, count_data);
521 }
522 else {
523 const float density = fn::evaluate_constant_field<float>(density_field);
524 points_by_tri = calc_tri_point_offsets(mesh, density, seed, count_data);
525 }
526 if (points_by_tri.total_size() == 0) {
527 return nullptr;
528 }
529
530 Vector<float3> positions;
531 Vector<float3> bary_coords;
532 Vector<int> tri_indices;
533 sample_bary_coords(mesh, seed, points_by_tri, positions, bary_coords, tri_indices);
534
536 positions.size());
537 bke::MutableAttributeAccessor point_attributes = pointcloud->attributes_for_write();
538 VectorData<float3, GuardedAllocator> positions_data = positions.release();
539 const auto *attr_data = implicit_sharing::info_for_mem_free(positions_data.data);
540 point_attributes.add<float3>("position",
542 bke::AttributeInitShared(positions_data.data, *attr_data));
543 attr_data->remove_user_and_delete_if_last();
544 point_attributes.add<float>("radius", bke::AttrDomain::Point, bke::AttributeInitValue(0.05f));
545
546 propagate_attributes(mesh, attribute_filter, *pointcloud, bary_coords, tri_indices);
547
549 mesh, *pointcloud, bary_coords, tri_indices, attribute_outputs, use_legacy_normal);
550
552
553 return pointcloud;
554}
555
557 const Field<bool> &selection_field,
558 const Field<float> &density_factor_field,
559 const float minimum_distance,
560 const float density_max,
561 const int seed,
562 const AttributeOutputs &attribute_outputs,
563 const bke::AttributeFilter &attribute_filter,
564 const bool use_legacy_normal)
565{
566 if (density_max <= 0.0f) {
567 return nullptr;
568 }
569 Array<int> count_data;
570 const OffsetIndices<int> points_by_tri = calc_tri_point_offsets(
571 mesh, density_max, seed, count_data);
572 if (points_by_tri.total_size() == 0) {
573 return nullptr;
574 }
575
576 Vector<float3> positions;
577 Vector<float3> bary_coords;
578 Vector<int> tri_indices;
579 sample_bary_coords(mesh, seed, points_by_tri, positions, bary_coords, tri_indices);
580
581 Array<bool> elimination_mask(positions.size(), false);
582 update_elimination_mask_for_close_points(positions, minimum_distance, elimination_mask);
583
585 mesh, density_factor_field, selection_field);
586
588 mesh, density_factors, bary_coords, tri_indices, elimination_mask.as_mutable_span());
589
590 eliminate_points_based_on_mask(elimination_mask.as_span(), positions, bary_coords, tri_indices);
591
592 if (positions.is_empty()) {
593 return nullptr;
594 }
595
597 positions.size());
598 bke::MutableAttributeAccessor point_attributes = pointcloud->attributes_for_write();
599 pointcloud->positions_for_write().copy_from(positions);
600 point_attributes.add<float>("radius", bke::AttrDomain::Point, bke::AttributeInitValue(0.05f));
601
602 propagate_attributes(mesh, attribute_filter, *pointcloud, bary_coords, tri_indices);
603
605 mesh, *pointcloud, bary_coords, tri_indices, attribute_outputs, use_legacy_normal);
606
608
609 return pointcloud;
610}
611
613{
614 const static mf::MultiFunction &max_fn = fn::multi_function::registry::lookup(
615 "max(float, float)"_ustr);
617 max_fn, {params.extract_input<Field<float>>(input), fn::Field<float>(0.0f)}));
618}
619
621{
622 GeometrySet geometry_set = params.extract_input<GeometrySet>("Mesh"_ustr);
623
624 const Field<bool> selection = params.extract_input<Field<bool>>("Selection"_ustr);
625 const int seed = params.extract_input<int>("Seed"_ustr) * 5383843;
626 const NodeAttributeFilter attribute_filter = params.get_attribute_filter("Points"_ustr);
627 const bool use_legacy_normal = params.node().custom2 != 0;
628
629 AttributeOutputs attribute_outputs;
630 attribute_outputs.rotation_id = params.get_output_anonymous_attribute_id_if_needed(
631 "Rotation"_ustr);
632 attribute_outputs.normal_id = params.get_output_anonymous_attribute_id_if_needed(
633 "Normal"_ustr, bool(attribute_outputs.rotation_id));
634
636
639 const Field<float> density = extract_non_negative_density(params, "Density"_ustr);
640 geometry::foreach_real_geometry(geometry_set, [&](GeometrySet &geometry_set) {
641 if (const Mesh *mesh = geometry_set.get_mesh()) {
642 PointCloud *pointcloud = create_points_random(*mesh,
643 selection,
644 density,
645 seed,
646 attribute_outputs,
647 attribute_filter,
648 use_legacy_normal);
649 geometry_set.replace_pointcloud(pointcloud);
650 }
651 geometry_set.keep_only(
653 });
654 break;
655 }
657 const Field<float> factors = extract_non_negative_density(params, "Density Factor"_ustr);
658 const float minimum_distance = params.extract_input<float>("Distance Min"_ustr);
659 const float density_max = params.extract_input<float>("Density Max"_ustr);
660 geometry::foreach_real_geometry(geometry_set, [&](GeometrySet &geometry_set) {
661 if (const Mesh *mesh = geometry_set.get_mesh()) {
663 selection,
664 factors,
665 minimum_distance,
666 density_max,
667 seed,
668 attribute_outputs,
669 attribute_filter,
670 use_legacy_normal);
671 geometry_set.replace_pointcloud(pointcloud);
672 geometry_set.keep_only(
674 }
675 });
676 break;
677 }
678 }
679
680 params.set_output("Points"_ustr, std::move(geometry_set));
681}
682
683static void node_register()
684{
685 static bke::bNodeType ntype;
686
688 &ntype, "GeometryNodeDistributePointsOnFaces"_ustr, GEO_NODE_DISTRIBUTE_POINTS_ON_FACES);
689 ntype.ui_name = "Distribute Points on Faces";
690 ntype.ui_description = "Generate points spread out on the surface of a mesh";
691 ntype.enum_name_legacy = "DISTRIBUTE_POINTS_ON_FACES";
694 ntype.declare = node_declare;
699}
700NOD_REGISTER_NODE(node_register)
701
702} // namespace blender::nodes::node_geo_distribute_points_on_faces_cc
#define NODE_CLASS_GEOMETRY
Definition BKE_node.hh:492
#define GEO_NODE_DISTRIBUTE_POINTS_ON_FACES
General operations for point clouds.
#define NOD_REGISTER_NODE(REGISTER_FUNC)
#define UI_ITEM_NONE
#define BLI_NOINLINE
#define ELEM(...)
Span< T > as_span() const
Definition BLI_array.hh:254
MutableSpan< T > as_mutable_span()
Definition BLI_array.hh:259
CommonVArrayInfo common_info() const
void foreach_in_radius(const T &position, const value_type radius, Fn &&fn) const
constexpr int64_t size() const
Definition BLI_span.hh:256
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
static VArray from_span(Span< T > values)
int64_t size() const
void remove_and_reorder(const int64_t index)
bool is_empty() const
void resize(const int64_t new_size)
VectorData< T, Allocator > release()
void foreach_attribute(const FunctionRef< void(const AttributeIter &)> fn) const
bool is_builtin(const StringRef name) const
GAttributeReader get() const
bool add(const StringRef name, const AttrDomain domain, const AttrType data_type, const AttributeInit &initializer)
GSpanAttributeWriter lookup_or_add_for_write_only_span(StringRef name, AttrDomain domain, AttrType data_type)
void set_selection(Field< bool > selection)
int add_with_destination(GField field, GVMutableArray dst)
bool depends_on_input() const
Definition FN_field.hh:513
static FieldOperationPtr from(std::shared_ptr< const mf::MultiFunction > fn, Vector< GField > inputs)
Definition field.cc:252
NodeAttributeFilter get_attribute_filter(const UString output_identifier) const
std::optional< std::string > get_output_anonymous_attribute_id_if_needed(const UString output_identifier, const bool force_create=false)
T extract_input(const UString identifier)
void set_output(const UString identifier, T &&value)
void make_available(bNode &node) const
#define bary_coord
void sample_point_attribute(Span< int > corner_verts, Span< int3 > corner_tris, Span< int > tri_indices, Span< float3 > bary_coords, const GVArray &src, const IndexMask &mask, GMutableSpan dst)
void sample_corner_attribute(Span< int3 > corner_tris, Span< int > tri_indices, Span< float3 > bary_coords, const GVArray &src, const IndexMask &mask, GMutableSpan dst)
void sample_face_attribute(Span< int > corner_tri_faces, Span< int > tri_indices, const GVArray &src, const IndexMask &mask, GMutableSpan dst)
PointCloud * pointcloud_new_no_attributes(PointCloudType type, int totpoint)
void node_register_type(bNodeType &ntype)
Definition node.cc:2920
const MultiFunction & lookup(UString id)
void evaluate_constant_field(const GField &field, void *r_value)
void foreach_real_geometry(bke::GeometrySet &geometry, FunctionRef< void(bke::GeometrySet &geometry_set)> fn)
void debug_randomize_point_order(PointCloud *pointcloud)
Definition randomize.cc:258
const ImplicitSharingInfo * info_for_mem_free(T *data)
QuaternionBase< float > Quaternion
MatBase< T, NumCol, NumRow > normalize(const MatBase< T, NumCol, NumRow > &a)
static BLI_NOINLINE void update_elimination_mask_for_close_points(Span< float3 > positions, const float minimum_distance, MutableSpan< bool > elimination_mask)
static void node_layout_ex(ui::Layout &layout, bContext *, PointerRNA *ptr)
static BLI_NOINLINE void interpolate_attribute(const Mesh &mesh, const Span< float3 > bary_coords, const Span< int > tri_indices, const AttrDomain source_domain, const GVArray &source_data, GMutableSpan output_data)
static PointCloud * create_points_poisson_disk(const Mesh &mesh, const Field< bool > &selection_field, const Field< float > &density_factor_field, const float minimum_distance, const float density_max, const int seed, const AttributeOutputs &attribute_outputs, const bke::AttributeFilter &attribute_filter, const bool use_legacy_normal)
static BLI_NOINLINE void compute_attribute_outputs(const Mesh &mesh, PointCloud &points, const Span< float3 > bary_coords, const Span< int > tri_indices, const AttributeOutputs &attribute_outputs, const bool use_legacy_normal)
static void sample_bary_coords(const Mesh &mesh, const int seed, const OffsetIndices< int > points_by_tri, Vector< float3 > &r_positions, Vector< float3 > &r_bary_coords, Vector< int > &r_tri_indices)
static void compute_normal_outputs(const Mesh &mesh, const Span< float3 > bary_coords, const Span< int > tri_indices, MutableSpan< float3 > r_normals)
static BLI_NOINLINE void update_elimination_mask_based_on_density_factors(const Mesh &mesh, const Span< float > density_factors, const Span< float3 > bary_coords, const Span< int > tri_indices, const MutableSpan< bool > elimination_mask)
static OffsetIndices< int > calc_tri_point_offsets(const Mesh &mesh, const Span< float > densities, const int seed, Array< int > &r_count_data)
static Field< float > extract_non_negative_density(GeoNodeExecParams &params, const UString input)
static void node_layout(ui::Layout &layout, bContext *, PointerRNA *ptr)
static BLI_NOINLINE void propagate_attributes(const Mesh &mesh, const bke::AttributeFilter &filter, PointCloud &points, const Span< float3 > bary_coords, const Span< int > tri_indices)
static Array< float > calc_full_density_factors_with_selection(const Mesh &mesh, const Field< float > &density_field, const Field< bool > &selection_field)
static void compute_rotation_output(const Span< float3 > normals, MutableSpan< math::Quaternion > r_rotations)
static PointCloud * create_points_random(const Mesh &mesh, const Field< bool > &selection_field, const Field< float > &density_field, const int seed, const AttributeOutputs &attribute_outputs, const bke::AttributeFilter &attribute_filter, const bool use_legacy_normal)
static BLI_NOINLINE void eliminate_points_based_on_mask(const Span< bool > elimination_mask, Vector< float3 > &positions, Vector< float3 > &bary_coords, Vector< int > &tri_indices)
static void compute_legacy_normal_outputs(const Mesh &mesh, const Span< float3 > bary_coords, const Span< int > tri_indices, MutableSpan< float3 > r_normals)
float hash_float_to_float(float k)
Definition noise.cc:254
OffsetIndices< int > accumulate_counts_to_offsets(MutableSpan< int > counts_to_offsets, int start_offset=0)
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 accumulated_task_sizes(Fn &&fn)
void vec_to_quat(float q[4], const float vec[3], short axis, short upflag)
GeometryNodeDistributePointsOnFacesMode
@ GEO_NODE_POINT_DISTRIBUTE_POINTS_ON_FACES_POISSON
@ GEO_NODE_POINT_DISTRIBUTE_POINTS_ON_FACES_RANDOM
float normal_tri_v3(float n[3], const float v1[3], const float v2[3], const float v3[3])
Definition math_geom.cc:45
VecBase< int32_t, 3 > int3
VecBase< float, 3 > float3
@ PROP_FACTOR
Definition RNA_types.hh:308
@ PROP_DISTANCE
Definition RNA_types.hh:313
void geo_node_type_base(bke::bNodeType *ntype, UString idname, const std::optional< int16_t > legacy_type)
#define hash
Definition noise_c.cc:156
#define min(a, b)
Definition sort.cc:38
void keep_only(Span< GeometryComponent::Type > component_types)
void replace_pointcloud(PointCloud *pointcloud, GeometryOwnershipType ownership=GeometryOwnershipType::Owned)
const Mesh * get_mesh() const
static constexpr int _180
Definition BKE_node.hh:247
Defines a node type.
Definition BKE_node.hh:265
void(*) draw_buttons(ui::Layout &, bContext *C, PointerRNA *ptr)
Definition BKE_node.hh:290
std::string ui_description
Definition BKE_node.hh:271
NodeGeometryExecFunction geometry_node_execute
Definition BKE_node.hh:385
void(*) draw_buttons_ex(ui::Layout &, bContext *C, PointerRNA *ptr)
Definition BKE_node.hh:292
const char * enum_name_legacy
Definition BKE_node.hh:274
NodeDeclareFunction declare
Definition BKE_node.hh:393
void prop(PointerRNA *ptr, PropertyRNA *prop, int index, int value, eUI_Item_Flag flag, std::optional< StringRef > name_opt, int icon, std::optional< StringRef > placeholder=std::nullopt)