30 .description(
"Curves to sample positions on");
33 const NodeGeometryCurveSample &storage = node_storage(*node);
34 b.add_input(eCustomDataType(storage.data_type),
"Value"_ustr)
36 .evaluated_geometry_field();
43 .structure_type(StructureType::Dynamic)
45 node_storage(node).mode = GEO_NODE_CURVE_SAMPLE_FACTOR;
50 .structure_type(StructureType::Dynamic)
52 node_storage(node).mode = GEO_NODE_CURVE_SAMPLE_LENGTH;
57 [](
bNode &
node) { node_storage(node).use_all_curves = false; });
59 const std::array<int, 3> dynamic_inputs = {factor.index(), length.index(), index.index()};
62 const NodeGeometryCurveSample &storage = node_storage(*node);
63 const GeometryNodeCurveSampleMode mode = GeometryNodeCurveSampleMode(storage.mode);
64 b.add_output(eCustomDataType(storage.data_type),
"Value"_ustr)
65 .propagate_references(dynamic_inputs)
66 .inferred_structure_type(dynamic_inputs);
68 factor.available(mode == GEO_NODE_CURVE_SAMPLE_FACTOR);
69 length.available(mode == GEO_NODE_CURVE_SAMPLE_LENGTH);
70 index.available(!storage.use_all_curves);
74 .propagate_references(dynamic_inputs)
75 .inferred_structure_type(dynamic_inputs);
77 .propagate_references(dynamic_inputs)
78 .inferred_structure_type(dynamic_inputs);
80 .propagate_references(dynamic_inputs)
81 .inferred_structure_type(dynamic_inputs);
95 data->use_all_curves =
false;
113 node_storage(
node).data_type = *type;
126 const float total_length = accumulated_lengths.
last();
129 mask.foreach_index([&](
const int i) {
131 sample_lengths[i] * total_length :
134 float factor_in_segment;
136 std::clamp(sample_length, 0.0f, total_length),
140 const float segment_start = segment_i == 0 ? 0.0f : accumulated_lengths[segment_i - 1];
141 const float segment_end = accumulated_lengths[segment_i];
142 const float segment_length = segment_end - segment_start;
144 r_segment_indices[i] = segment_i;
145 r_length_in_segment[i] = factor_in_segment * segment_length;
156 const float total_length = accumulated_lengths.
last();
159 switch (length_mode) {
161 mask.foreach_index([&](
const int i,
const int pos) {
162 const float length = sample_lengths[i] * total_length;
164 std::clamp(
length, 0.0f, total_length),
165 r_segment_indices[pos],
166 r_factor_in_segment[pos],
171 mask.foreach_index([&](
const int i,
const int pos) {
172 const float length = sample_lengths[i];
174 std::clamp(
length, 0.0f, total_length),
175 r_segment_indices[pos],
176 r_factor_in_segment[pos],
195 : accumulated_lengths_(std::move(accumulated_lengths)), length_mode_(length_mode)
197 static const mf::Signature
signature = []() {
199 mf::SignatureBuilder builder{
"Sample Curve Index",
signature};
200 builder.single_input<
float>(
"Length");
202 builder.single_output<
int>(
"Curve Index");
203 builder.single_output<
float>(
"Length in Curve");
211 const VArraySpan<float> lengths = params.readonly_single_input<
float>(0,
"Length");
212 MutableSpan<int> indices = params.uninitialized_single_output<
int>(1,
"Curve Index");
214 2,
"Length in Curve");
217 accumulated_lengths_, lengths, length_mode_,
mask, indices, lengths_in_segments);
232 mf::Signature signature_;
235 mutable std::optional<bke::CurvesFieldContext> source_context_;
236 mutable std::unique_ptr<FieldEvaluator> source_evaluator_;
237 mutable const GVArray *source_data_;
243 : geometry_set_(std::move(geometry_set)),
244 src_field_(std::move(src_field)),
245 length_mode_(length_mode)
247 mf::SignatureBuilder builder{
"Sample Curve", signature_};
248 builder.single_input<
int>(
"Curve Index");
249 builder.single_input<
float>(
"Length");
250 builder.single_output<
float3>(
"Position", mf::ParamFlag::SupportsUnusedOutput);
251 builder.single_output<
float3>(
"Tangent", mf::ParamFlag::SupportsUnusedOutput);
252 builder.single_output<
float3>(
"Normal", mf::ParamFlag::SupportsUnusedOutput);
253 builder.single_output(
"Value", src_field_.cpp_type(), mf::ParamFlag::SupportsUnusedOutput);
254 this->set_signature(&signature_);
265 GMutableSpan sampled_values = params.uninitialized_single_output_if_required(5,
"Value");
267 auto return_default = [&]() {
268 if (!sampled_positions.
is_empty()) {
271 if (!sampled_tangents.is_empty()) {
274 if (!sampled_normals.is_empty()) {
279 if (!geometry_set_.has_curves()) {
284 const Curves &curves_id = *geometry_set_.get_curves();
290 curves.ensure_can_interpolate_to_evaluated();
294 if (!sampled_tangents.is_empty()) {
295 evaluated_tangents =
curves.evaluated_tangents();
297 if (!sampled_normals.is_empty()) {
298 evaluated_normals =
curves.evaluated_normals();
303 const VArray<int> curve_indices = params.readonly_single_input<
int>(0,
"Curve Index");
304 const VArraySpan<float> lengths = params.readonly_single_input<
float>(1,
"Length");
309 GArray<> src_original_values(source_data_->type());
310 GArray<> src_evaluated_values(source_data_->type());
313 if (!sampled_positions.
is_empty()) {
316 if (!sampled_tangents.is_empty()) {
319 if (!sampled_normals.is_empty()) {
322 if (!sampled_values.is_empty()) {
323 sampled_values.type().fill_construct_indices(
324 sampled_values.type().default_value(), sampled_values.data(),
mask);
328 auto sample_curve = [&](
const int curve_i,
const IndexMask &
mask) {
329 const IndexRange evaluated_points = evaluated_points_by_curve[curve_i];
330 if (evaluated_points.
size() == 1) {
331 if (!sampled_positions.
is_empty()) {
333 sampled_positions, evaluated_positions[evaluated_points.
first()],
mask);
335 if (!sampled_tangents.is_empty()) {
337 sampled_tangents, evaluated_tangents[evaluated_points.
first()],
mask);
339 if (!sampled_normals.is_empty()) {
341 sampled_normals, evaluated_normals[evaluated_points.
first()],
mask);
343 if (!sampled_values.is_empty()) {
345 source_data_->get(points_by_curve[curve_i].first(), value);
346 source_data_->type().fill_construct_indices(value, sampled_values.data(),
mask);
351 const Span<float> accumulated_lengths =
curves.evaluated_lengths_for_curve(curve_i,
353 if (accumulated_lengths.
is_empty()) {
364 accumulated_lengths, lengths, length_mode_,
mask, indices, factors);
366 if (!sampled_positions.
is_empty()) {
368 evaluated_positions.
slice(evaluated_points),
374 if (!sampled_tangents.is_empty()) {
376 evaluated_tangents.
slice(evaluated_points), indices, factors,
mask, sampled_tangents);
378 [&](
const int i) { sampled_tangents[i] =
math::normalize(sampled_tangents[i]); });
380 if (!sampled_normals.is_empty()) {
382 evaluated_normals.
slice(evaluated_points), indices, factors,
mask, sampled_normals);
384 [&](
const int i) { sampled_normals[i] =
math::normalize(sampled_normals[i]); });
386 if (!sampled_values.is_empty()) {
387 const IndexRange points = points_by_curve[curve_i];
389 source_data_->materialize_compressed_to_uninitialized(points, src_original_values.
data());
391 curves.interpolate_to_evaluated(curve_i, src_original_values, src_evaluated_values);
393 if constexpr (!std::is_same_v<T, std::string>) {
394 const Span<T> src_evaluated_values_typed = src_evaluated_values.as_span().typed<T>();
395 MutableSpan<T> sampled_values_typed = sampled_values.typed<T>();
396 length_parameterize::interpolate_to_masked<T>(
397 src_evaluated_values_typed, indices, factors, mask, sampled_values_typed);
403 if (
const std::optional<int> curve_i = curve_indices.get_if_single()) {
404 if (
curves.curves_range().contains(*curve_i)) {
405 sample_curve(*curve_i,
mask);
412 const VArraySpan<int> curve_indices_span(curve_indices);
413 IndexMaskMemory memory;
415 return curves.curves_range().contains(curve_indices_span[i]);
419 valid_mask, curve_indices, memory);
420 for (
const IndexMask &curve_mask : mask_by_curve) {
421 sample_curve(curve_indices_span[curve_mask.first()], curve_mask);
423 fill_invalid(invalid_mask);
429 mutex_.ensure([&]() {
430 const Curves &curves_id = *geometry_set_.get_curves();
433 source_evaluator_ = std::make_unique<FieldEvaluator>(*source_context_,
curves.points_num());
434 source_evaluator_->add(src_field_);
435 source_evaluator_->evaluate();
436 source_data_ = &source_evaluator_->get_evaluated(0);
442 static constexpr int8_t id = 0;
444 hash.add(geometry_set_.get_curves());
445 hash.add(length_mode_);
457 for (
const int i :
curves.curves_range()) {
458 length +=
curves.evaluated_length_total_for_curve(i, cyclic[i]);
459 curve_lengths[i] =
length;
461 return curve_lengths;
479 curves.ensure_evaluated_lengths();
490 std::string error_message;
496 std::shared_ptr<FieldOperation> sample_op;
497 if (
curves.curves_num() == 1) {
500 std::make_unique<SampleCurveFunction>(
501 std::move(geometry_set), mode, std::move(src_values_field)),
502 {&curve_index, &sample_length},
503 {&
position, &tangent, &normal, &value},
519 {&curve_index, &length_in_curve},
528 std::make_shared<SampleCurveFunction>(std::move(geometry_set),
530 std::move(src_values_field)),
531 {&curve_index, &length_in_curve},
532 {&
position, &tangent, &normal, &value},
544 std::make_shared<SampleCurveFunction>(
545 std::move(geometry_set), mode, std::move(src_values_field)),
546 {&curve_index, &sample_length},
547 {&
position, &tangent, &normal, &value},
559 params.
set_output(
"Tangent"_ustr, std::move(tangent));
560 params.
set_output(
"Normal"_ustr, std::move(normal));
561 params.
set_output(
"Value"_ustr, std::move(value));
569 ntype.
ui_name =
"Sample Curve";
571 "Retrieve data from a point on a curve at a certain distance from its start";
Low-level operations for curves.
#define NODE_STORAGE_FUNCS(StorageT)
#define NODE_CLASS_GEOMETRY
#define GEO_NODE_SAMPLE_CURVE
#define BUFFER_FOR_CPP_TYPE_VALUE(type, variable_name)
#define NOD_REGISTER_NODE(REGISTER_FUNC)
void reinitialize(const int64_t new_size)
void reinitialize(const int64_t new_size)
const void * data() const
static IndexMask from_predicate(const IndexMask &universe, LinearAllocator<> &memory, Fn &&predicate, exec_mode::Mode mode=exec_mode::parallel)
static IndexMask from_difference(const IndexMask &mask_a, const IndexMask &mask_b, LinearAllocator<> &memory)
static Vector< IndexMask, 4 > from_group_ids(const VArray< int > &group_ids, LinearAllocator<> &memory)
constexpr int64_t first() const
constexpr int64_t size() const
constexpr bool is_empty() const
constexpr Span slice(int64_t start, int64_t size) const
constexpr const T & last(const int64_t n=0) const
constexpr bool is_empty() const
static SocketValueVariant from(T &&value)
const Signature & signature() const
void set_signature(const Signature *signature)
const bke::bNodeType & node_type() const
void add_item(std::string socket_name, SocketLinkOperation::LinkSocketFn fn, int weight=0)
const bNodeSocket & other_socket() const
void error_message_add(const NodeWarningType type, StringRef message) const
T extract_input(const UString identifier)
GeoNodesUserData * user_data() const
const bNode & node() const
void set_default_remaining_outputs()
void set_output(const UString identifier, T &&value)
void update_and_connect_available_socket(bNode &new_node, UString socket_name)
bNode & add_node(UString idname)
Vector< SocketDeclaration * > inputs
Vector< SocketDeclaration * > outputs
StructureType structure_type
bool only_realized_data() const
void hash_unique(UniqueHashBytes &hash) const override
void prepare_for_execution() const override
SampleCurveFunction(GeometrySet geometry_set, const GeometryNodeCurveSampleMode length_mode, GField src_field)
void call(const IndexMask &mask, mf::Params params, mf::Context) const override
void call(const IndexMask &mask, mf::Params params, mf::Context) const override
SampleFloatSegmentsFunction(Array< float > accumulated_lengths, const GeometryNodeCurveSampleMode length_mode)
#define storage(slot, qualifiers)
float length(VecOp< float, D >) RET
ccl_device_inline float2 mask(const MaskType mask, const float2 a)
void to_static_type(const CPPType &cpp_type, Fn &&fn)
void node_register_type(bNodeType &ntype)
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))
std::optional< eCustomDataType > socket_type_to_custom_data_type(eNodeSocketDatatype type)
void masked_fill(MutableSpan< T > data, const T &value, const IndexMask &mask)
void sample_at_length(const Span< float > accumulated_segment_lengths, const float sample_length, int &r_segment_index, float &r_factor, SampleSegmentHint *hint=nullptr)
void interpolate_to_masked(const Span< T > src, const Span< int > indices, const Span< float > factors, const IndexMask &dst_mask, MutableSpan< T > dst)
MatBase< T, NumCol, NumRow > normalize(const MatBase< T, NumCol, NumRow > &a)
static void sample_indices_and_factors_to_compressed(const Span< float > accumulated_lengths, const Span< float > sample_lengths, const GeometryNodeCurveSampleMode length_mode, const IndexMask &mask, MutableSpan< int > r_segment_indices, MutableSpan< float > r_factor_in_segment)
static Array< float > curve_accumulated_lengths(const bke::CurvesGeometry &curves)
static void node_declare(NodeDeclarationBuilder &b)
static void node_register()
static void node_geo_exec(GeoNodeExecParams params)
static void node_gather_link_searches(GatherLinkSearchOpParams ¶ms)
static void sample_indices_and_lengths(const Span< float > accumulated_lengths, const Span< float > sample_lengths, const GeometryNodeCurveSampleMode length_mode, const IndexMask &mask, MutableSpan< int > r_segment_indices, MutableSpan< float > r_length_in_segment)
static void node_layout(ui::Layout &layout, bContext *, PointerRNA *ptr)
static void node_init(bNodeTree *, bNode *node)
void search_link_ops_for_declarations(GatherLinkSearchOpParams ¶ms, Span< SocketDeclaration * > declarations)
bool execute_multi_function_on_value_variant(const MultiFunction &fn, const std::shared_ptr< MultiFunction > &owned_fn, const Span< SocketValueVariant * > input_values, const Span< SocketValueVariant * > output_values, GeoNodesUserData *user_data, std::string &r_error_message)
BMesh const char void * data
void node_copy_standard_storage(bNodeTree *, bNode *dest_node, const bNode *src_node)
void node_free_standard_storage(bNode *node)
VecBase< float, 3 > float3
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
const Curves * get_curves() const
void(*) draw_buttons(ui::Layout &, bContext *C, PointerRNA *ptr)
std::string ui_description
NodeGeometryExecFunction geometry_node_execute
void(*) initfunc(bNodeTree *ntree, bNode *node)
const char * enum_name_legacy
NodeGatherSocketLinkOperationsFunction gather_link_search_ops
NodeDeclareFunction declare
nodes::NodeDeclaration * static_declaration
UniqueHash ensure(const GFieldRef &field)
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)