Blender V5.3
node_geo_curve_to_points.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_math_matrix.hh"
6
8
9#include "BKE_customdata.hh"
10#include "BKE_grease_pencil.hh"
11#include "BKE_instances.hh"
12#include "BKE_pointcloud.hh"
13
17
18#include "NOD_rna_define.hh"
19
21#include "UI_resources.hh"
22
23#include "node_geometry_util.hh"
24
26
28
30{
31 b.add_input<decl::Geometry>("Curve"_ustr)
33 .description("Curves to convert to points");
34 auto &count = b.add_input<decl::Int>("Count"_ustr)
35 .default_value(10)
36 .min(2)
37 .max(100000)
38 .evaluated_geometry_field()
39 .make_available([](bNode &node) {
40 node_storage(node).mode = GEO_NODE_CURVE_RESAMPLE_COUNT;
41 });
42 auto &length = b.add_input<decl::Float>("Length"_ustr)
43 .default_value(0.1f)
44 .min(0.001f)
45 .subtype(PROP_DISTANCE)
46 .evaluated_geometry_field()
47 .make_available([](bNode &node) {
48 node_storage(node).mode = GEO_NODE_CURVE_RESAMPLE_LENGTH;
49 });
50 b.add_output<decl::Geometry>("Points"_ustr).propagate_all_geometry();
51 b.add_output<decl::Vector>("Tangent"_ustr).anonymous_attribute_output();
52 b.add_output<decl::Vector>("Normal"_ustr).anonymous_attribute_output();
53 b.add_output<decl::Rotation>("Rotation"_ustr).anonymous_attribute_output();
54
55 const bNode *node = b.node_or_null();
56 if (node != nullptr) {
57 const NodeGeometryCurveToPoints &storage = node_storage(*node);
59
60 count.available(mode == GEO_NODE_CURVE_RESAMPLE_COUNT);
61 length.available(mode == GEO_NODE_CURVE_RESAMPLE_LENGTH);
62 }
63}
64
65static void node_layout(ui::Layout &layout, bContext * /*C*/, PointerRNA *ptr)
66{
67 layout.prop(ptr, "mode", UI_ITEM_NONE, "", ICON_NONE);
68}
69
70static void node_init(bNodeTree * /*tree*/, bNode *node)
71{
72 NodeGeometryCurveToPoints *data = MEM_new<NodeGeometryCurveToPoints>(__func__);
73
75 node->storage = data;
76}
77
78static void fill_rotation_attribute(const Span<float3> tangents,
79 const Span<float3> normals,
81{
82 threading::parallel_for(IndexRange(rotations.size()), 512, [&](IndexRange range) {
83 for (const int i : range) {
84 const float3 tangent = tangents[i];
85 BLI_assert(math::is_unit(tangent));
86 const float3 binormal = math::normalize(math::cross(tangent, normals[i]));
87 const float3 normal = math::cross(binormal, tangent);
88 rotations[i] = math::to_quaternion(float3x3{normal, binormal, tangent});
89 }
90 });
91}
92
93static void copy_curve_domain_attributes(const AttributeAccessor curve_attributes,
94 const AttributeFilter &attribute_filter,
95 MutableAttributeAccessor point_attributes)
96{
97 curve_attributes.foreach_attribute([&](const bke::AttributeIter &iter) {
98 if (iter.is_builtin) {
99 return;
100 }
101 if (iter.domain != AttrDomain::Curve) {
102 return;
103 }
104 if (attribute_filter.allow_skip(iter.name)) {
105 return;
106 }
107 if (iter.data_type == bke::AttrType::String) {
108 return;
109 }
110 point_attributes.add(iter.name,
111 AttrDomain::Point,
112 iter.data_type,
113 bke::AttributeInitVArray(*iter.get(AttrDomain::Point)));
114 });
115}
116
119 const AttributeFilter &attribute_filter,
120 const geometry::ResampleCurvesOutputAttributeIDs &resample_attributes,
121 const std::optional<StringRef> &rotation_id)
122{
123 const AttributeAccessor curve_attributes = curves.attributes();
124
126 curves.points_num());
127 MutableAttributeAccessor point_attributes = pointcloud->attributes_for_write();
128
129 const bke::AttributeFilterFromFunc filter = [&](const StringRef name) {
130 if (ELEM(name, resample_attributes.tangent_id, resample_attributes.normal_id, rotation_id)) {
132 }
133 if (attribute_filter.allow_skip(name)) {
135 }
136 if (curve_attributes.is_builtin(name) && !point_attributes.is_builtin(name)) {
138 }
140 };
141
142 bke::copy_attributes(curves.attributes(),
145 filter,
146 pointcloud->attributes_for_write());
147
148 copy_curve_domain_attributes(curve_attributes, filter, point_attributes);
149
150 if (rotation_id) {
151 const VArraySpan tangents = *curve_attributes.lookup<float3>(*resample_attributes.tangent_id,
152 AttrDomain::Point);
153 const VArraySpan normals = *curve_attributes.lookup<float3>(*resample_attributes.normal_id,
154 AttrDomain::Point);
155 SpanAttributeWriter rotations =
156 point_attributes.lookup_or_add_for_write_only_span<math::Quaternion>(*rotation_id,
157 AttrDomain::Point);
158 fill_rotation_attribute(tangents, normals, rotations.span);
159 rotations.finish();
160 }
161
162 return pointcloud;
163}
164
165static void layer_pointclouds_to_instances(const Span<PointCloud *> pointcloud_by_layer,
166 const AttributeFilter &attribute_filter,
168{
169 if (!pointcloud_by_layer.is_empty()) {
170 auto instances = std::make_unique<bke::Instances>(pointcloud_by_layer.size());
171 MutableSpan<int> handles = instances->reference_handles_for_write();
172 instances->transforms_for_write().fill(float4x4::identity());
173 for (const int i : pointcloud_by_layer.index_range()) {
174 PointCloud *pointcloud = pointcloud_by_layer[i];
175 if (!pointcloud) {
176 /* Add an empty reference so the number of layers and instances match.
177 * This makes it easy to reconstruct the layers afterwards and keep their
178 * attributes. */
179 handles[i] = instances->add_reference(bke::InstanceReference());
180 continue;
181 }
182 GeometrySet temp_set = GeometrySet::from_pointcloud(pointcloud);
183 handles[i] = instances->add_reference(bke::InstanceReference{std::move(temp_set)});
184 }
185
186 bke::copy_attributes(geometry.get_grease_pencil()->attributes(),
189 attribute_filter,
190 instances->attributes_for_write());
191 InstancesComponent &dst_component = geometry.get_component_for_write<InstancesComponent>();
193 {GeometrySet::from_instances(dst_component.release()),
194 GeometrySet::from_instances(std::move(instances))},
195 attribute_filter);
196 dst_component.replace(new_instances.get_component_for_write<InstancesComponent>().release());
197 }
198}
199
201{
202 const NodeGeometryCurveToPoints &storage = node_storage(params.node());
204 GeometrySet geometry_set = params.extract_input<GeometrySet>("Curve"_ustr);
205
207
208 std::optional<std::string> rotation_anonymous_id =
209 params.get_output_anonymous_attribute_id_if_needed("Rotation"_ustr);
210 const bool need_tangent_and_normal = bool(rotation_anonymous_id);
211 std::optional<std::string> tangent_anonymous_id =
212 params.get_output_anonymous_attribute_id_if_needed("Tangent"_ustr, need_tangent_and_normal);
213 std::optional<std::string> normal_anonymous_id =
214 params.get_output_anonymous_attribute_id_if_needed("Normal"_ustr, need_tangent_and_normal);
215
217 resample_attributes.tangent_id = tangent_anonymous_id;
218 resample_attributes.normal_id = normal_anonymous_id;
219 const NodeAttributeFilter &attribute_filter = params.get_attribute_filter("Points"_ustr);
220
221 switch (mode) {
223 const Field<int> count = params.extract_input<Field<int>>("Count"_ustr);
225 if (const Curves *src_curves_id = geometry.get_curves()) {
227 src_curves_id->geometry.wrap(),
228 bke::CurvesFieldContext(*src_curves_id, AttrDomain::Curve),
229 fn::Field<bool>(true),
230 count,
231 resample_attributes);
232 PointCloud *pointcloud = curves_to_points(
233 dst_curves, attribute_filter, resample_attributes, rotation_anonymous_id);
234 geometry.replace_pointcloud(pointcloud);
235 }
236 if (const GreasePencil *grease_pencil = geometry.get_grease_pencil()) {
237 Array<PointCloud *> pointcloud_by_layer(grease_pencil->layers().size(), nullptr);
238 for (const int layer_index : grease_pencil->layers().index_range()) {
239 const bke::greasepencil::Drawing *drawing = grease_pencil->get_eval_drawing(
240 grease_pencil->layer(layer_index));
241 if (drawing == nullptr) {
242 continue;
243 }
245 drawing->strokes(),
246 bke::GreasePencilLayerFieldContext(*grease_pencil, AttrDomain::Curve, layer_index),
247 fn::Field<bool>(true),
248 count,
249 resample_attributes);
250 pointcloud_by_layer[layer_index] = curves_to_points(
251 dst_curves, attribute_filter, resample_attributes, rotation_anonymous_id);
252 }
253 layer_pointclouds_to_instances(pointcloud_by_layer, attribute_filter, geometry);
254 }
258 });
259 break;
260 }
262 const Field<float> length = params.extract_input<Field<float>>("Length"_ustr);
264 if (const Curves *src_curves_id = geometry.get_curves()) {
266 src_curves_id->geometry.wrap(),
267 bke::CurvesFieldContext(*src_curves_id, AttrDomain::Curve),
268 fn::Field<bool>(true),
269 length,
270 resample_attributes);
271 PointCloud *pointcloud = curves_to_points(
272 dst_curves, attribute_filter, resample_attributes, rotation_anonymous_id);
273 geometry.replace_pointcloud(pointcloud);
274 }
275 if (const GreasePencil *grease_pencil = geometry.get_grease_pencil()) {
276 Array<PointCloud *> pointcloud_by_layer(grease_pencil->layers().size(), nullptr);
277 for (const int layer_index : grease_pencil->layers().index_range()) {
278 const bke::greasepencil::Drawing *drawing = grease_pencil->get_eval_drawing(
279 grease_pencil->layer(layer_index));
280 if (drawing == nullptr) {
281 continue;
282 }
284 drawing->strokes(),
285 bke::GreasePencilLayerFieldContext(*grease_pencil, AttrDomain::Curve, layer_index),
286 fn::Field<bool>(true),
287 length,
288 resample_attributes);
289 pointcloud_by_layer[layer_index] = curves_to_points(
290 dst_curves, attribute_filter, resample_attributes, rotation_anonymous_id);
291 }
292 layer_pointclouds_to_instances(pointcloud_by_layer, attribute_filter, geometry);
293 }
297 });
298 break;
299 }
302 if (const Curves *src_curves_id = geometry.get_curves()) {
304 src_curves_id->geometry.wrap(),
305 bke::CurvesFieldContext(*src_curves_id, AttrDomain::Curve),
306 fn::Field<bool>(true),
307 resample_attributes);
308 PointCloud *pointcloud = curves_to_points(
309 dst_curves, attribute_filter, resample_attributes, rotation_anonymous_id);
310 geometry.replace_pointcloud(pointcloud);
311 geometry.replace_curves(nullptr);
312 }
313 if (const GreasePencil *grease_pencil = geometry.get_grease_pencil()) {
314 Array<PointCloud *> pointcloud_by_layer(grease_pencil->layers().size(), nullptr);
315 for (const int layer_index : grease_pencil->layers().index_range()) {
316 const bke::greasepencil::Drawing *drawing = grease_pencil->get_eval_drawing(
317 grease_pencil->layer(layer_index));
318 if (drawing == nullptr) {
319 continue;
320 }
322 drawing->strokes(),
323 bke::GreasePencilLayerFieldContext(*grease_pencil, AttrDomain::Curve, layer_index),
324 fn::Field<bool>(true),
325 resample_attributes);
326 pointcloud_by_layer[layer_index] = curves_to_points(
327 dst_curves, attribute_filter, resample_attributes, rotation_anonymous_id);
328 }
329 layer_pointclouds_to_instances(pointcloud_by_layer, attribute_filter, geometry);
330 }
334 });
335 break;
336 }
337 }
338
339 params.set_output("Points"_ustr, std::move(geometry_set));
340}
341
342static void node_rna(StructRNA *srna)
343{
344 static EnumPropertyItem mode_items[] = {
346 "EVALUATED",
347 0,
348 "Evaluated",
349 "Create points from the curve's evaluated points, based on the resolution attribute for "
350 "NURBS and Bézier splines"},
352 "COUNT",
353 0,
354 "Count",
355 "Sample each spline by evenly distributing the specified number of points"},
357 "LENGTH",
358 0,
359 "Length",
360 "Sample each spline by splitting it into segments with the specified length"},
361 {0, nullptr, 0, nullptr, nullptr},
362 };
363
365 "mode",
366 "Mode",
367 "How to generate points from the input curve",
368 mode_items,
371}
372
373static void node_register()
374{
375 static bke::bNodeType ntype;
376
377 geo_node_type_base(&ntype, "GeometryNodeCurveToPoints"_ustr, GEO_NODE_CURVE_TO_POINTS);
378 ntype.ui_name = "Curve to Points";
379 ntype.ui_description = "Generate a point cloud by sampling positions along curves";
380 ntype.enum_name_legacy = "CURVE_TO_POINTS";
382 ntype.declare = node_declare;
386 ntype, "NodeGeometryCurveToPoints", node_free_standard_storage, node_copy_standard_storage);
387 ntype.initfunc = node_init;
389
390 node_rna(ntype.rna_ext.srna);
391}
392NOD_REGISTER_NODE(node_register)
393
394} // namespace blender::nodes::node_geo_curve_to_points_cc
CustomData interface, see also DNA_customdata_types.h.
Low-level operations for grease pencil.
#define NODE_STORAGE_FUNCS(StorageT)
Definition BKE_node.hh:1353
#define NODE_CLASS_GEOMETRY
Definition BKE_node.hh:492
#define GEO_NODE_CURVE_TO_POINTS
General operations for point clouds.
#define NOD_REGISTER_NODE(REGISTER_FUNC)
#define NOD_storage_enum_accessors(member)
#define UI_ITEM_NONE
#define ELEM(...)
btScalar max
constexpr IndexRange()=default
constexpr int64_t size() const
Definition BLI_span.hh:499
constexpr void fill(const T &value) const
Definition BLI_span.hh:523
constexpr int64_t size() const
Definition BLI_span.hh:256
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
constexpr bool is_empty() const
Definition BLI_span.hh:264
void foreach_attribute(const FunctionRef< void(const AttributeIter &)> fn) const
GAttributeReader lookup(const StringRef name) const
bool is_builtin(const StringRef name) const
GAttributeReader get() const
void replace(Instances *instances, GeometryOwnershipType ownership=GeometryOwnershipType::Owned)
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)
const bke::CurvesGeometry & strokes() const
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)
static void remember_deformed_positions_if_necessary(GeometrySet &geometry)
#define storage(slot, qualifiers)
float length(VecOp< float, D >) RET
PointCloud * pointcloud_new_no_attributes(PointCloudType type, int totpoint)
void node_register_type(bNodeType &ntype)
Definition node.cc:2920
void copy_attributes(const AttributeAccessor src_attributes, AttrDomain src_domain, AttrDomain dst_domain, const AttributeFilter &attribute_filter, MutableAttributeAccessor dst_attributes)
void node_type_storage(bNodeType &ntype, std::optional< StringRefNull > storagename, void(*freefunc)(bNode *node), void(*copyfunc)(bNodeTree *dest_ntree, bNode *dest_node, const bNode *src_node))
Definition node.cc:6166
bke::GeometrySet join_geometries(Span< bke::GeometrySet > geometries, const bke::AttributeFilter &attribute_filter, const std::optional< Span< bke::GeometryComponent::Type > > &component_types_to_join=std::nullopt, bool allow_merging_instance_references=true)
void foreach_real_geometry(bke::GeometrySet &geometry, FunctionRef< void(bke::GeometrySet &geometry_set)> fn)
CurvesGeometry resample_to_count(const CurvesGeometry &src_curves, const IndexMask &selection, const VArray< int > &counts, const ResampleCurvesOutputAttributeIDs &output_ids={})
CurvesGeometry resample_to_evaluated(const CurvesGeometry &src_curves, const IndexMask &selection, const ResampleCurvesOutputAttributeIDs &output_ids={})
CurvesGeometry resample_to_length(const CurvesGeometry &src_curves, const IndexMask &selection, const VArray< float > &sample_lengths, const ResampleCurvesOutputAttributeIDs &output_ids={}, bool keep_last_segment=false)
QuaternionBase< float > Quaternion
static PointCloud * curves_to_points(const bke::CurvesGeometry &curves, const AttributeFilter &attribute_filter, const geometry::ResampleCurvesOutputAttributeIDs &resample_attributes, const std::optional< StringRef > &rotation_id)
static void node_geo_exec(GeoNodeExecParams params)
static void node_declare(NodeDeclarationBuilder &b)
static void copy_curve_domain_attributes(const AttributeAccessor curve_attributes, const AttributeFilter &attribute_filter, MutableAttributeAccessor point_attributes)
static void node_layout(ui::Layout &layout, bContext *, PointerRNA *ptr)
static void node_init(bNodeTree *, bNode *node)
static void fill_rotation_attribute(const Span< float3 > tangents, const Span< float3 > normals, MutableSpan< math::Quaternion > rotations)
static void layer_pointclouds_to_instances(const Span< PointCloud * > pointcloud_by_layer, const AttributeFilter &attribute_filter, GeometrySet &geometry)
PropertyRNA * RNA_def_node_enum(StructRNA *srna, const char *identifier, const char *ui_name, const char *ui_description, const EnumPropertyItem *static_items, const EnumRNAAccessors accessors, std::optional< int > default_value, const EnumPropertyItemFunc item_func, const bool allow_animation)
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
BMesh const char void * data
void node_copy_standard_storage(bNodeTree *, bNode *dest_node, const bNode *src_node)
Definition node_util.cc:57
void node_free_standard_storage(bNode *node)
Definition node_util.cc:45
VecBase< float, 3 > float3
@ PROP_DISTANCE
Definition RNA_types.hh:313
GeometryNodeCurveResampleMode
@ GEO_NODE_CURVE_RESAMPLE_LENGTH
@ GEO_NODE_CURVE_RESAMPLE_COUNT
@ GEO_NODE_CURVE_RESAMPLE_EVALUATED
void geo_node_type_base(bke::bNodeType *ntype, UString idname, const std::optional< int16_t > legacy_type)
#define min(a, b)
Definition sort.cc:38
bool allow_skip(const StringRef name) const
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(*) initfunc(bNodeTree *ntree, bNode *node)
Definition BKE_node.hh:320
const char * enum_name_legacy
Definition BKE_node.hh:274
NodeDeclareFunction declare
Definition BKE_node.hh:393
static GeometrySet from_instances(std::unique_ptr< Instances > instances)
static GeometrySet from_pointcloud(PointCloud *pointcloud, GeometryOwnershipType ownership=GeometryOwnershipType::Owned)
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)