Blender V5.3
node_geo_curve_trim.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 "BKE_curves.hh"
7
9#include "UI_resources.hh"
10
12
14#include "GEO_trim_curves.hh"
15
16#include "NOD_rna_define.hh"
17
18#include "node_geometry_util.hh"
19
21
23
25{
26 b.use_custom_socket_order();
27 b.allow_any_socket_order();
28 b.add_default_layout();
29 b.add_input<decl::Geometry>("Curve"_ustr)
31 .description("Curves to shorten");
32 b.add_output<decl::Geometry>("Curve"_ustr).propagate_all_geometry().align_with_previous();
33 b.add_input<decl::Bool>("Selection"_ustr)
34 .default_value(true)
35 .hide_value()
36 .evaluated_geometry_field();
37 auto &start_fac = b.add_input<decl::Float>("Start"_ustr)
38 .min(0.0f)
39 .max(1.0f)
40 .subtype(PROP_FACTOR)
41 .make_available([](bNode &node) {
42 node_storage(node).mode = GEO_NODE_CURVE_SAMPLE_FACTOR;
43 })
44 .evaluated_geometry_field();
45 auto &end_fac = b.add_input<decl::Float>("End"_ustr)
46 .min(0.0f)
47 .max(1.0f)
48 .default_value(1.0f)
49 .subtype(PROP_FACTOR)
50 .make_available([](bNode &node) {
51 node_storage(node).mode = GEO_NODE_CURVE_SAMPLE_FACTOR;
52 })
53 .evaluated_geometry_field();
54 auto &start_len = b.add_input<decl::Float>("Start"_ustr, "Start_001"_ustr)
55 .min(0.0f)
56 .subtype(PROP_DISTANCE)
57 .make_available([](bNode &node) {
58 node_storage(node).mode = GEO_NODE_CURVE_SAMPLE_LENGTH;
59 })
60 .evaluated_geometry_field();
61 auto &end_len = b.add_input<decl::Float>("End"_ustr, "End_001"_ustr)
62 .min(0.0f)
63 .default_value(1.0f)
64 .subtype(PROP_DISTANCE)
65 .make_available([](bNode &node) {
66 node_storage(node).mode = GEO_NODE_CURVE_SAMPLE_LENGTH;
67 })
68 .evaluated_geometry_field();
69
70 const bNode *node = b.node_or_null();
71 if (node != nullptr) {
72 const NodeGeometryCurveTrim &storage = node_storage(*node);
74
75 start_fac.available(mode == GEO_NODE_CURVE_SAMPLE_FACTOR);
76 end_fac.available(mode == GEO_NODE_CURVE_SAMPLE_FACTOR);
77 start_len.available(mode == GEO_NODE_CURVE_SAMPLE_LENGTH);
78 end_len.available(mode == GEO_NODE_CURVE_SAMPLE_LENGTH);
79 }
80}
81
82static void node_layout(ui::Layout &layout, bContext * /*C*/, PointerRNA *ptr)
83{
84 layout.prop(ptr, "mode", ui::ITEM_R_EXPAND, std::nullopt, ICON_NONE);
85}
86
87static void node_init(bNodeTree * /*tree*/, bNode *node)
88{
89 NodeGeometryCurveTrim *data = MEM_new<NodeGeometryCurveTrim>(__func__);
90
92 node->storage = data;
93}
94
96 public:
100 {
101 bNode &node = params.add_node("GeometryNodeTrimCurve"_ustr);
102 node_storage(node).mode = mode;
104 }
105};
106
108{
109 const NodeDeclaration &declaration = *params.node_type().static_declaration;
110
111 search_link_ops_for_declarations(params, declaration.outputs);
112 search_link_ops_for_declarations(params, declaration.inputs.as_span().take_front(1));
113
114 if (params.in_out() == SOCK_IN) {
115 if (params.node_tree().typeinfo->validate_link(params.other_socket().type, SOCK_FLOAT)) {
116 params.add_item(IFACE_("Start (Factor)"),
118 params.add_item(IFACE_("End (Factor)"),
120 params.add_item(IFACE_("Start (Length)"),
122 params.add_item(IFACE_("End (Length)"),
124 }
125 }
126}
127
128static bool trim_curves(const bke::CurvesGeometry &src_curves,
130 const fn::FieldContext &field_context,
131 Field<bool> &selection_field,
132 Field<float> &start_field,
133 Field<float> &end_field,
134 const AttributeFilter &attribute_filter,
135 bke::CurvesGeometry &dst_curves)
136{
137 if (src_curves.is_empty()) {
138 return false;
139 }
140 fn::FieldEvaluator evaluator{field_context, src_curves.curves_num()};
141 evaluator.add(selection_field);
142 evaluator.add(start_field);
143 evaluator.add(end_field);
144 evaluator.evaluate();
145
146 const IndexMask selection = evaluator.get_evaluated_as_mask(0);
147 const VArray<float> starts = evaluator.get_evaluated<float>(1);
148 const VArray<float> ends = evaluator.get_evaluated<float>(2);
149
150 if (selection.is_empty()) {
151 return false;
152 }
153
154 dst_curves = geometry::trim_curves(src_curves, selection, starts, ends, mode, attribute_filter);
155 return true;
156}
157
158static void geometry_set_curve_trim(GeometrySet &geometry_set,
160 Field<bool> &selection_field,
161 Field<float> &start_field,
162 Field<float> &end_field,
163 const AttributeFilter &attribute_filter)
164{
165 if (geometry_set.has_curves()) {
166 const Curves &src_curves_id = *geometry_set.get_curves();
167 const bke::CurvesGeometry &src_curves = src_curves_id.geometry.wrap();
168 const bke::CurvesFieldContext field_context{src_curves_id, AttrDomain::Curve};
169 bke::CurvesGeometry dst_curves;
170 if (trim_curves(src_curves,
171 mode,
172 field_context,
173 selection_field,
174 start_field,
175 end_field,
176 attribute_filter,
177 dst_curves))
178 {
179 Curves *dst_curves_id = bke::curves_new_nomain(std::move(dst_curves));
180 bke::curves_copy_parameters(src_curves_id, *dst_curves_id);
181 geometry_set.replace_curves(dst_curves_id);
182 }
183 }
184 if (geometry_set.has_grease_pencil()) {
185 using namespace bke::greasepencil;
187 for (const int layer_index : grease_pencil.layers().index_range()) {
188 Drawing *drawing = grease_pencil.get_eval_drawing(grease_pencil.layer(layer_index));
189 if (drawing == nullptr) {
190 continue;
191 }
192 const bke::CurvesGeometry &src_curves = drawing->strokes();
193 const bke::GreasePencilLayerFieldContext field_context{
194 grease_pencil, AttrDomain::Curve, layer_index};
195 bke::CurvesGeometry dst_curves;
196 if (trim_curves(src_curves,
197 mode,
198 field_context,
199 selection_field,
200 start_field,
201 end_field,
202 attribute_filter,
203 dst_curves))
204 {
205 drawing->strokes_for_write() = std::move(dst_curves);
206 drawing->tag_topology_changed();
207 }
208 }
209 }
210}
211
213{
214 const NodeGeometryCurveTrim &storage = node_storage(params.node());
216
217 GeometrySet geometry_set = params.extract_input<GeometrySet>("Curve"_ustr);
219
220 const NodeAttributeFilter &attribute_filter = params.get_attribute_filter("Curve"_ustr);
221
222 Field<bool> selection_field = params.extract_input<Field<bool>>("Selection"_ustr);
223 if (mode == GEO_NODE_CURVE_SAMPLE_FACTOR) {
224 Field<float> start_field = params.extract_input<Field<float>>("Start"_ustr);
225 Field<float> end_field = params.extract_input<Field<float>>("End"_ustr);
226 geometry::foreach_real_geometry(geometry_set, [&](GeometrySet &geometry_set) {
228 geometry_set, mode, selection_field, start_field, end_field, attribute_filter);
229 });
230 }
231 else if (mode == GEO_NODE_CURVE_SAMPLE_LENGTH) {
232 Field<float> start_field = params.extract_input<Field<float>>("Start_001"_ustr);
233 Field<float> end_field = params.extract_input<Field<float>>("End_001"_ustr);
234 geometry::foreach_real_geometry(geometry_set, [&](GeometrySet &geometry_set) {
236 geometry_set, mode, selection_field, start_field, end_field, attribute_filter);
237 });
238 }
239
240 params.set_output("Curve"_ustr, std::move(geometry_set));
241}
242
243static void node_rna(StructRNA *srna)
244{
245 static EnumPropertyItem mode_items[] = {
247 "FACTOR",
248 0,
249 "Factor",
250 "Find the endpoint positions using a factor of each spline's length"},
252 "LENGTH",
253 0,
254 "Length",
255 "Find the endpoint positions using a length from the start of each spline"},
256 {0, nullptr, 0, nullptr, nullptr},
257 };
258
260 "mode",
261 "Mode",
262 "How to find endpoint positions for the trimmed spline",
263 mode_items,
265}
266
267static void node_register()
268{
269 static bke::bNodeType ntype;
270 geo_node_type_base(&ntype, "GeometryNodeTrimCurve"_ustr, GEO_NODE_TRIM_CURVE);
271 ntype.ui_name = "Trim Curve";
272 ntype.ui_description = "Shorten curves by removing portions at the start or end";
273 ntype.enum_name_legacy = "TRIM_CURVE";
277 ntype.declare = node_declare;
279 ntype, "NodeGeometryCurveTrim", node_free_standard_storage, node_copy_standard_storage);
280 ntype.initfunc = node_init;
283
284 node_rna(ntype.rna_ext.srna);
285}
287
288} // namespace blender::nodes::node_geo_curve_trim_cc
Low-level operations for curves.
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_TRIM_CURVE
#define IFACE_(msgid)
#define NOD_REGISTER_NODE(REGISTER_FUNC)
#define NOD_storage_enum_accessors(member)
btScalar max
bke::CurvesGeometry & strokes_for_write()
const bke::CurvesGeometry & strokes() const
int add(GField field, GVArray *varray_ptr)
IndexMask get_evaluated_as_mask(int field_index)
const GVArray & get_evaluated(const int field_index) const
const bke::bNodeType & node_type() const
void add_item(std::string socket_name, SocketLinkOperation::LinkSocketFn fn, int weight=0)
NodeAttributeFilter get_attribute_filter(const UString output_identifier) const
T extract_input(const UString identifier)
void set_output(const UString identifier, T &&value)
static void remember_deformed_positions_if_necessary(GeometrySet &geometry)
void update_and_connect_available_socket(bNode &new_node, UString socket_name)
Vector< SocketDeclaration * > inputs
Vector< SocketDeclaration * > outputs
#define storage(slot, qualifiers)
void curves_copy_parameters(const Curves &src, Curves &dst)
void node_register_type(bNodeType &ntype)
Definition node.cc:2920
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
Curves * curves_new_nomain(int points_num, int curves_num)
bke::CurvesGeometry trim_curves(const bke::CurvesGeometry &src_curves, const IndexMask &selection, const VArray< float > &starts, const VArray< float > &ends, GeometryNodeCurveSampleMode mode, const bke::AttributeFilter &attribute_filter)
void foreach_real_geometry(bke::GeometrySet &geometry, FunctionRef< void(bke::GeometrySet &geometry_set)> fn)
static void node_init(bNodeTree *, bNode *node)
static bool trim_curves(const bke::CurvesGeometry &src_curves, const GeometryNodeCurveSampleMode mode, const fn::FieldContext &field_context, Field< bool > &selection_field, Field< float > &start_field, Field< float > &end_field, const AttributeFilter &attribute_filter, bke::CurvesGeometry &dst_curves)
static void node_declare(NodeDeclarationBuilder &b)
static void node_gather_link_searches(GatherLinkSearchOpParams &params)
static void geometry_set_curve_trim(GeometrySet &geometry_set, const GeometryNodeCurveSampleMode mode, Field< bool > &selection_field, Field< float > &start_field, Field< float > &end_field, const AttributeFilter &attribute_filter)
static void node_layout(ui::Layout &layout, bContext *, PointerRNA *ptr)
static void node_geo_exec(GeoNodeExecParams params)
void search_link_ops_for_declarations(GatherLinkSearchOpParams &params, Span< SocketDeclaration * > declarations)
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)
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
@ PROP_FACTOR
Definition RNA_types.hh:308
@ PROP_DISTANCE
Definition RNA_types.hh:313
@ GEO_NODE_CURVE_RESAMPLE_LENGTH
void geo_node_type_base(bke::bNodeType *ntype, UString idname, const std::optional< int16_t > legacy_type)
GeometryNodeCurveSampleMode
@ GEO_NODE_CURVE_SAMPLE_LENGTH
@ GEO_NODE_CURVE_SAMPLE_FACTOR
eNodeSocketDatatype type
bke::bNodeTreeType * typeinfo
const Curves * get_curves() const
void replace_curves(Curves *curves, GeometryOwnershipType ownership=GeometryOwnershipType::Owned)
GreasePencil * get_grease_pencil_for_write()
bool(*) validate_link(eNodeSocketDatatype from, eNodeSocketDatatype to)
Definition BKE_node.hh:566
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
NodeGatherSocketLinkOperationsFunction gather_link_search_ops
Definition BKE_node.hh:409
NodeDeclareFunction declare
Definition BKE_node.hh:393
nodes::NodeDeclaration * static_declaration
Definition BKE_node.hh:402
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)