43 .
description(
"Mesh on whose faces to distribute points on");
47 .evaluated_geometry_field();
48 auto &distance_min =
b.add_input<
decl::Float>(
"Distance Min"_ustr)
51 .make_available(enable_poisson)
53 auto &density_max =
b.add_input<
decl::Float>(
"Density Max"_ustr)
61 .evaluated_geometry_field()
64 auto &density_factor =
b.add_input<
decl::Float>(
"Density Factor"_ustr)
69 .evaluated_geometry_field()
70 .make_available(enable_poisson)
75 b.add_output<
decl::Vector>(
"Normal"_ustr).anonymous_attribute_output();
76 b.add_output<
decl::Rotation>(
"Rotation"_ustr).anonymous_attribute_output();
79 if (
node !=
nullptr) {
80 switch (
node->custom1) {
82 distance_min.available(
true);
83 density_max.available(
true);
84 density_factor.available(
true);
87 density.available(
true);
100 layout.
prop(ptr,
"use_legacy_normal",
UI_ITEM_NONE, std::nullopt, ICON_NONE);
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);
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);
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]]];
189 const int corner_tri_seed = noise::hash(tri_i, seed);
190 RandomNumberGenerator corner_tri_rng(corner_tri_seed);
193 corner_tri_rng.skip(1);
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;
204 [&](
const IndexRange range) {
return points_by_tri[range].size(); }));
210 if (minimum_distance <= 0.0f) {
217 if (elimination_mask[i]) {
222 positions[i], minimum_distance, [&](
const int index,
const float ) {
224 elimination_mask[
index] =
true;
239 if (elimination_mask[i]) {
243 const int3 &tri = corner_tris[tri_indices[i]];
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]];
254 if (
hash > probability) {
255 elimination_mask[i] =
true;
265 for (
int i = positions.
size() - 1; i >= 0; i--) {
266 if (elimination_mask[i]) {
281 switch (source_domain) {
282 case AttrDomain::Point: {
292 case AttrDomain::Corner: {
301 case AttrDomain::Face: {
326 if (iter.
domain == AttrDomain::Edge) {
333 if (
ELEM(name,
"position",
".select_vert")) {
336 if (
filter.allow_skip(name)) {
339 const StringRef dst_name = name ==
".select_poly" ?
".selection" : name;
347 if (point_attributes.
add(dst_name, AttrDomain::Point, iter.
data_type,
init)) {
352 dst_name, AttrDomain::Point, iter.
data_type);
362struct AttributeOutputs {
363 std::optional<std::string> normal_id;
364 std::optional<std::string> rotation_id;
373 switch (
mesh.normals_domain()) {
379 bke::mesh_surface_sample::sample_point_normals(
380 corner_verts, corner_tris, tri_indices, bary_coords, vert_normals, range, r_normals);
388 bke::mesh_surface_sample::sample_face_attribute(
389 tri_faces, tri_indices, face_normals, range, r_normals);
397 bke::mesh_surface_sample::sample_corner_normals(
398 corner_tris, tri_indices, bary_coords, corner_normals, range, r_normals);
415 const int tri_i = tri_indices[i];
416 const int3 &tri = corner_tris[tri_i];
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];
427 r_normals[i] = normal;
435 for (const int i : range) {
436 r_rotations[i] = normal_to_rotation(normals[i]);
445 const AttributeOutputs &attribute_outputs,
446 const bool use_legacy_normal)
451 "id", AttrDomain::Point);
456 if (attribute_outputs.normal_id) {
458 *attribute_outputs.normal_id, AttrDomain::Point);
460 if (attribute_outputs.rotation_id) {
462 *attribute_outputs.rotation_id, AttrDomain::Point);
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);
474 if (use_legacy_normal) {
475 compute_legacy_normal_outputs(
mesh, bary_coords, tri_indices, normals.span);
478 compute_normal_outputs(
mesh, bary_coords, tri_indices, normals.span);
482 compute_rotation_output(normals.span, rotations.span);
496 const int domain_size =
mesh.attributes().domain_size(domain);
511 const AttributeOutputs &attribute_outputs,
513 const bool use_legacy_normal)
519 mesh, density_field, selection_field);
543 attr_data->remove_user_and_delete_if_last();
549 mesh, *pointcloud, bary_coords, tri_indices, attribute_outputs, use_legacy_normal);
559 const float minimum_distance,
560 const float density_max,
562 const AttributeOutputs &attribute_outputs,
564 const bool use_legacy_normal)
566 if (density_max <= 0.0f) {
571 mesh, density_max, seed, count_data);
585 mesh, density_factor_field, selection_field);
599 pointcloud->positions_for_write().copy_from(positions);
605 mesh, *pointcloud, bary_coords, tri_indices, attribute_outputs, use_legacy_normal);
615 "max(float, float)"_ustr);
625 const int seed = params.
extract_input<
int>(
"Seed"_ustr) * 5383843;
627 const bool use_legacy_normal = params.
node().
custom2 != 0;
629 AttributeOutputs attribute_outputs;
633 "Normal"_ustr,
bool(attribute_outputs.rotation_id));
658 const float minimum_distance = params.
extract_input<
float>(
"Distance Min"_ustr);
659 const float density_max = params.
extract_input<
float>(
"Density Max"_ustr);
680 params.
set_output(
"Points"_ustr, std::move(geometry_set));
689 ntype.
ui_name =
"Distribute Points on Faces";
690 ntype.
ui_description =
"Generate points spread out on the surface of a mesh";
#define NODE_CLASS_GEOMETRY
#define GEO_NODE_DISTRIBUTE_POINTS_ON_FACES
General operations for point clouds.
#define NOD_REGISTER_NODE(REGISTER_FUNC)
Span< T > as_span() const
MutableSpan< T > as_mutable_span()
CommonVArrayInfo common_info() const
const CPPType & type() const
void foreach_in_radius(const T &position, const value_type radius, Fn &&fn) const
constexpr int64_t size() const
constexpr IndexRange index_range() const
static VArray from_span(Span< T > values)
void remove_and_reorder(const int64_t index)
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
static FieldOperationPtr from(std::shared_ptr< const mf::MultiFunction > fn, Vector< GField > inputs)
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)
const bNode & node() const
void set_output(const UString identifier, T &&value)
void make_available(bNode &node) const
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)
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)
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 void node_register()
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 math::Quaternion normal_to_rotation(const float3 normal)
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 void node_geo_exec(GeoNodeExecParams params)
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 void node_declare(NodeDeclarationBuilder &b)
static Field< float > extract_non_negative_density(GeoNodeExecParams ¶ms, 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)
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))
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])
VecBase< int32_t, 3 > int3
VecBase< float, 3 > float3
void geo_node_type_base(bke::bNodeType *ntype, UString idname, const std::optional< int16_t > legacy_type)
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
void(*) draw_buttons(ui::Layout &, bContext *C, PointerRNA *ptr)
std::string ui_description
NodeGeometryExecFunction geometry_node_execute
void(*) draw_buttons_ex(ui::Layout &, bContext *C, PointerRNA *ptr)
const char * enum_name_legacy
NodeDeclareFunction declare
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)