Blender V5.3
geometry_nodes_foreach_geometry_element_zone.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2024 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
10
13#include "BKE_curves.hh"
15#include "BKE_grease_pencil.hh"
16#include "BKE_node_runtime.hh"
18
22
24
25#include "BLT_translation.hh"
26
28
29namespace blender::nodes {
30
31using bke::AttrDomain;
32using bke::AttributeAccessor;
33using bke::GeometryComponent;
34using bke::GeometrySet;
35using bke::MutableAttributeAccessor;
36using bke::SocketValueVariant;
37using fn::Field;
38using fn::GField;
39
42
48
58 std::optional<bke::GeometryFieldContext> field_context;
59 std::optional<fn::FieldEvaluator> field_evaluator;
65 std::optional<Array<SocketValueVariant>> element_geometries;
71
73 {
74 if (this->id.component_type == GeometryComponent::Type::GreasePencil &&
75 ELEM(this->id.domain, AttrDomain::Point, AttrDomain::Curve))
76 {
77 this->field_context.emplace(
78 *geometry.get_grease_pencil(), this->id.domain, *this->id.layer_index);
79 }
80 else {
81 this->field_context.emplace(*geometry.get_component(this->id.component_type),
82 this->id.domain);
83 }
84 }
85
87 {
88 return *this->field_context->attributes();
89 }
90
92 {
93 if (this->id.component_type == GeometryComponent::Type::GreasePencil &&
94 ELEM(this->id.domain, AttrDomain::Point, AttrDomain::Curve))
95 {
96 BLI_assert(this->id.layer_index.has_value());
97 GreasePencil *grease_pencil = geometry.get_grease_pencil_for_write();
98 const bke::greasepencil::Layer &layer = grease_pencil->layer(*this->id.layer_index);
99 bke::greasepencil::Drawing *drawing = grease_pencil->get_eval_drawing(layer);
100 BLI_assert(drawing);
101 return drawing->strokes_for_write().attributes_for_write();
102 }
103 GeometryComponent &component = geometry.get_component_for_write(this->id.component_type);
104 return *component.attributes_for_write();
105 }
106};
107
115
116 public:
120
121 void execute_impl(lf::Params &params, const lf::Context &context) const override;
122
123 void handle_main_items_and_geometry(lf::Params &params, const lf::Context &context) const;
124 void handle_generation_items(lf::Params &params, const lf::Context &context) const;
125 int handle_invalid_generation_items(lf::Params &params) const;
126 void handle_generation_item_groups(lf::Params &params,
127 const lf::Context &context,
128 int first_valid_item_i) const;
129 void handle_generation_items_group(lf::Params &params,
130 const lf::Context &context,
131 int geometry_item_i,
132 IndexRange generation_items_range) const;
133 bool handle_generation_items_group_lazyness(lf::Params &params,
134 const lf::Context &context,
135 int geometry_item_i,
136 IndexRange generation_items_range) const;
137};
138
143class ForeachGeometryElementNodeExecuteWrapper : public lf::GraphExecutorNodeExecuteWrapper {
144 public:
145 const bNode *output_bnode_ = nullptr;
147
148 void execute_node(const lf::FunctionNode &node,
149 lf::Params &params,
150 const lf::Context &context) const override
151 {
152 GeoNodesUserData &user_data = *static_cast<GeoNodesUserData *>(context.user_data);
153 const int index = lf_body_nodes_->index_of_try(const_cast<lf::FunctionNode *>(&node));
154 const LazyFunction &fn = node.function();
155 if (index == -1) {
156 /* The node is not a loop body node, just execute it normally. */
157 fn.execute(params, context);
158 return;
159 }
160
161 /* Setup context for the loop body evaluation. */
163 user_data.compute_context, *output_bnode_, index};
164 GeoNodesUserData body_user_data = user_data;
165 body_user_data.compute_context = &body_compute_context;
166 body_user_data.verbose_log = should_log_verbose_in_context(user_data,
167 body_compute_context.hash());
168
169 GeoNodesLocalUserData body_local_user_data{body_user_data};
170 lf::Context body_context{context.storage, &body_user_data, &body_local_user_data};
171 fn.execute(params, body_context);
172 }
173};
174
179class ForeachGeometryElementZoneSideEffectProvider : public lf::GraphExecutorSideEffectProvider {
180 public:
181 const bNode *output_bnode_ = nullptr;
183
185 const lf::Context &context) const override
186 {
187 GeoNodesUserData &user_data = *static_cast<GeoNodesUserData *>(context.user_data);
188 const GeoNodesCallData &call_data = *user_data.call_data;
189 if (!call_data.side_effect_nodes) {
190 return {};
191 }
192 const ComputeContextHash &context_hash = user_data.compute_context->hash();
193 const Span<int> iterations_with_side_effects =
195 {context_hash, output_bnode_->identifier});
196
198 for (const int i : iterations_with_side_effects) {
199 if (i >= 0 && i < lf_body_nodes_.size()) {
200 lf_nodes.append(lf_body_nodes_[i]);
201 }
202 }
203 return lf_nodes;
204 }
205};
206
213
215 lf::Graph graph;
216 std::optional<ForeachGeometryElementZoneSideEffectProvider> side_effect_provider;
217 std::optional<ForeachGeometryElementNodeExecuteWrapper> body_execute_wrapper;
218 std::optional<lf::GraphExecutor> graph_executor;
219 void *graph_executor_storage = nullptr;
220
222 std::optional<LazyFunctionForLogicalOr> or_function;
223 std::optional<LazyFunctionForReduceForeachGeometryElement> reduce_function;
224
230
237};
238
239class LazyFunctionForForeachGeometryElementZone : public LazyFunction {
240 private:
241 const bNodeTree &btree_;
242 const bke::bNodeTreeZone &zone_;
243 const bNode &output_bnode_;
244 const ZoneBuildInfo &zone_info_;
245 const ZoneBodyFunction &body_fn_;
246
247 struct ItemIndices {
248 /* `outer` refers to sockets on the outside of the zone, and `inner` to the sockets on the
249 * inside. The `lf` and `bsocket` indices are similar, but the `lf` indices skip unavailable
250 * and extend sockets. */
251 IndexRange lf_outer;
252 IndexRange lf_inner;
253 IndexRange bsocket_outer;
254 IndexRange bsocket_inner;
255 };
256
258 struct {
259 ItemIndices inputs;
260 ItemIndices main;
261 ItemIndices generation;
262 } indices_;
263
264 friend LazyFunctionForReduceForeachGeometryElement;
265
266 public:
268 const bke::bNodeTreeZone &zone,
269 ZoneBuildInfo &zone_info,
270 const ZoneBodyFunction &body_fn)
271 : btree_(btree),
272 zone_(zone),
273 output_bnode_(*zone.output_node()),
274 zone_info_(zone_info),
275 body_fn_(body_fn)
276 {
277 debug_name_ = "Foreach Geometry Element";
278
279 initialize_zone_wrapper(zone, zone_info, body_fn, true, inputs_, outputs_);
280 /* All main inputs are always used for now. */
281 for (const int i : zone_info.indices.inputs.main) {
282 inputs_[i].usage = lf::ValueUsage::Used;
283 }
284
285 const auto &node_storage = *static_cast<const NodeGeometryForeachGeometryElementOutput *>(
286 output_bnode_.storage);
287 const AttrDomain iteration_domain = AttrDomain(node_storage.domain);
288 BLI_assert(zone_.input_node()->output_socket(1).is_available() ==
289 (iteration_domain != AttrDomain::Corner));
290
291 const int input_items_num = node_storage.input_items.items_num;
292 const int main_items_num = node_storage.main_items.items_num;
293 const int generation_items_num = node_storage.generation_items.items_num;
294
295 indices_.inputs.lf_outer = IndexRange::from_begin_size(2, input_items_num);
296 indices_.inputs.lf_inner = IndexRange::from_begin_size(
297 iteration_domain == AttrDomain::Corner ? 1 : 2, input_items_num);
298 indices_.inputs.bsocket_outer = indices_.inputs.lf_outer;
299 indices_.inputs.bsocket_inner = indices_.inputs.lf_inner;
300
301 indices_.main.lf_outer = IndexRange::from_begin_size(1, main_items_num);
302 indices_.main.lf_inner = IndexRange::from_begin_size(0, main_items_num);
303 indices_.main.bsocket_outer = indices_.main.lf_outer;
304 indices_.main.bsocket_inner = indices_.main.lf_inner;
305
306 indices_.generation.lf_outer = IndexRange::from_begin_size(1 + main_items_num,
307 generation_items_num);
308 indices_.generation.lf_inner = IndexRange::from_begin_size(main_items_num,
309 generation_items_num);
310 indices_.generation.bsocket_outer = IndexRange::from_begin_size(2 + main_items_num,
311 generation_items_num);
312 indices_.generation.bsocket_inner = IndexRange::from_begin_size(1 + main_items_num,
313 generation_items_num);
314 }
315
316 void *init_storage(LinearAllocator<> &allocator) const override
317 {
318 return allocator.construct<ForeachGeometryElementEvalStorage>().release();
319 }
320
321 void destruct_storage(void *storage) const override
322 {
323 auto *s = static_cast<ForeachGeometryElementEvalStorage *>(storage);
324 if (s->graph_executor_storage) {
325 s->graph_executor->destruct_storage(s->graph_executor_storage);
326 }
327 std::destroy_at(s);
328 }
329
330 void execute_impl(lf::Params &params, const lf::Context &context) const override
331 {
332 const ScopedNodeTimer node_timer{context, output_bnode_};
333
334 auto &user_data = *static_cast<GeoNodesUserData *>(context.user_data);
335 auto &local_user_data = *static_cast<GeoNodesLocalUserData *>(context.local_user_data);
336
337 const auto &node_storage = *static_cast<const NodeGeometryForeachGeometryElementOutput *>(
338 output_bnode_.storage);
339 auto &eval_storage = *static_cast<ForeachGeometryElementEvalStorage *>(context.storage);
340 eval_log::NodeTreeLogger *tree_logger = local_user_data.try_get_tree_logger(user_data);
341
342 if (!eval_storage.graph_executor) {
343 /* Create the execution graph in the first evaluation. */
344 this->initialize_execution_graph(params, eval_storage, node_storage);
345
346 if (tree_logger) {
347 if (eval_storage.total_iterations_num == 0) {
348 if (!eval_storage.main_geometry.is_empty()) {
349 tree_logger->node_warnings.append(
350 *tree_logger->allocator,
351 {zone_.input_node()->identifier,
352 {NodeWarningType::Info,
353 N_("Input geometry has no elements in the iteration domain.")}});
354 }
355 }
356 }
357 }
358
359 lf::Context eval_graph_context{
360 eval_storage.graph_executor_storage, context.user_data, context.local_user_data};
361
362 eval_storage.graph_executor->execute(params, eval_graph_context);
363 }
364
366 lf::Params &params,
368 const NodeGeometryForeachGeometryElementOutput &node_storage) const
369 {
370 eval_storage.main_geometry = params
371 .extract_input<SocketValueVariant>(
372 zone_info_.indices.inputs.main[0])
374
375 /* Find all the things we need to iterate over in the input geometry. */
376 this->prepare_components(params, eval_storage, node_storage);
377
378 /* Add interface sockets for the zone graph. Those are the same as for the entire zone, even
379 * though some of the inputs are not strictly needed anymore. It's easier to avoid another
380 * level of index remapping though. */
381 lf::Graph &lf_graph = eval_storage.graph;
384 for (const int i : inputs_.index_range()) {
385 const lf::Input &input = inputs_[i];
386 graph_inputs.append(&lf_graph.add_input(*input.type, this->input_name(i)));
387 }
388 for (const int i : outputs_.index_range()) {
389 const lf::Output &output = outputs_[i];
390 graph_outputs.append(&lf_graph.add_output(*output.type, this->output_name(i)));
391 }
392
393 /* Add all the nodes and links to the graph. */
394 this->build_graph_contents(eval_storage, node_storage, graph_inputs, graph_outputs);
395
396 eval_storage.side_effect_provider.emplace();
397 eval_storage.side_effect_provider->output_bnode_ = &output_bnode_;
398 eval_storage.side_effect_provider->lf_body_nodes_ = eval_storage.lf_body_nodes;
399
400 eval_storage.body_execute_wrapper.emplace();
401 eval_storage.body_execute_wrapper->output_bnode_ = &output_bnode_;
402 eval_storage.body_execute_wrapper->lf_body_nodes_ = &eval_storage.lf_body_nodes;
403
404 lf_graph.update_node_indices();
405 eval_storage.graph_executor.emplace(lf_graph,
406 graph_inputs.as_span(),
407 graph_outputs.as_span(),
408 nullptr,
409 &*eval_storage.side_effect_provider,
410 &*eval_storage.body_execute_wrapper);
411 eval_storage.graph_executor_storage = eval_storage.graph_executor->init_storage(
412 eval_storage.allocator);
413
414 /* Log graph for debugging purposes. */
415 const bNodeTree &btree_orig = *DEG_get_original(&btree_);
416 if (btree_orig.runtime->logged_zone_graphs) {
417 std::lock_guard lock{btree_orig.runtime->logged_zone_graphs->mutex};
418 btree_orig.runtime->logged_zone_graphs->graph_by_zone_id.lookup_or_add_cb(
419 output_bnode_.identifier, [&]() { return lf_graph.to_dot(); });
420 }
421 }
422
423 void prepare_components(lf::Params &params,
425 const NodeGeometryForeachGeometryElementOutput &node_storage) const
426 {
427 const AttrDomain iteration_domain = AttrDomain(node_storage.domain);
428
429 /* TODO: Get propagation info from input, but that's not necessary for correctness for now. */
430 bke::AttributeFilter attribute_filter;
431
432 const bNodeSocket &element_geometry_bsocket = zone_.input_node()->output_socket(1);
433 const bool create_element_geometries = element_geometry_bsocket.is_available() &&
434 element_geometry_bsocket.is_directly_linked();
435
436 /* Gather components to process. */
438 for (const GeometryComponent *src_component : eval_storage.main_geometry.get_components()) {
439 const GeometryComponent::Type component_type = src_component->type();
440 if (src_component->type() == GeometryComponent::Type::GreasePencil &&
441 ELEM(iteration_domain, AttrDomain::Point, AttrDomain::Curve))
442 {
444 for (const int layer_i : grease_pencil.layers().index_range()) {
445 const bke::greasepencil::Drawing *drawing = grease_pencil.get_eval_drawing(
446 grease_pencil.layer(layer_i));
447 if (drawing == nullptr) {
448 continue;
449 }
450 const bke::CurvesGeometry &curves = drawing->strokes();
451 if (curves.is_empty()) {
452 continue;
453 }
454 component_ids.append({component_type, iteration_domain, layer_i});
455 }
456 }
457 else {
458 const int domain_size = src_component->attribute_domain_size(iteration_domain);
459 if (domain_size > 0) {
460 component_ids.append({component_type, iteration_domain});
461 }
462 }
463 }
464
465 const Field<bool> selection_field = params
466 .extract_input<SocketValueVariant>(
467 zone_info_.indices.inputs.main[1])
469
470 /* Evaluate the selection and field inputs for all components. */
471 int body_nodes_offset = 0;
472 eval_storage.components.reinitialize(component_ids.size());
473 for (const int component_i : component_ids.index_range()) {
474 const ForeachElementComponentID id = component_ids[component_i];
475 ForeachElementComponent &component_info = eval_storage.components[component_i];
476 component_info.id = id;
477 component_info.emplace_field_context(eval_storage.main_geometry);
478
479 const int domain_size = component_info.input_attributes().domain_size(id.domain);
480 BLI_assert(domain_size > 0);
481
482 /* Prepare field evaluation for the zone inputs. */
483 component_info.field_evaluator.emplace(*component_info.field_context, domain_size);
484 component_info.field_evaluator->set_selection(selection_field);
485 for (const int item_i : IndexRange(node_storage.input_items.items_num)) {
486 const GField item_field =
487 params
488 .get_input<SocketValueVariant>(
489 zone_info_.indices.inputs.main[indices_.inputs.lf_outer[item_i]])
490 .ensure_type<GField>();
491 component_info.field_evaluator->add(item_field);
492 }
493
494 /* Evaluate all fields passed to the zone input. */
495 component_info.field_evaluator->evaluate();
496
497 /* The mask contains all the indices that should be iterated over in the component. */
498 const IndexMask mask = component_info.field_evaluator->get_evaluated_selection_as_mask();
499 component_info.body_nodes_range = IndexRange::from_begin_size(body_nodes_offset,
500 mask.size());
501 body_nodes_offset += mask.size();
502
503 /* Prepare indices that are passed into each iteration. */
504 component_info.index_values.reinitialize(mask.size());
505 mask.foreach_index_optimized<int>(
506 [&](const int i, const int pos) { component_info.index_values[pos].emplace<int>(i); });
507
508 if (create_element_geometries) {
509 if (std::optional<Array<GeometrySet>> element_geometries =
511 eval_storage.main_geometry, id, mask, attribute_filter))
512 {
513 component_info.element_geometries.emplace(element_geometries->size());
515 element_geometries->index_range(), 256, [&](const IndexRange range) {
516 for (const int i : range) {
517 (*component_info.element_geometries)[i] = SocketValueVariant::from(
518 (*element_geometries)[i]);
519 }
520 });
521 }
522 }
523
524 /* Prepare remaining inputs that come from the field evaluation. */
525 component_info.item_input_values.reinitialize(node_storage.input_items.items_num);
526 for (const int item_i : IndexRange(node_storage.input_items.items_num)) {
527 const NodeForeachGeometryElementInputItem &item = node_storage.input_items.items[item_i];
528 const eNodeSocketDatatype socket_type = item.socket_type;
529 const CPPType &base_cpp_type = *bke::socket_type_to_geo_nodes_base_cpp_type(socket_type);
530 component_info.item_input_values[item_i].reinitialize(mask.size());
531 const GVArray &values = component_info.field_evaluator->get_evaluated(item_i);
532 mask.foreach_index(
533 [&](const int i, const int pos) {
534 SocketValueVariant &value_variant = component_info.item_input_values[item_i][pos];
535 void *buffer = value_variant.allocate_single(base_cpp_type);
536 values.get_to_uninitialized(i, buffer);
537 },
539 }
540 }
541
542 eval_storage.total_iterations_num = body_nodes_offset;
543 }
544
545 std::optional<Array<GeometrySet>> try_extract_element_geometries(
546 const GeometrySet &main_geometry,
548 const IndexMask &mask,
549 const bke::AttributeFilter &attribute_filter) const
550 {
551 switch (id.component_type) {
552 case GeometryComponent::Type::Mesh: {
553 const Mesh &main_mesh = *main_geometry.get_mesh();
554 Array<Mesh *> meshes;
555 switch (id.domain) {
556 case AttrDomain::Point: {
557 meshes = geometry::extract_mesh_vertices(main_mesh, mask, attribute_filter);
558 break;
559 }
560 case AttrDomain::Edge: {
561 meshes = geometry::extract_mesh_edges(main_mesh, mask, attribute_filter);
562 break;
563 }
564 case AttrDomain::Face: {
565 meshes = geometry::extract_mesh_faces(main_mesh, mask, attribute_filter);
566 break;
567 }
568 default: {
569 return std::nullopt;
570 }
571 }
572 Array<GeometrySet> element_geometries(meshes.size());
573 for (const int i : meshes.index_range()) {
574 element_geometries[i].replace_mesh(meshes[i]);
575 }
576 return element_geometries;
577 }
578 case GeometryComponent::Type::PointCloud: {
579 if (id.domain != AttrDomain::Point) {
580 return std::nullopt;
581 }
582 const PointCloud &main_pointcloud = *main_geometry.get_pointcloud();
584 main_pointcloud, mask, attribute_filter);
585 Array<GeometrySet> element_geometries(pointclouds.size());
586 for (const int i : pointclouds.index_range()) {
587 element_geometries[i].replace_pointcloud(pointclouds[i]);
588 }
589 return element_geometries;
590 }
591 case GeometryComponent::Type::Curve: {
592 const Curves &main_curves = *main_geometry.get_curves();
593 Array<Curves *> element_curves;
594 switch (id.domain) {
595 case AttrDomain::Point: {
596 element_curves = geometry::extract_curves_points(main_curves, mask, attribute_filter);
597 break;
598 }
599 case AttrDomain::Curve: {
600 element_curves = geometry::extract_curves(main_curves, mask, attribute_filter);
601 break;
602 }
603 default:
604 return std::nullopt;
605 }
606 Array<GeometrySet> element_geometries(element_curves.size());
607 for (const int i : element_curves.index_range()) {
608 element_geometries[i].replace_curves(element_curves[i]);
609 }
610 return element_geometries;
611 }
612 case GeometryComponent::Type::Instance: {
613 if (id.domain != AttrDomain::Instance) {
614 return std::nullopt;
615 }
616 const bke::Instances &main_instances = *main_geometry.get_instances();
618 main_instances, mask, attribute_filter);
619 Array<GeometrySet> element_geometries(element_instances.size());
620 for (const int i : element_instances.index_range()) {
621 element_geometries[i].replace_instances(element_instances[i]);
622 }
623 return element_geometries;
624 }
625 case GeometryComponent::Type::GreasePencil: {
626 const GreasePencil &main_grease_pencil = *main_geometry.get_grease_pencil();
627 Array<GreasePencil *> element_grease_pencils;
628 switch (id.domain) {
629 case AttrDomain::Layer: {
630 element_grease_pencils = geometry::extract_greasepencil_layers(
631 main_grease_pencil, mask, attribute_filter);
632 break;
633 }
634 case AttrDomain::Point: {
635 element_grease_pencils = geometry::extract_greasepencil_layer_points(
636 main_grease_pencil, *id.layer_index, mask, attribute_filter);
637 break;
638 }
639 case AttrDomain::Curve: {
640 element_grease_pencils = geometry::extract_greasepencil_layer_curves(
641 main_grease_pencil, *id.layer_index, mask, attribute_filter);
642 break;
643 }
644 default:
645 return std::nullopt;
646 }
647 Array<GeometrySet> element_geometries(element_grease_pencils.size());
648 for (const int i : element_geometries.index_range()) {
649 element_geometries[i].replace_grease_pencil(element_grease_pencils[i]);
650 }
651 return element_geometries;
652 }
653 default:
654 break;
655 }
656 return std::nullopt;
657 }
658
661 Span<lf::GraphInputSocket *> graph_inputs,
662 Span<lf::GraphOutputSocket *> graph_outputs) const
663 {
664 lf::Graph &lf_graph = eval_storage.graph;
665
666 /* Create body nodes. */
667 VectorSet<lf::FunctionNode *> &lf_body_nodes = eval_storage.lf_body_nodes;
668 for ([[maybe_unused]] const int i : IndexRange(eval_storage.total_iterations_num)) {
669 lf::FunctionNode &lf_node = lf_graph.add_function(*body_fn_.function);
670 lf_body_nodes.add_new(&lf_node);
671 }
672
673 /* Link up output usages to body nodes. */
674 for (const int zone_output_i : body_fn_.indices.inputs.output_usages.index_range()) {
675 /* +1 because of geometry output. */
676 lf::GraphInputSocket &lf_graph_input =
677 *graph_inputs[zone_info_.indices.inputs.output_usages[1 + zone_output_i]];
678 for (const int i : lf_body_nodes.index_range()) {
679 lf::FunctionNode &lf_node = *lf_body_nodes[i];
680 lf_graph.add_link(lf_graph_input,
681 lf_node.input(body_fn_.indices.inputs.output_usages[zone_output_i]));
682 }
683 }
684
685 const bNodeSocket &element_geometry_bsocket = zone_.input_node()->output_socket(1);
686
687 static const SocketValueVariant empty_geometry_value = SocketValueVariant::from(GeometrySet());
688 for (const ForeachElementComponent &component_info : eval_storage.components) {
689 for (const int i : component_info.body_nodes_range.index_range()) {
690 const int body_i = component_info.body_nodes_range[i];
691 lf::FunctionNode &lf_body_node = *lf_body_nodes[body_i];
692 /* Set index input for loop body. */
693 lf_body_node.input(body_fn_.indices.inputs.main[0])
694 .set_default_value(&component_info.index_values[i]);
695 /* Set geometry element input for loop body. */
696 if (element_geometry_bsocket.is_available()) {
697 const SocketValueVariant *element_geometry =
698 component_info.element_geometries.has_value() ?
699 &(*component_info.element_geometries)[i] :
700 &empty_geometry_value;
701 lf_body_node.input(body_fn_.indices.inputs.main[1]).set_default_value(element_geometry);
702 }
703 /* Set main input values for loop body. */
704 for (const int item_i : IndexRange(node_storage.input_items.items_num)) {
705 lf_body_node.input(body_fn_.indices.inputs.main[indices_.inputs.lf_inner[item_i]])
706 .set_default_value(&component_info.item_input_values[item_i][i]);
707 }
708 /* Link up border-link inputs to the loop body. */
709 for (const int border_link_i : zone_info_.indices.inputs.border_links.index_range()) {
710 lf_graph.add_link(
711 *graph_inputs[zone_info_.indices.inputs.border_links[border_link_i]],
712 lf_body_node.input(body_fn_.indices.inputs.border_links[border_link_i]));
713 }
714 /* Link up reference sets. */
715 for (const auto &item : body_fn_.indices.inputs.reference_sets.items()) {
716 lf_graph.add_link(
717 *graph_inputs[zone_info_.indices.inputs.reference_sets.lookup(item.key)],
718 lf_body_node.input(item.value));
719 }
720 }
721 }
722
723 /* Add the reduce function that has all outputs from the zone bodies as input. */
724 eval_storage.reduce_function.emplace(*this, eval_storage);
725 lf::FunctionNode &lf_reduce = lf_graph.add_function(*eval_storage.reduce_function);
726
727 /* Link up body outputs to reduce function. */
728 const int body_main_outputs_num = node_storage.main_items.items_num +
729 node_storage.generation_items.items_num;
730 BLI_assert(body_main_outputs_num == body_fn_.indices.outputs.main.size());
731 for (const int i : IndexRange(eval_storage.total_iterations_num)) {
732 lf::FunctionNode &lf_body_node = *lf_body_nodes[i];
733 for (const int item_i : IndexRange(node_storage.main_items.items_num)) {
734 lf_graph.add_link(lf_body_node.output(body_fn_.indices.outputs.main[item_i]),
735 lf_reduce.input(i * body_main_outputs_num + item_i));
736 }
737 for (const int item_i : IndexRange(node_storage.generation_items.items_num)) {
738 const int body_output_i = item_i + node_storage.main_items.items_num;
739 lf_graph.add_link(lf_body_node.output(body_fn_.indices.outputs.main[body_output_i]),
740 lf_reduce.input(i * body_main_outputs_num + body_output_i));
741 }
742 }
743
744 /* Link up reduce function outputs to final zone outputs. */
745 lf_graph.add_link(lf_reduce.output(0), *graph_outputs[zone_info_.indices.outputs.main[0]]);
746 for (const int item_i : IndexRange(node_storage.main_items.items_num)) {
747 const int output_i = indices_.main.lf_outer[item_i];
748 lf_graph.add_link(lf_reduce.output(output_i),
749 *graph_outputs[zone_info_.indices.outputs.main[output_i]]);
750 }
751 for (const int item_i : IndexRange(node_storage.generation_items.items_num)) {
752 const int output_i = indices_.generation.lf_outer[item_i];
753 lf_graph.add_link(lf_reduce.output(output_i),
754 *graph_outputs[zone_info_.indices.outputs.main[output_i]]);
755 }
756
757 /* All zone inputs are used for now. */
758 static bool static_true{true};
759 for (const int i : zone_info_.indices.outputs.input_usages) {
760 graph_outputs[i]->set_default_value(&static_true);
761 }
762
763 /* Handle usage outputs for border-links. A border-link is used if it's used by any of the
764 * iterations. */
765 eval_storage.or_function.emplace(eval_storage.total_iterations_num);
766 for (const int border_link_i : zone_.border_links.index_range()) {
767 lf::FunctionNode &lf_or = lf_graph.add_function(*eval_storage.or_function);
768 for (const int i : lf_body_nodes.index_range()) {
769 lf::FunctionNode &lf_body_node = *lf_body_nodes[i];
770 lf_graph.add_link(
771 lf_body_node.output(body_fn_.indices.outputs.border_link_usages[border_link_i]),
772 lf_or.input(i));
773 }
774 lf_graph.add_link(
775 lf_or.output(0),
776 *graph_outputs[zone_info_.indices.outputs.border_link_usages[border_link_i]]);
777 }
778 }
779
780 std::string input_name(const int i) const override
781 {
782 return zone_wrapper_input_name(zone_info_, zone_, inputs_, i);
783 }
784
785 std::string output_name(const int i) const override
786 {
787 return zone_wrapper_output_name(zone_info_, zone_, outputs_, i);
788 }
789};
790
794 : parent_(parent), eval_storage_(eval_storage)
795{
796 debug_name_ = "Reduce";
797
798 const auto &node_storage = *static_cast<NodeGeometryForeachGeometryElementOutput *>(
799 parent.output_bnode_.storage);
800
801 inputs_.reserve(eval_storage.total_iterations_num *
802 (node_storage.main_items.items_num + node_storage.generation_items.items_num));
803
804 for ([[maybe_unused]] const int i : eval_storage.lf_body_nodes.index_range()) {
805 /* Add parameters for main items. */
806 for (const int item_i : IndexRange(node_storage.main_items.items_num)) {
807 const NodeForeachGeometryElementMainItem &item = node_storage.main_items.items[item_i];
808 inputs_.append_as(item.name, CPPType::get<SocketValueVariant>(), lf::ValueUsage::Used);
809 }
810 /* Add parameters for generation items. */
811 for (const int item_i : IndexRange(node_storage.generation_items.items_num)) {
812 const NodeForeachGeometryElementGenerationItem &item =
813 node_storage.generation_items.items[item_i];
814 inputs_.append_as(item.name, CPPType::get<SocketValueVariant>(), lf::ValueUsage::Maybe);
815 }
816 }
817
818 /* Add output for main geometry. */
819 outputs_.append_as("Geometry", CPPType::get<SocketValueVariant>());
820 /* Add outputs for main items. */
821 for (const int item_i : IndexRange(node_storage.main_items.items_num)) {
822 const NodeForeachGeometryElementMainItem &item = node_storage.main_items.items[item_i];
823 outputs_.append_as(item.name, CPPType::get<SocketValueVariant>());
824 }
825 /* Add outputs for generation items. */
826 for (const int item_i : IndexRange(node_storage.generation_items.items_num)) {
827 const NodeForeachGeometryElementGenerationItem &item =
828 node_storage.generation_items.items[item_i];
829 outputs_.append_as(item.name, CPPType::get<SocketValueVariant>());
830 }
831}
832
834static std::optional<AttrDomain> get_foreach_attribute_propagation_target_domain(
835 const GeometryComponent::Type component_type)
836{
837 switch (component_type) {
838 case GeometryComponent::Type::Mesh:
839 case GeometryComponent::Type::PointCloud:
840 return AttrDomain::Point;
841 case GeometryComponent::Type::Curve:
842 return AttrDomain::Curve;
843 case GeometryComponent::Type::Instance:
844 return AttrDomain::Instance;
845 case GeometryComponent::Type::GreasePencil:
846 return AttrDomain::Layer;
847 default:
848 break;
849 }
850 return std::nullopt;
851}
852
854 const lf::Context &context) const
855{
856 const auto &node_storage = *static_cast<NodeGeometryForeachGeometryElementOutput *>(
857 parent_.output_bnode_.storage);
858
859 this->handle_main_items_and_geometry(params, context);
860 if (node_storage.generation_items.items_num == 0) {
861 return;
862 }
863 this->handle_generation_items(params, context);
864}
865
867 lf::Params &params, const lf::Context &context) const
868{
869 auto &user_data = *static_cast<GeoNodesUserData *>(context.user_data);
870 const auto &node_storage = *static_cast<NodeGeometryForeachGeometryElementOutput *>(
871 parent_.output_bnode_.storage);
872 const int body_main_outputs_num = node_storage.main_items.items_num +
873 node_storage.generation_items.items_num;
874
875 const int main_geometry_output = 0;
876 if (params.output_was_set(main_geometry_output)) {
877 /* Done already. */
878 return;
879 }
880
881 GeometrySet output_geometry = eval_storage_.main_geometry;
882
883 for (const int item_i : IndexRange(node_storage.main_items.items_num)) {
884 const NodeForeachGeometryElementMainItem &item = node_storage.main_items.items[item_i];
885 const eNodeSocketDatatype socket_type = item.socket_type;
886 const CPPType *base_cpp_type = bke::socket_type_to_geo_nodes_base_cpp_type(socket_type);
887 if (!base_cpp_type) {
888 continue;
889 }
890 const bke::AttrType cd_type = bke::cpp_type_to_attribute_type(*base_cpp_type);
891
892 /* Compute output attribute name for this item. */
893 const std::string attribute_name = bke::hash_to_anonymous_attribute_name(
894 user_data.call_data->self_object()->id.name,
895 user_data.compute_context->hash(),
896 parent_.output_bnode_.identifier,
897 item.identifier);
898
899 /* Create a new output attribute for the current item on each iteration component. */
900 for (const ForeachElementComponent &component_info : eval_storage_.components) {
901 MutableAttributeAccessor attributes = component_info.attributes_for_write(output_geometry);
902 const int domain_size = attributes.domain_size(component_info.id.domain);
903 const IndexMask mask = component_info.field_evaluator->get_evaluated_selection_as_mask();
904
905 /* Actually create the attribute. */
907 attribute_name, component_info.id.domain, cd_type);
908
909 /* Fill the elements of the attribute that we didn't iterate over because they were not
910 * selected. */
911 IndexMaskMemory memory;
912 const IndexMask inverted_mask = mask.complement(IndexRange(domain_size), memory);
913 base_cpp_type->value_initialize_indices(attribute.span.data(), inverted_mask);
914
915 /* Copy the values from each iteration into the attribute. */
916 mask.foreach_index([&](const int i, const int pos) {
917 const int lf_param_index = pos * body_main_outputs_num + item_i;
918 SocketValueVariant &value_variant = params.get_input<SocketValueVariant>(lf_param_index);
919 const void *value = value_variant.ensure_type(*base_cpp_type);
920 base_cpp_type->copy_construct(value, attribute.span[i]);
921 });
922
923 attribute.finish();
924 }
925
926 /* Output the field for the anonymous attribute. */
927 auto attribute_field = bke::AttributeFieldInput::from(
928 attribute_name,
929 *base_cpp_type,
931 parent_.output_bnode_.output_socket(parent_.indices_.main.bsocket_outer[item_i])));
932 params.set_output(1 + item_i, SocketValueVariant::from(std::move(attribute_field)));
933 }
934
935 /* Output the original geometry with potentially additional attributes. */
936 params.set_output(main_geometry_output, SocketValueVariant::from(std::move(output_geometry)));
937}
938
940 lf::Params &params, const lf::Context &context) const
941{
942 const auto &node_storage = *static_cast<NodeGeometryForeachGeometryElementOutput *>(
943 parent_.output_bnode_.storage);
944
945 const int first_valid_item_i = this->handle_invalid_generation_items(params);
946 if (first_valid_item_i == node_storage.generation_items.items_num) {
947 return;
948 }
949 this->handle_generation_item_groups(params, context, first_valid_item_i);
950}
951
953 lf::Params &params) const
954{
955 const auto &node_storage = *static_cast<NodeGeometryForeachGeometryElementOutput *>(
956 parent_.output_bnode_.storage);
957
958 int item_i = 0;
959 /* Handle invalid generation items that come before a geometry. */
960 for (; item_i < node_storage.generation_items.items_num; item_i++) {
962 node_storage.generation_items.items[item_i];
963 const eNodeSocketDatatype socket_type = item.socket_type;
964 if (socket_type == SOCK_GEOMETRY) {
965 break;
966 }
967 const int lf_socket_i = parent_.indices_.generation.lf_outer[item_i];
968 if (!params.output_was_set(lf_socket_i)) {
969 const int bsocket_i = parent_.indices_.generation.bsocket_outer[item_i];
971 params, lf_socket_i, parent_.zone_.output_node()->output_socket(bsocket_i));
972 }
973 }
974 return item_i;
975}
976
978 lf::Params &params, const lf::Context &context, const int first_valid_item_i) const
979{
980 const auto &node_storage = *static_cast<NodeGeometryForeachGeometryElementOutput *>(
981 parent_.output_bnode_.storage);
982 int previous_geometry_item_i = first_valid_item_i;
983 /* Iterate over all groups. A group starts with a geometry socket followed by an arbitrary number
984 * of non-geometry sockets. */
985 for (const int item_i :
986 IndexRange::from_begin_end(first_valid_item_i + 1, node_storage.generation_items.items_num))
987 {
989 node_storage.generation_items.items[item_i];
990 const eNodeSocketDatatype socket_type = item.socket_type;
991 if (socket_type == SOCK_GEOMETRY) {
993 params,
994 context,
995 previous_geometry_item_i,
996 IndexRange::from_begin_end(previous_geometry_item_i + 1, item_i));
997 previous_geometry_item_i = item_i;
998 }
999 }
1001 params,
1002 context,
1003 previous_geometry_item_i,
1004 IndexRange::from_begin_end(previous_geometry_item_i + 1,
1005 node_storage.generation_items.items_num));
1006}
1007
1009 lf::Params &params,
1010 const lf::Context &context,
1011 const int geometry_item_i,
1012 const IndexRange generation_items_range) const
1013{
1014 auto &user_data = *static_cast<GeoNodesUserData *>(context.user_data);
1015 const auto &node_storage = *static_cast<NodeGeometryForeachGeometryElementOutput *>(
1016 parent_.output_bnode_.storage);
1017 const int body_main_outputs_num = node_storage.main_items.items_num +
1018 node_storage.generation_items.items_num;
1019
1020 /* Handle the case when the output is not needed or the inputs have not been computed yet. */
1022 params, context, geometry_item_i, generation_items_range))
1023 {
1024 return;
1025 }
1026
1027 /* TODO: Get propagation info from input, but that's not necessary for correctness for now. */
1028 bke::AttributeFilter attribute_filter;
1029
1030 const int bodies_num = eval_storage_.lf_body_nodes.size();
1031 Array<GeometrySet> geometries(bodies_num + 1);
1032
1033 /* Create attribute names for the outputs. */
1034 Array<std::string> attribute_names(generation_items_range.size());
1035 for (const int i : generation_items_range.index_range()) {
1036 const int item_i = generation_items_range[i];
1038 node_storage.generation_items.items[item_i];
1039 attribute_names[i] = bke::hash_to_anonymous_attribute_name(
1040 user_data.call_data->self_object()->id.name,
1041 user_data.compute_context->hash(),
1042 parent_.output_bnode_.identifier,
1043 item.identifier);
1044 }
1045
1046 for (const ForeachElementComponent &component_info : eval_storage_.components) {
1047 const AttributeAccessor src_attributes = component_info.input_attributes();
1048
1049 /* These are the attributes we need to propagate from the original input geometry. */
1050 struct NameWithType {
1051 StringRef name;
1052 bke::AttrType type;
1053 };
1054 Vector<NameWithType> attributes_to_propagate;
1055 src_attributes.foreach_attribute([&](const bke::AttributeIter &iter) {
1056 if (iter.data_type == bke::AttrType::String) {
1057 return;
1058 }
1059 if (attribute_filter.allow_skip(iter.name)) {
1060 return;
1061 }
1062 attributes_to_propagate.append({iter.name, iter.data_type});
1063 });
1064 Map<StringRef, GVArray> cached_adapted_src_attributes;
1065
1066 const IndexMask mask = component_info.field_evaluator->get_evaluated_selection_as_mask();
1067
1068 /* Add attributes for each field on the geometry created by each iteration. */
1069 mask.foreach_index([&](const int element_i, const int local_body_i) {
1070 const int body_i = component_info.body_nodes_range[local_body_i];
1071 const int geometry_param_i = body_i * body_main_outputs_num +
1072 parent_.indices_.generation.lf_inner[geometry_item_i];
1073 GeometrySet &geometry = geometries[body_i];
1074 geometry = params.extract_input<SocketValueVariant>(geometry_param_i).extract<GeometrySet>();
1075
1076 for (const GeometryComponent::Type dst_component_type :
1077 {GeometryComponent::Type::Mesh,
1078 GeometryComponent::Type::PointCloud,
1079 GeometryComponent::Type::Curve,
1080 GeometryComponent::Type::GreasePencil,
1081 GeometryComponent::Type::Instance})
1082 {
1083 if (!geometry.has(dst_component_type)) {
1084 continue;
1085 }
1086 GeometryComponent &dst_component = geometry.get_component_for_write(dst_component_type);
1087 MutableAttributeAccessor dst_attributes = *dst_component.attributes_for_write();
1088
1089 /* Determine the domain that we propagate the input attribute to. Technically, this is only
1090 * a single value for the entire geometry, but we can't optimize for that yet. */
1091 const std::optional<AttrDomain> propagation_domain =
1093 if (!propagation_domain) {
1094 continue;
1095 }
1096
1097 /* Propagate attributes from the input geometry. */
1098 for (const NameWithType &name_with_type : attributes_to_propagate) {
1099 const StringRef name = name_with_type.name;
1100 const bke::AttrType data_type = name_with_type.type;
1101 if (src_attributes.is_builtin(name) && !dst_attributes.is_builtin(name)) {
1102 continue;
1103 }
1104 if (dst_attributes.contains(name)) {
1105 /* Attributes created in the zone shouldn't be overridden. */
1106 continue;
1107 }
1108 /* Get the source attribute adapted to the iteration domain. */
1109 const GVArray &src_attribute = cached_adapted_src_attributes.lookup_or_add_cb(
1110 name, [&]() {
1111 bke::GAttributeReader attribute = src_attributes.lookup(name);
1112 return src_attributes.adapt_domain(
1113 *attribute, attribute.domain, component_info.id.domain);
1114 });
1115 if (!src_attribute) {
1116 continue;
1117 }
1118 const CPPType &type = src_attribute.type();
1119 BUFFER_FOR_CPP_TYPE_VALUE(type, element_value);
1120 src_attribute.get_to_uninitialized(element_i, element_value);
1121
1122 /* Actually create the attribute. */
1123 bke::GSpanAttributeWriter dst_attribute =
1124 dst_attributes.lookup_or_add_for_write_only_span(
1125 name, *propagation_domain, data_type);
1126 type.fill_assign_n(element_value, dst_attribute.span.data(), dst_attribute.span.size());
1127 dst_attribute.finish();
1128
1129 type.destruct(element_value);
1130 }
1131 }
1132
1133 /* Create an attribute for each field that corresponds to the current geometry. */
1134 for (const int local_item_i : generation_items_range.index_range()) {
1135 const int item_i = generation_items_range[local_item_i];
1137 node_storage.generation_items.items[item_i];
1138 const AttrDomain capture_domain = AttrDomain(item.domain);
1139 const int field_param_i = body_i * body_main_outputs_num +
1140 parent_.indices_.generation.lf_inner[item_i];
1141 GField field = params.get_input<SocketValueVariant>(field_param_i).copy_as<GField>();
1142
1143 if (capture_domain == AttrDomain::Instance) {
1144 if (geometry.has_instances()) {
1146 geometry.get_component_for_write(GeometryComponent::Type::Instance),
1147 attribute_names[local_item_i],
1148 capture_domain,
1149 field);
1150 }
1151 }
1152 else {
1154 for (const GeometryComponent::Type component_type :
1155 {GeometryComponent::Type::Mesh,
1156 GeometryComponent::Type::PointCloud,
1157 GeometryComponent::Type::Curve,
1158 GeometryComponent::Type::GreasePencil})
1159 {
1160 if (sub_geometry.has(component_type)) {
1162 sub_geometry.get_component_for_write(component_type),
1163 attribute_names[local_item_i],
1164 capture_domain,
1165 field);
1166 }
1167 }
1168 });
1169 }
1170 }
1171 });
1172 }
1173
1174 /* The last geometry contains the edit data from the main geometry. */
1175 GeometrySet &edit_data_geometry = geometries.last();
1176 edit_data_geometry = eval_storage_.main_geometry;
1177 edit_data_geometry.keep_only({GeometryComponent::Type::Edit});
1178
1179 /* Join the geometries from all iterations into a single one. */
1180 GeometrySet joined_geometry = geometry::join_geometries(geometries, attribute_filter);
1181
1182 /* Output the joined geometry. */
1183 params.set_output(parent_.indices_.generation.lf_outer[geometry_item_i],
1184 SocketValueVariant::from(std::move(joined_geometry)));
1185
1186 /* Output the anonymous attribute fields. */
1187 for (const int local_item_i : generation_items_range.index_range()) {
1188 const int item_i = generation_items_range[local_item_i];
1190 node_storage.generation_items.items[item_i];
1191 const eNodeSocketDatatype socket_type = item.socket_type;
1192 const CPPType &base_cpp_type = *bke::socket_type_to_geo_nodes_base_cpp_type(socket_type);
1193 const StringRef attribute_name = attribute_names[local_item_i];
1194 auto attribute_field = bke::AttributeFieldInput::from(
1195 attribute_name,
1196 base_cpp_type,
1198 parent_.output_bnode_.output_socket(2 + node_storage.main_items.items_num + item_i)));
1199 params.set_output(parent_.indices_.generation.lf_outer[item_i],
1200 bke::SocketValueVariant::from(std::move(attribute_field)));
1201 }
1202}
1203
1205 lf::Params &params,
1206 const lf::Context & /*context*/,
1207 const int geometry_item_i,
1208 const IndexRange generation_items_range) const
1209{
1210 const auto &node_storage = *static_cast<NodeGeometryForeachGeometryElementOutput *>(
1211 parent_.output_bnode_.storage);
1212 const int body_main_outputs_num = node_storage.main_items.items_num +
1213 node_storage.generation_items.items_num;
1214
1215 const int geometry_output_param = parent_.indices_.generation.lf_outer[geometry_item_i];
1216
1217 if (params.output_was_set(geometry_output_param)) {
1218 /* Done already. */
1219 return false;
1220 }
1221 const lf::ValueUsage geometry_output_usage = params.get_output_usage(geometry_output_param);
1222 if (geometry_output_usage == lf::ValueUsage::Unused) {
1223 /* Output dummy values. */
1224 const int start_bsocket_i = parent_.indices_.generation.bsocket_outer[geometry_item_i];
1225 for (const int i : IndexRange(1 + generation_items_range.size())) {
1226 const bNodeSocket &bsocket = parent_.output_bnode_.output_socket(start_bsocket_i + i);
1227 set_default_value_for_output_socket(params, geometry_output_param + i, bsocket);
1228 }
1229 return false;
1230 }
1231 bool any_output_used = false;
1232 for (const int i : IndexRange(1 + generation_items_range.size())) {
1233 const lf::ValueUsage usage = params.get_output_usage(geometry_output_param + i);
1234 if (usage == lf::ValueUsage::Used) {
1235 any_output_used = true;
1236 break;
1237 }
1238 }
1239 if (!any_output_used) {
1240 /* Only execute below if we are sure that the output is actually needed. */
1241 return false;
1242 }
1243 const int bodies_num = eval_storage_.lf_body_nodes.size();
1244
1245 /* Check if all inputs are available, and request them if not. */
1246 bool has_missing_input = false;
1247 for (const int body_i : IndexRange(bodies_num)) {
1248 const int offset = body_i * body_main_outputs_num +
1249 parent_.indices_.generation.lf_inner[geometry_item_i];
1250 for (const int i : IndexRange(1 + generation_items_range.size())) {
1251 const bool is_available = params.try_get_input_data_ptr_or_request(offset + i) != nullptr;
1252 if (!is_available) {
1253 has_missing_input = true;
1254 }
1255 }
1256 }
1257 if (has_missing_input) {
1258 /* Come back when all inputs are available. */
1259 return false;
1260 }
1261 return true;
1262}
1263
1265 const bNodeTree &btree,
1266 const bke::bNodeTreeZone &zone,
1267 ZoneBuildInfo &zone_info,
1268 const ZoneBodyFunction &body_fn)
1269{
1271 btree, zone, zone_info, body_fn);
1272}
1273
1274} // namespace blender::nodes
Low-level operations for curves.
Low-level operations for grease pencil.
#define BUFFER_FOR_CPP_TYPE_VALUE(type, variable_name)
volatile int lock
__forceinline float extract(const int4 &b)
Definition binning.cpp:27
#define ELEM(...)
#define output
int64_t size() const
Definition BLI_array.hh:267
const T & last(const int64_t n=0) const
Definition BLI_array.hh:307
IndexRange index_range() const
Definition BLI_array.hh:371
static const CPPType & get()
void value_initialize_indices(void *ptr, const IndexMask &mask) const
void fill_assign_n(const void *value, void *dst, int64_t n) const
void copy_construct(const void *src, void *dst) const
void destruct(void *ptr) const
const ComputeContextHash & hash() const
void get_to_uninitialized(int64_t index, void *r_value) const
constexpr int64_t size() const
static constexpr IndexRange from_begin_end(const int64_t begin, const int64_t end)
constexpr IndexRange()=default
static constexpr IndexRange from_begin_size(const int64_t begin, const int64_t size)
constexpr IndexRange index_range() const
destruct_ptr< T > construct(Args &&...args)
Value & lookup_or_add_cb(const Key &key, const CreateValueF &create_value)
Definition BLI_map.hh:620
T & construct(Args &&...args)
constexpr int64_t size() const
Definition BLI_span.hh:256
int64_t index_of_try(const Key &key) const
int64_t size() const
IndexRange index_range() const
void add_new(const Key &key)
int64_t size() const
void append(const T &value)
IndexRange index_range() const
Span< T > as_span() const
void foreach_attribute(const FunctionRef< void(const AttributeIter &)> fn) const
bool contains(StringRef name) const
GVArray adapt_domain(const GVArray &varray, const AttrDomain from_domain, const AttrDomain to_domain) const
GAttributeReader lookup(const StringRef name) const
int domain_size(const AttrDomain domain) const
bool is_builtin(const StringRef name) const
static fn::GField from(std::string name, const CPPType &type, std::optional< std::string > socket_inspection_name=std::nullopt)
MutableAttributeAccessor attributes_for_write()
virtual std::optional< MutableAttributeAccessor > attributes_for_write()
GSpanAttributeWriter lookup_or_add_for_write_only_span(StringRef name, AttrDomain domain, AttrType data_type)
void * allocate_single(const CPPType &type)
std::unique_ptr< LoggedZoneGraphs > logged_zone_graphs
const bNode * output_node() const
bke::CurvesGeometry & strokes_for_write()
const bke::CurvesGeometry & strokes() const
void execute_node(const lf::FunctionNode &node, lf::Params &params, const lf::Context &context) const override
Vector< const lf::FunctionNode * > get_nodes_with_side_effects(const lf::Context &context) const override
void execute_impl(lf::Params &params, const lf::Context &context) const override
std::optional< Array< GeometrySet > > try_extract_element_geometries(const GeometrySet &main_geometry, const ForeachElementComponentID &id, const IndexMask &mask, const bke::AttributeFilter &attribute_filter) const
void initialize_execution_graph(lf::Params &params, ForeachGeometryElementEvalStorage &eval_storage, const NodeGeometryForeachGeometryElementOutput &node_storage) const
void prepare_components(lf::Params &params, ForeachGeometryElementEvalStorage &eval_storage, const NodeGeometryForeachGeometryElementOutput &node_storage) const
LazyFunctionForForeachGeometryElementZone(const bNodeTree &btree, const bke::bNodeTreeZone &zone, ZoneBuildInfo &zone_info, const ZoneBodyFunction &body_fn)
void build_graph_contents(ForeachGeometryElementEvalStorage &eval_storage, const NodeGeometryForeachGeometryElementOutput &node_storage, Span< lf::GraphInputSocket * > graph_inputs, Span< lf::GraphOutputSocket * > graph_outputs) const
static SocketValueVariant from(T &&value)
linear_allocator::ChunkedList< WarningWithNode > node_warnings
#define main()
#define storage(slot, qualifiers)
#define attribute(slot)
#define layer
bool try_capture_field_on_geometry(MutableAttributeAccessor attributes, const fn::FieldContext &field_context, const StringRef name, AttrDomain domain, const fn::Field< bool > &selection, const fn::GField &field)
const CPPType * socket_type_to_geo_nodes_base_cpp_type(eNodeSocketDatatype type)
Definition node.cc:5969
AttrType cpp_type_to_attribute_type(const CPPType &type)
std::string hash_to_anonymous_attribute_name(Args &&...args)
constexpr ParallelGrainSize grain_size(int grain_size)
Array< bke::Instances * > extract_instances(const bke::Instances &instances, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
Array< GreasePencil * > extract_greasepencil_layer_points(const GreasePencil &grease_pencil, int layer_i, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
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)
Array< Mesh * > extract_mesh_faces(const Mesh &mesh, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
Array< Mesh * > extract_mesh_vertices(const Mesh &mesh, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
Array< Curves * > extract_curves(const Curves &curves, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
Array< Curves * > extract_curves_points(const Curves &curves, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
Array< GreasePencil * > extract_greasepencil_layers(const GreasePencil &grease_pencil, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
Array< GreasePencil * > extract_greasepencil_layer_curves(const GreasePencil &grease_pencil, int layer_i, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
Array< PointCloud * > extract_pointcloud_points(const PointCloud &pointcloud, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
Array< Mesh * > extract_mesh_edges(const Mesh &mesh, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
static std::optional< AttrDomain > get_foreach_attribute_propagation_target_domain(const GeometryComponent::Type component_type)
void initialize_zone_wrapper(const bNodeTreeZone &zone, ZoneBuildInfo &zone_info, const ZoneBodyFunction &body_fn, const bool expose_all_reference_sets, Vector< lf::Input > &r_inputs, Vector< lf::Output > &r_outputs)
bool should_log_verbose_in_context(const GeoNodesUserData &user_data, const ComputeContextHash hash)
std::string make_anonymous_attribute_socket_inspection_string(const bNodeSocket &socket)
void set_default_value_for_output_socket(lf::Params &params, const int lf_index, const bNodeSocket &bsocket)
std::string zone_wrapper_output_name(const ZoneBuildInfo &zone_info, const bNodeTreeZone &zone, const Span< lf::Output > outputs, const int lf_socket_i)
LazyFunction & build_foreach_geometry_element_zone_lazy_function(ResourceScope &scope, const bNodeTree &btree, const bke::bNodeTreeZone &zone, ZoneBuildInfo &zone_info, const ZoneBodyFunction &body_fn)
std::string zone_wrapper_input_name(const ZoneBuildInfo &zone_info, const bNodeTreeZone &zone, const Span< lf::Input > inputs, const int lf_socket_i)
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
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
T * DEG_get_original(T *id)
NodeForeachGeometryElementInputItem * items
NodeForeachGeometryElementInputItems input_items
NodeForeachGeometryElementGenerationItems generation_items
NodeForeachGeometryElementMainItems main_items
bke::bNodeTreeRuntime * runtime
bool allow_skip(const StringRef name) const
void keep_only(Span< GeometryComponent::Type > component_types)
GeometryComponent & get_component_for_write(GeometryComponent::Type component_type)
const GreasePencil * get_grease_pencil() const
Vector< const GeometryComponent * > get_components() const
bool has(const GeometryComponent::Type component_type) const
const Curves * get_curves() const
const Instances * get_instances() const
const PointCloud * get_pointcloud() const
const Mesh * get_mesh() const
std::optional< Array< SocketValueVariant > > element_geometries
MutableAttributeAccessor attributes_for_write(GeometrySet &geometry) const
std::optional< LazyFunctionForReduceForeachGeometryElement > reduce_function
std::optional< ForeachGeometryElementZoneSideEffectProvider > side_effect_provider
std::optional< ForeachGeometryElementNodeExecuteWrapper > body_execute_wrapper
const GeoNodesSideEffectNodes * side_effect_nodes
MultiValueMap< std::pair< ComputeContextHash, int32_t >, int > iterations_by_iteration_zone
LazyFunctionForReduceForeachGeometryElement(const LazyFunctionForForeachGeometryElementZone &parent, ForeachGeometryElementEvalStorage &eval_storage)
void handle_main_items_and_geometry(lf::Params &params, const lf::Context &context) const
void handle_generation_items_group(lf::Params &params, const lf::Context &context, int geometry_item_i, IndexRange generation_items_range) const
void handle_generation_item_groups(lf::Params &params, const lf::Context &context, int first_valid_item_i) const
void execute_impl(lf::Params &params, const lf::Context &context) const override
bool handle_generation_items_group_lazyness(lf::Params &params, const lf::Context &context, int geometry_item_i, IndexRange generation_items_range) const
void handle_generation_items(lf::Params &params, const lf::Context &context) const
struct blender::nodes::ZoneFunctionIndices::@342054057300321050315260123310012173322070035365 inputs