Blender V5.3
geometry_nodes_lazy_function.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
22
23#include "NOD_geo_viewer.hh"
24#include "NOD_geometry_exec.hh"
29#include "NOD_multi_function.hh"
32
33#include "BLI_array_utils.hh"
35#include "BLI_bit_span_ops.hh"
36#include "BLI_lazy_threading.hh"
37#include "BLI_map.hh"
38#include "BLI_stack.hh"
39
40#include "DNA_ID.h"
41
45#include "BKE_geometry_set.hh"
46#include "BKE_grease_pencil.hh"
47#include "BKE_lib_id.hh"
48#include "BKE_library.hh"
50#include "BKE_node_runtime.hh"
55#include "BKE_scene.hh"
57
58#include "ED_node.hh"
59
61
63
65
66#include "list_function_eval.hh"
68
69#include <fmt/format.h>
70#include <iostream>
71#include <sstream>
72
73namespace blender::nodes {
74
75using bke::bNodeTreeZone;
76using bke::bNodeTreeZones;
77using bke::SocketValueVariant;
78using bke::node_tree_reference_lifetimes::ReferenceLifetimesInfo;
79using bke::node_tree_reference_lifetimes::ReferenceSetInfo;
81
87 Vector<lf::Input> &r_inputs,
88 Vector<lf::Output> &r_outputs,
89 MutableSpan<int> r_lf_index_by_bsocket)
90{
91 const bool is_muted = node.is_muted();
92 const lf::ValueUsage input_usage = lf::ValueUsage::Used;
93 for (const bNodeSocket *socket : node.input_sockets()) {
94 if (!socket->is_available()) {
95 continue;
96 }
97 if (!socket->typeinfo->geometry_nodes_default_value) {
98 continue;
99 }
100 const CPPType *type;
101 if (socket->is_multi_input() && !is_muted) {
103 }
104 else {
106 }
107 r_lf_index_by_bsocket[socket->index_in_tree()] = r_inputs.append_and_get_index_as(
108 socket->name, *type, input_usage);
109 }
110 for (const bNodeSocket *socket : node.output_sockets()) {
111 if (!socket->is_available()) {
112 continue;
113 }
114 if (!socket->typeinfo->geometry_nodes_default_value) {
115 continue;
116 }
117 r_lf_index_by_bsocket[socket->index_in_tree()] = r_outputs.append_and_get_index_as(
118 socket->name, CPPType::get<SocketValueVariant>());
119 }
120}
121
125class LazyFunctionForGeometryNode : public LazyFunction {
126 private:
127 const bNode &node_;
128 const GeometryNodesLazyFunctionGraphInfo &own_lf_graph_info_;
134 Vector<bool> is_attribute_output_bsocket_;
135
136 public:
138 GeometryNodesLazyFunctionGraphInfo &own_lf_graph_info)
139 : node_(node),
140 own_lf_graph_info_(own_lf_graph_info),
141 is_attribute_output_bsocket_(node.output_sockets().size(), false)
142 {
143 BLI_assert(node.typeinfo->geometry_node_execute != nullptr);
144 debug_name_ = node.name;
146 node, inputs_, outputs_, own_lf_graph_info.mapping.lf_index_by_bsocket);
147
148 const NodeDeclaration &node_decl = *node.declaration();
149 const rl::RelationsInNode *relations = node_decl.reference_lifetime_relations();
150 if (relations == nullptr) {
151 return;
152 }
153 bool has_anonymous_attribute_output = false;
154 for (const int output_i : node_decl.outputs.index_range()) {
155 const SocketDeclaration *socket_decl = node_decl.outputs[output_i];
156 if (socket_decl->is_anonymous_attribute_output) {
157 const bNodeSocket &output = node.output_socket(output_i);
158 has_anonymous_attribute_output = true;
159 is_attribute_output_bsocket_[output_i] = true;
160 const int lf_index = inputs_.append_and_get_index_as("Output Used", CPPType::get<bool>());
161 own_lf_graph_info.mapping
162 .lf_input_index_for_output_bsocket_usage[output.index_in_all_outputs()] = lf_index;
163 }
164 }
165 if (has_anonymous_attribute_output) {
166 /* Inputs are only used when an output is used that is not just outputting an anonymous
167 * attribute field. */
168 for (lf::Input &input : inputs_) {
169 input.usage = lf::ValueUsage::Maybe;
170 }
171 }
172
173 Vector<const bNodeSocket *> handled_data_outputs;
174 for (const rl::DataPropagation &relation : relations->data_propagations) {
175 const bNodeSocket &output_bsocket = node.output_socket(relation.to_output);
176 if (output_bsocket.is_available() && !handled_data_outputs.contains(&output_bsocket)) {
177 handled_data_outputs.append(&output_bsocket);
178 const int lf_index = inputs_.append_and_get_index_as(
179 "Propagate to Output", CPPType::get<GeometryNodesReferenceSet>());
180 own_lf_graph_info.mapping
181 .lf_input_index_for_reference_set_for_output[output_bsocket.index_in_all_outputs()] =
182 lf_index;
183 }
184 }
185 }
186
187 void execute_impl(lf::Params &params, const lf::Context &context) const override
188 {
189 const ScopedNodeTimer node_timer{context, node_};
190
191 GeoNodesUserData *user_data = dynamic_cast<GeoNodesUserData *>(context.user_data);
192 BLI_assert(user_data != nullptr);
193
194 bool used_non_attribute_output_exists = false;
195 for (const int output_bsocket_index : node_.output_sockets().index_range()) {
196 const bNodeSocket &output_bsocket = node_.output_socket(output_bsocket_index);
197 const int lf_index =
198 own_lf_graph_info_.mapping.lf_index_by_bsocket[output_bsocket.index_in_tree()];
199 if (lf_index == -1) {
200 continue;
201 }
202 const lf::ValueUsage output_usage = params.get_output_usage(lf_index);
203 if (output_usage == lf::ValueUsage::Unused) {
204 continue;
205 }
206 if (is_attribute_output_bsocket_[output_bsocket_index]) {
207 if (params.output_was_set(lf_index)) {
208 continue;
209 }
210 this->output_anonymous_attribute_field(params, *user_data, lf_index, output_bsocket);
211 }
212 else {
213 if (output_usage == lf::ValueUsage::Used) {
214 used_non_attribute_output_exists = true;
215 }
216 }
217 }
218
219 if (!used_non_attribute_output_exists) {
220 /* Only attribute outputs are used currently, no need to evaluate the full node and its
221 * inputs. */
222 return;
223 }
224
225 bool missing_input = false;
226 for (const int lf_index : inputs_.index_range()) {
227 if (params.try_get_input_data_ptr_or_request(lf_index) == nullptr) {
228 missing_input = true;
229 }
230 }
231 if (missing_input) {
232 /* Wait until all inputs are available. */
233 return;
234 }
235
236 auto get_anonymous_attribute_name = [&](const int i) {
237 return this->anonymous_attribute_name_for_output(*user_data, i);
238 };
239
240 GeoNodeExecParams geo_params{
241 node_,
242 params,
243 context,
244 own_lf_graph_info_.mapping.lf_input_index_for_output_bsocket_usage,
245 own_lf_graph_info_.mapping.lf_input_index_for_reference_set_for_output,
246 get_anonymous_attribute_name};
247
248 node_.typeinfo->geometry_node_execute(geo_params);
249 }
250
251 std::string input_name(const int index) const override
252 {
253 for (const bNodeSocket *bsocket : node_.output_sockets()) {
254 {
255 const int lf_index =
256 own_lf_graph_info_.mapping
257 .lf_input_index_for_output_bsocket_usage[bsocket->index_in_all_outputs()];
258 if (index == lf_index) {
259 return StringRef("Use Output '") + bsocket->name + "'";
260 }
261 }
262 {
263 const int lf_index =
264 own_lf_graph_info_.mapping
265 .lf_input_index_for_reference_set_for_output[bsocket->index_in_all_outputs()];
266 if (index == lf_index) {
267 return StringRef("Propagate to '") + bsocket->name + "'";
268 }
269 }
270 }
271 return inputs_[index].debug_name;
272 }
273
274 std::string output_name(const int index) const override
275 {
276 return outputs_[index].debug_name;
277 }
278
279 void output_anonymous_attribute_field(lf::Params &params,
280 const GeoNodesUserData &user_data,
281 const int lf_index,
282 const bNodeSocket &socket) const
283 {
284 std::string attribute_name = this->anonymous_attribute_name_for_output(user_data,
285 socket.index());
286 std::string socket_inspection_name = make_anonymous_attribute_socket_inspection_string(socket);
287
288 void *r_value = params.get_output_data_ptr(lf_index);
290 r_value,
291 GField::from_input<AttributeFieldInput>(std::move(attribute_name),
292 *socket.typeinfo->base_cpp_type,
293 std::move(socket_inspection_name)));
294 params.output_set(lf_index);
295 }
296
298 const int output_index) const
299 {
301 user_data.compute_context->hash(),
302 node_.identifier,
303 node_.output_socket(output_index).identifier);
304 }
305};
306
311class LazyFunctionForMultiInput : public LazyFunction {
312 public:
314
316 {
317 debug_name_ = "Multi Input";
318 BLI_assert(socket.is_multi_input());
319 for (const bNodeLink *link : socket.directly_linked_links()) {
320 if (link->is_muted() || !link->fromsock->is_available() ||
321 link->fromnode->is_dangling_reroute())
322 {
323 continue;
324 }
325 inputs_.append({"Input", CPPType::get<SocketValueVariant>()});
326 this->links.append(link);
327 }
328 outputs_.append({"Output", CPPType::get<GeoNodesMultiInput<SocketValueVariant>>()});
329 }
330
331 void execute_impl(lf::Params &params, const lf::Context & /*context*/) const override
332 {
333 void *output_ptr = params.get_output_data_ptr(0);
334 auto &values = *new (output_ptr) GeoNodesMultiInput<SocketValueVariant>();
335 for (const int i : inputs_.index_range()) {
336 values.values.append(params.extract_input<SocketValueVariant>(i));
337 }
338 params.output_set(0);
339 }
340};
341
345class LazyFunctionForRerouteNode : public LazyFunction {
346 public:
348 {
349 debug_name_ = "Reroute";
350 inputs_.append({"Input", CPPType::get<SocketValueVariant>()});
351 outputs_.append({"Output", CPPType::get<SocketValueVariant>()});
352 }
353
354 void execute_impl(lf::Params &params, const lf::Context & /*context*/) const override
355 {
356 void *input_value = params.try_get_input_data_ptr(0);
357 void *output_value = params.get_output_data_ptr(0);
358 BLI_assert(input_value != nullptr);
359 BLI_assert(output_value != nullptr);
360 const CPPType &type = *inputs_[0].type;
361 type.move_construct(input_value, output_value);
362 params.output_set(0);
363 }
364};
365
371class LazyFunctionForUndefinedNode : public LazyFunction {
372 const bNode &node_;
373
374 public:
376 : node_(node)
377 {
378 debug_name_ = "Undefined";
379 Vector<lf::Input> dummy_inputs;
380 lazy_function_interface_from_node(node, dummy_inputs, outputs_, r_lf_index_by_bsocket);
381 }
382
383 void execute_impl(lf::Params &params, const lf::Context & /*context*/) const override
384 {
386 }
387};
388
394
396 const int lf_index,
397 const bNodeSocket &bsocket)
398{
399 void *output_value = params.get_output_data_ptr(lf_index);
400 construct_socket_default_value(*bsocket.typeinfo, output_value);
401 params.output_set(lf_index);
402}
403
404void set_default_remaining_node_outputs(lf::Params &params, const bNode &node)
405{
406 const bNodeTree &ntree = node.owner_tree();
407 const Span<int> lf_index_by_bsocket =
409 for (const bNodeSocket *bsocket : node.output_sockets()) {
410 const int lf_index = lf_index_by_bsocket[bsocket->index_in_tree()];
411 if (lf_index == -1) {
412 continue;
413 }
414 if (params.output_was_set(lf_index)) {
415 continue;
416 }
417 set_default_value_for_output_socket(params, lf_index, *bsocket);
418 }
419}
420
422{
423 return make_anonymous_attribute_socket_inspection_string(socket.owner_node().label_or_name(),
424 socket.name);
425}
427 StringRef socket_name)
428{
429 return fmt::format(fmt::runtime(TIP_("\"{}\" from {}")), socket_name, node_name);
430}
431
433 const MultiFunction &fn,
434 const Span<SocketValueVariant *> input_values,
435 const Span<SocketValueVariant *> output_values,
436 GeoNodesUserData *user_data)
437{
438 /* In this case, the multi-function is evaluated directly. */
439 const IndexMask mask(1);
440 mf::ParamsBuilder params{fn, &mask};
441 mf::ContextBuilder context;
442 context.user_data(user_data);
443
444 for (const int i : input_values.index_range()) {
445 SocketValueVariant &input_variant = *input_values[i];
446 const mf::ParamType param_type = fn.param_type(params.next_param_index());
447 const CPPType &cpp_type = param_type.data_type().single_type();
448 const void *value = input_variant.ensure_type(cpp_type);
449 params.add_readonly_single_input(GPointer{cpp_type, value});
450 }
451 for (const int i : output_values.index_range()) {
452 if (output_values[i] == nullptr) {
453 params.add_ignored_single_output("");
454 continue;
455 }
456 SocketValueVariant &output_variant = *output_values[i];
457 const mf::ParamType param_type = fn.param_type(params.next_param_index());
458 const CPPType &cpp_type = param_type.data_type().single_type();
459 void *value = output_variant.allocate_single(cpp_type);
460 params.add_uninitialized_single_output(GMutableSpan{cpp_type, value, 1});
461 }
462 fn.prepare_for_execution();
463 fn.call(mask, params, context);
464}
465
467 const MultiFunction &fn,
468 const std::shared_ptr<MultiFunction> &owned_fn,
469 const Span<SocketValueVariant *> input_values,
470 const Span<SocketValueVariant *> output_values)
471{
472 /* Convert all inputs into fields, so that they can be used as input in the new field. */
473 Vector<GField> input_fields;
474 for (const int i : input_values.index_range()) {
475 input_fields.append(input_values[i]->extract<GField>());
476 }
477
478 /* Construct the new field node. */
480 if (owned_fn) {
481 operation = fn::FieldOperation::from(owned_fn, std::move(input_fields));
482 }
483 else {
484 operation = fn::FieldOperation::from(fn, std::move(input_fields));
485 }
486
487 /* Store the new fields in the output. */
488 for (const int i : output_values.index_range()) {
489 if (output_values[i] == nullptr) {
490 continue;
491 }
492 *output_values[i] = bke::SocketValueVariant::from(GField{operation, i});
493 }
494}
495
501 const MultiFunction &fn,
502 const std::shared_ptr<MultiFunction> &owned_fn,
503 const Span<SocketValueVariant *> input_values,
504 const Span<SocketValueVariant *> output_values,
505 GeoNodesUserData *user_data,
506 std::string &r_error_message)
507{
508 /* Check input types which determine how the function is evaluated. */
509 bool any_input_is_field = false;
510 bool any_input_is_volume_grid = false;
511 bool any_input_is_list = false;
512 for (const int i : input_values.index_range()) {
513 const SocketValueVariant &value = *input_values[i];
514 if (value.is_context_dependent_field()) {
515 any_input_is_field = true;
516 }
517 else if (value.is_volume_grid()) {
518 any_input_is_volume_grid = true;
519 }
520 else if (value.is_list()) {
521 any_input_is_list = true;
522 }
523 }
524
525 if (any_input_is_volume_grid) {
527 fn, input_values, output_values, r_error_message);
528 }
529 if (any_input_is_list) {
531 fn, owned_fn, input_values, output_values, user_data, r_error_message);
532 }
533 if (any_input_is_field) {
534 execute_multi_function_on_value_variant__field(fn, owned_fn, input_values, output_values);
535 return true;
536 }
537 execute_multi_function_on_value_variant__single(fn, input_values, output_values, user_data);
538 return true;
539}
540
541std::optional<SocketValueVariant> implicitly_convert_socket_value(
542 const bke::bNodeSocketType &from_type,
543 const SocketValueVariant &from_value,
545{
546 if (from_type.type == to_type.type) {
547 return from_value;
548 }
550 const CPPType *from_cpp_type = from_type.base_cpp_type;
551 const CPPType *to_cpp_type = to_type.base_cpp_type;
552 if (!from_cpp_type || !to_cpp_type) {
553 return std::nullopt;
554 }
555 if (conversions.is_convertible(*from_cpp_type, *to_cpp_type)) {
556 const MultiFunction &multi_fn = *conversions.get_conversion_multi_function(
557 mf::DataType::ForSingle(*from_cpp_type), mf::DataType::ForSingle(*to_cpp_type));
558 SocketValueVariant input_variant = from_value;
559 SocketValueVariant output_variant;
560 std::string error_message;
562 multi_fn, {&input_variant}, {&output_variant}, nullptr, error_message))
563 {
564 return std::nullopt;
565 }
566 return output_variant;
567 }
568 return std::nullopt;
569}
570
571class LazyFunctionForImplicitConversion : public LazyFunction {
572 private:
573 const MultiFunction &fn_;
574 const bke::bNodeSocketType &dst_type_;
575
576 public:
577 LazyFunctionForImplicitConversion(const MultiFunction &fn, const bke::bNodeSocketType &dst_type)
578 : fn_(fn), dst_type_(dst_type)
579 {
580 debug_name_ = "Convert";
581 inputs_.append_as("From", CPPType::get<SocketValueVariant>());
582 outputs_.append_as("To", CPPType::get<SocketValueVariant>());
583 }
584
585 void execute_impl(lf::Params &params, const lf::Context & /*context*/) const override
586 {
587 SocketValueVariant *from_value = params.try_get_input_data_ptr<SocketValueVariant>(0);
588 SocketValueVariant *to_value = new (params.get_output_data_ptr(0)) SocketValueVariant();
589 BLI_assert(from_value != nullptr);
590 BLI_assert(to_value != nullptr);
591 std::string error_message;
593 fn_, {from_value}, {to_value}, nullptr, error_message))
594 {
595 std::destroy_at(to_value);
596 construct_socket_default_value(dst_type_, to_value);
597 }
598 params.output_set(0);
599 }
600};
601
604 ResourceScope &scope)
605{
606 if (!from_type.geometry_nodes_default_value || !to_type.geometry_nodes_default_value) {
607 return nullptr;
608 }
609 if (from_type.type == to_type.type) {
610 return &scope.construct<LazyFunctionForRerouteNode>();
611 }
613 const CPPType &from_base_type = *from_type.base_cpp_type;
614 const CPPType &to_base_type = *to_type.base_cpp_type;
615 if (conversions.is_convertible(from_base_type, to_base_type)) {
616 const MultiFunction &multi_fn = *conversions.get_conversion_multi_function(
617 mf::DataType::ForSingle(from_base_type), mf::DataType::ForSingle(to_base_type));
618 return &scope.construct<LazyFunctionForImplicitConversion>(multi_fn, to_type);
619 }
620 return nullptr;
621}
622
629class LazyFunctionForMutedNode : public LazyFunction {
630 private:
631 const bNode &node_;
632 Span<int> lf_index_by_bsocket_;
633 Array<const bNodeSocket *> input_by_output_index_;
634
635 public:
637 : node_(node), lf_index_by_bsocket_(r_lf_index_by_bsocket)
638 {
639 debug_name_ = "Muted";
640 lazy_function_interface_from_node(node, inputs_, outputs_, r_lf_index_by_bsocket);
641 for (lf::Input &fn_input : inputs_) {
642 fn_input.usage = lf::ValueUsage::Maybe;
643 }
644
645 for (lf::Input &fn_input : inputs_) {
646 fn_input.usage = lf::ValueUsage::Unused;
647 }
648
649 input_by_output_index_.reinitialize(node.output_sockets().size());
650 input_by_output_index_.fill(nullptr);
651 for (const bNodeInternalLink &internal_link : node.internal_links()) {
652 const int input_i = r_lf_index_by_bsocket[internal_link.in->index_in_tree()];
653 const int output_i = r_lf_index_by_bsocket[internal_link.out->index_in_tree()];
654 if (ELEM(-1, input_i, output_i)) {
655 continue;
656 }
657 input_by_output_index_[internal_link.out->index()] = internal_link.in;
658 inputs_[input_i].usage = lf::ValueUsage::Maybe;
659 }
660 }
661
662 void execute_impl(lf::Params &params, const lf::Context & /*context*/) const override
663 {
664 for (const bNodeSocket *output_bsocket : node_.output_sockets()) {
665 const int lf_output_index = lf_index_by_bsocket_[output_bsocket->index_in_tree()];
666 if (lf_output_index == -1) {
667 continue;
668 }
669 if (params.output_was_set(lf_output_index)) {
670 continue;
671 }
672 if (params.get_output_usage(lf_output_index) != lf::ValueUsage::Used) {
673 continue;
674 }
675 const bNodeSocket *input_bsocket = input_by_output_index_[output_bsocket->index()];
676 if (input_bsocket == nullptr) {
677 set_default_value_for_output_socket(params, lf_output_index, *output_bsocket);
678 continue;
679 }
680 const int lf_input_index = lf_index_by_bsocket_[input_bsocket->index_in_tree()];
681 const SocketValueVariant *input_value =
682 params.try_get_input_data_ptr_or_request<SocketValueVariant>(lf_input_index);
683 if (!input_value) {
684 /* Wait for value to be available. */
685 continue;
686 }
687 if (std::optional<SocketValueVariant> converted_value = implicitly_convert_socket_value(
688 *input_bsocket->typeinfo, *input_value, *output_bsocket->typeinfo))
689 {
690 params.set_output(lf_output_index, std::move(*converted_value));
691 continue;
692 }
693 set_default_value_for_output_socket(params, lf_output_index, *output_bsocket);
694 }
695 }
696};
697
701class LazyFunctionForMultiFunctionNode : public LazyFunction {
702 private:
703 const bNode &node_;
704 const NodeMultiFunctions::Item fn_item_;
705
706 public:
709 MutableSpan<int> r_lf_index_by_bsocket)
710 : node_(node), fn_item_(std::move(fn_item))
711 {
712 BLI_assert(fn_item_.fn != nullptr);
713 debug_name_ = node.name;
714 lazy_function_interface_from_node(node, inputs_, outputs_, r_lf_index_by_bsocket);
715 }
716
717 void execute_impl(lf::Params &params, const lf::Context &context) const override
718 {
719 auto &user_data = *static_cast<GeoNodesUserData *>(context.user_data);
720
721 Vector<SocketValueVariant *> input_values(inputs_.size());
722 Vector<SocketValueVariant *> output_values(outputs_.size());
723 for (const int i : inputs_.index_range()) {
724 input_values[i] = params.try_get_input_data_ptr<SocketValueVariant>(i);
725 }
726 for (const int i : outputs_.index_range()) {
727 if (params.get_output_usage(i) != lf::ValueUsage::Unused) {
728 output_values[i] = new (params.get_output_data_ptr(i)) SocketValueVariant();
729 }
730 else {
731 output_values[i] = nullptr;
732 }
733 }
734
735 bke::NodeComputeContext eval_compute_context{
736 user_data.compute_context, node_.identifier, &node_.owner_tree()};
737 GeoNodesUserData eval_user_data = user_data;
738 eval_user_data.compute_context = &eval_compute_context;
739
740 std::string error_message;
742 fn_item_.owned_fn,
743 input_values,
744 output_values,
745 &eval_user_data,
746 error_message))
747 {
749 if (!error_message.empty()) {
750 const auto &user_data = *static_cast<GeoNodesUserData *>(context.user_data);
751 const auto &local_user_data = *static_cast<GeoNodesLocalUserData *>(
752 context.local_user_data);
753 if (eval_log::NodeTreeLogger *tree_logger = local_user_data.try_get_tree_logger(user_data))
754 {
755 tree_logger->node_warnings.append(
756 *tree_logger->allocator,
757 {node_.identifier, {NodeWarningType::Error, error_message}});
758 }
759 }
760 return;
761 }
762
763 for (const int i : outputs_.index_range()) {
764 if (params.get_output_usage(i) != lf::ValueUsage::Unused) {
765 params.output_set(i);
766 }
767 }
768 }
769};
770
775class LazyFunctionForImplicitInput : public LazyFunction {
776 private:
780 std::function<void(void *)> init_fn_;
781
782 public:
783 LazyFunctionForImplicitInput(const CPPType &type, std::function<void(void *)> init_fn)
784 : init_fn_(std::move(init_fn))
785 {
786 debug_name_ = "Input";
787 outputs_.append({"Output", type});
788 }
789
790 void execute_impl(lf::Params &params, const lf::Context & /*context*/) const override
791 {
792 void *value = params.get_output_data_ptr(0);
793 init_fn_(value);
794 params.output_set(0);
795 }
796};
797
798template<typename T>
799 requires std::is_integral_v<T> || std::is_floating_point_v<T>
800class LazyFunctionForImplicitSceneFrame : public LazyFunction {
801 public:
803 {
804 debug_name_ = "Scene Time";
805 outputs_.append({"Scene Time", CPPType::get<SocketValueVariant>()});
806 }
807
808 void execute_impl(lf::Params &params, const lf::Context &context) const override
809 {
810 const GeoNodesUserData &user_data = *static_cast<const GeoNodesUserData *>(context.user_data);
811 const Depsgraph *depsgraph = nullptr;
812 if (user_data.call_data->modifier_data) {
813 depsgraph = user_data.call_data->modifier_data->depsgraph;
814 }
815 else if (user_data.call_data->operator_data) {
816 depsgraph = user_data.call_data->operator_data->depsgraphs->active;
817 }
818 if (!depsgraph) {
819 params.set_output(0, SocketValueVariant(T(0)));
820 return;
821 }
822 const Scene *scene = DEG_get_input_scene(depsgraph);
823 const float scene_ctime = BKE_scene_ctime_get(scene);
824 params.set_output(0, SocketValueVariant(T(scene_ctime)));
825 }
826};
827
828class LazyFunctionForImplicitSelfObject : public LazyFunction {
829 public:
831 {
832 debug_name_ = "Self Object";
833 outputs_.append({"Self Object", CPPType::get<SocketValueVariant>()});
834 }
835
836 void execute_impl(lf::Params &params, const lf::Context &context) const override
837 {
838 const GeoNodesUserData &user_data = *static_cast<const GeoNodesUserData *>(context.user_data);
839 const Object *self_object = user_data.call_data->self_object();
840 params.set_output(0, SocketValueVariant::from(const_cast<Object *>(self_object)));
841 }
842};
843
848class LazyFunctionForViewerNode : public LazyFunction {
849 private:
850 const bNode &bnode_;
851 Span<int> lf_index_by_bsocket_;
852
853 public:
854 LazyFunctionForViewerNode(const bNode &bnode, MutableSpan<int> r_lf_index_by_bsocket)
855 : bnode_(bnode), lf_index_by_bsocket_(r_lf_index_by_bsocket)
856 {
857 debug_name_ = "Viewer";
858 lazy_function_interface_from_node(bnode, inputs_, outputs_, r_lf_index_by_bsocket);
859 }
860
861 void execute_impl(lf::Params &params, const lf::Context &context) const override
862 {
863 const auto &user_data = *static_cast<GeoNodesUserData *>(context.user_data);
864 const auto &local_user_data = *static_cast<GeoNodesLocalUserData *>(context.local_user_data);
865 eval_log::NodeTreeLogger *tree_logger = local_user_data.try_get_tree_logger(user_data);
866 if (tree_logger == nullptr) {
867 return;
868 }
869
870 LinearAllocator<> &allocator = *tree_logger->allocator;
871
872 const NodeGeometryViewer &storage = *static_cast<const NodeGeometryViewer *>(bnode_.storage);
873
874 Vector<bke::SocketValueVariant *> values(storage.items_num, nullptr);
875
876 for (const int i : IndexRange(storage.items_num)) {
877 const bNodeSocket &bsocket = bnode_.input_socket(i);
878 const int param_index = lf_index_by_bsocket_[bsocket.index_in_tree()];
879 values[i] = params.try_get_input_data_ptr<bke::SocketValueVariant>(param_index);
880 }
881
882 auto log = allocator.construct<eval_log::ViewerNodeLog>();
883 geo_viewer_node_log(bnode_, values, *log);
884 tree_logger->viewer_node_logs.append(allocator, {bnode_.identifier, std::move(log)});
885 }
886};
887
891class LazyFunctionForViewerInputUsage : public LazyFunction {
892 private:
893 const lf::FunctionNode &lf_viewer_node_;
894
895 public:
896 LazyFunctionForViewerInputUsage(const lf::FunctionNode &lf_viewer_node)
897 : lf_viewer_node_(lf_viewer_node)
898 {
899 debug_name_ = "Viewer Input Usage";
900 outputs_.append_as("Viewer is Used", CPPType::get<bool>());
901 }
902
903 void execute_impl(lf::Params &params, const lf::Context &context) const override
904 {
905 GeoNodesUserData *user_data = dynamic_cast<GeoNodesUserData *>(context.user_data);
906 BLI_assert(user_data != nullptr);
907 if (!user_data->call_data->side_effect_nodes) {
908 params.set_output<bool>(0, false);
909 return;
910 }
911 const ComputeContextHash &context_hash = user_data->compute_context->hash();
912 const Span<const lf::FunctionNode *> nodes_with_side_effects =
913 user_data->call_data->side_effect_nodes->nodes_by_context.lookup(context_hash);
914
915 const bool viewer_is_used = nodes_with_side_effects.contains(&lf_viewer_node_);
916 params.set_output(0, viewer_is_used);
917 }
918};
919
921static bool gizmo_is_used(const GeoNodesUserData &user_data, const lf::FunctionNode &lf_gizmo_node)
922{
923 if (!user_data.call_data->side_effect_nodes) {
924 return false;
925 }
926 const Span<const lf::FunctionNode *> nodes_with_side_effects =
928 user_data.compute_context->hash());
929 const bool is_used = nodes_with_side_effects.contains(&lf_gizmo_node);
930 return is_used;
931}
932
938class LazyFunctionForGizmoNode : public LazyFunction {
939 private:
940 const bNode &bnode_;
941
942 public:
943 const lf::FunctionNode *self_node = nullptr;
945
946 LazyFunctionForGizmoNode(const bNode &bnode, MutableSpan<int> r_lf_index_by_bsocket)
947 : bnode_(bnode)
948 {
949 debug_name_ = bnode.name;
950 const bNodeSocket &gizmo_socket = bnode.input_socket(0);
951 /* Create inputs for every input of the multi-input socket to make sure that they can be
952 * logged. */
953 for (const bNodeLink *link : gizmo_socket.directly_linked_links()) {
954 if (!link->is_used()) {
955 continue;
956 }
957 if (link->fromnode->is_dangling_reroute()) {
958 continue;
959 }
960 inputs_.append_and_get_index_as(
961 gizmo_socket.identifier, CPPType::get<SocketValueVariant>(), lf::ValueUsage::Maybe);
962 gizmo_links.append(link);
963 }
964 for (const bNodeSocket *socket : bnode.input_sockets().drop_front(1)) {
965 r_lf_index_by_bsocket[socket->index_in_tree()] = inputs_.append_and_get_index_as(
966 socket->identifier, CPPType::get<SocketValueVariant>(), lf::ValueUsage::Maybe);
967 }
968 r_lf_index_by_bsocket[bnode.output_socket(0).index_in_tree()] =
969 outputs_.append_and_get_index_as("Transform", CPPType::get<SocketValueVariant>());
970 }
971
972 void execute_impl(lf::Params &params, const lf::Context &context) const override
973 {
974 const auto &user_data = *static_cast<GeoNodesUserData *>(context.user_data);
975 if (!gizmo_is_used(user_data, *this->self_node)) {
977 return;
978 }
979 if (!params.output_was_set(0)) {
981 GeometryComponentEditData &edit_data =
982 geometry.get_component_for_write<GeometryComponentEditData>();
983 edit_data.gizmo_edit_hints_ = std::make_unique<bke::GizmoEditHints>();
984 edit_data.gizmo_edit_hints_->gizmo_transforms.add(
985 {user_data.compute_context->hash(), bnode_.identifier}, float4x4::identity());
986 params.set_output(0, SocketValueVariant::from(std::move(geometry)));
987 }
988
989 /* Request all inputs so that their values can be logged. */
990 for (const int i : inputs_.index_range()) {
991 params.try_get_input_data_ptr_or_request(i);
992 }
993
994 const auto &local_user_data = *static_cast<GeoNodesLocalUserData *>(context.local_user_data);
995 if (eval_log::NodeTreeLogger *tree_logger = local_user_data.try_get_tree_logger(user_data)) {
996 tree_logger->evaluated_gizmo_nodes.append(*tree_logger->allocator, {bnode_.identifier});
997 }
998 }
999};
1000
1001class LazyFunctionForGizmoInputsUsage : public LazyFunction {
1002 private:
1003 const lf::FunctionNode *lf_gizmo_node_ = nullptr;
1004
1005 public:
1006 LazyFunctionForGizmoInputsUsage(const bNode &gizmo_node, const lf::FunctionNode &lf_gizmo_node)
1007 : lf_gizmo_node_(&lf_gizmo_node)
1008 {
1009 debug_name_ = gizmo_node.name;
1010 outputs_.append_as("Need Inputs", CPPType::get<bool>());
1011 }
1012
1013 void execute_impl(lf::Params &params, const lf::Context &context) const override
1014 {
1015 const auto &user_data = *static_cast<GeoNodesUserData *>(context.user_data);
1016 const bool is_used = gizmo_is_used(user_data, *lf_gizmo_node_);
1017 params.set_output(0, is_used);
1018 }
1019};
1020
1021class LazyFunctionForSimulationInputsUsage : public LazyFunction {
1022 private:
1023 const bNode *output_bnode_;
1024
1025 public:
1026 LazyFunctionForSimulationInputsUsage(const bNode &output_bnode) : output_bnode_(&output_bnode)
1027 {
1028 debug_name_ = "Simulation Inputs Usage";
1029 outputs_.append_as("Need Input Inputs", CPPType::get<bool>());
1030 outputs_.append_as("Need Output Inputs", CPPType::get<bool>());
1031 }
1032
1033 void execute_impl(lf::Params &params, const lf::Context &context) const override
1034 {
1035 const GeoNodesUserData &user_data = *static_cast<GeoNodesUserData *>(context.user_data);
1036 const GeoNodesCallData &call_data = *user_data.call_data;
1037 if (!call_data.simulation_params) {
1038 this->set_default_outputs(params);
1039 return;
1040 }
1041 const std::optional<FoundNestedNodeID> found_id = find_nested_node_id(
1042 user_data, output_bnode_->identifier);
1043 if (!found_id) {
1044 this->set_default_outputs(params);
1045 return;
1046 }
1047 if (found_id->is_in_loop) {
1048 this->set_default_outputs(params);
1049 return;
1050 }
1051 SimulationZoneBehavior *zone_behavior = call_data.simulation_params->get(found_id->id);
1052 if (!zone_behavior) {
1053 this->set_default_outputs(params);
1054 return;
1055 }
1056
1057 bool solve_contains_side_effect = false;
1058 if (call_data.side_effect_nodes) {
1059 const Span<const lf::FunctionNode *> side_effect_nodes =
1060 call_data.side_effect_nodes->nodes_by_context.lookup(user_data.compute_context->hash());
1061 solve_contains_side_effect = !side_effect_nodes.is_empty();
1062 }
1063
1064 params.set_output(0, std::holds_alternative<sim_input::PassThrough>(zone_behavior->input));
1065 params.set_output(
1066 1,
1067 solve_contains_side_effect ||
1068 std::holds_alternative<sim_output::StoreNewState>(zone_behavior->output));
1069 }
1070
1071 void set_default_outputs(lf::Params &params) const
1072 {
1073 params.set_output(0, false);
1074 params.set_output(1, false);
1075 }
1076};
1077
1078class LazyFunctionForBakeInputsUsage : public LazyFunction {
1079 private:
1080 const bNode *bnode_;
1081
1082 public:
1083 LazyFunctionForBakeInputsUsage(const bNode &bnode) : bnode_(&bnode)
1084 {
1085 debug_name_ = "Bake Inputs Usage";
1086 outputs_.append_as("Used", CPPType::get<bool>());
1087 }
1088
1089 void execute_impl(lf::Params &params, const lf::Context &context) const override
1090 {
1091 const GeoNodesUserData &user_data = *static_cast<GeoNodesUserData *>(context.user_data);
1092 if (!user_data.call_data->bake_params) {
1093 this->set_default_outputs(params);
1094 return;
1095 }
1096 const std::optional<FoundNestedNodeID> found_id = find_nested_node_id(user_data,
1097 bnode_->identifier);
1098 if (!found_id) {
1099 this->set_default_outputs(params);
1100 return;
1101 }
1102 if (found_id->is_in_loop || found_id->is_in_simulation) {
1103 this->set_default_outputs(params);
1104 return;
1105 }
1106 BakeNodeBehavior *behavior = user_data.call_data->bake_params->get(found_id->id);
1107 if (!behavior) {
1108 this->set_default_outputs(params);
1109 return;
1110 }
1111 const bool need_inputs = std::holds_alternative<sim_output::PassThrough>(behavior->behavior) ||
1112 std::holds_alternative<sim_output::StoreNewState>(behavior->behavior);
1113 params.set_output(0, need_inputs);
1114 }
1115
1116 void set_default_outputs(lf::Params &params) const
1117 {
1118 params.set_output(0, false);
1119 }
1120};
1121
1124{
1125 if (const Set<ComputeContextHash> *contexts = user_data.call_data->verbose_log_contexts) {
1126 return contexts->contains(hash);
1127 }
1128 if (user_data.call_data->operator_data) {
1129 return false;
1130 }
1131 return true;
1132}
1133
1138class LazyFunctionForGroupNode : public LazyFunction {
1139 private:
1140 const bNode &group_node_;
1141 const GeometryNodesGroupFunction &group_lazy_function_;
1142 bool has_many_nodes_ = false;
1143
1144 struct Storage {
1145 void *group_storage = nullptr;
1146 };
1147
1148 public:
1150 const GeometryNodesLazyFunctionGraphInfo &group_lf_graph_info,
1151 GeometryNodesLazyFunctionGraphInfo &own_lf_graph_info)
1152 : group_node_(group_node), group_lazy_function_(group_lf_graph_info.function)
1153 {
1154 debug_name_ = group_node.name;
1155 allow_missing_requested_inputs_ = true;
1156
1157 /* This wrapper has the same interface as the actual underlying node group. */
1158 inputs_ = group_lf_graph_info.function.function->inputs();
1159 outputs_ = group_lf_graph_info.function.function->outputs();
1160
1161 has_many_nodes_ = group_lf_graph_info.num_inline_nodes_approximate > 1000;
1162
1163 /* Add a boolean input for every output bsocket that indicates whether that socket is used. */
1164 for (const int i : group_node.output_sockets().index_range()) {
1165 own_lf_graph_info.mapping.lf_input_index_for_output_bsocket_usage
1166 [group_node.output_socket(i).index_in_all_outputs()] =
1167 group_lf_graph_info.function.inputs.output_usages[i];
1168 }
1169
1170 /* Add an reference set input for every output geometry socket that can propagate data
1171 * from inputs. */
1172 for (const int i : group_lf_graph_info.function.inputs.references_to_propagate.geometry_outputs
1173 .index_range())
1174 {
1175 const int lf_index = group_lf_graph_info.function.inputs.references_to_propagate.range[i];
1176 const int output_index =
1177 group_lf_graph_info.function.inputs.references_to_propagate.geometry_outputs[i];
1178 const bNodeSocket &output_bsocket = group_node_.output_socket(output_index);
1179 own_lf_graph_info.mapping
1180 .lf_input_index_for_reference_set_for_output[output_bsocket.index_in_all_outputs()] =
1181 lf_index;
1182 }
1183 }
1184
1185 void execute_impl(lf::Params &params, const lf::Context &context) const override
1186 {
1187 const ScopedNodeTimer node_timer{context, group_node_};
1188 GeoNodesUserData *user_data = dynamic_cast<GeoNodesUserData *>(context.user_data);
1189 BLI_assert(user_data != nullptr);
1190 auto &local_user_data = *static_cast<GeoNodesLocalUserData *>(context.local_user_data);
1191
1192 if (user_data->is_stack_limit_reached()) {
1193 if (eval_log::NodeTreeLogger *tree_logger = local_user_data.try_get_tree_logger(*user_data))
1194 {
1195 tree_logger->node_warnings.append(
1196 *tree_logger->allocator,
1197 {group_node_.identifier,
1198 {NodeWarningType::Error, TIP_("Stack limit reached. Group node is ignored.")}});
1199 }
1200 for (const int i : group_lazy_function_.outputs.main.index_range()) {
1201 const bNodeSocket &socket = group_node_.output_socket(i);
1202 set_default_value_for_output_socket(params, group_lazy_function_.outputs.main[i], socket);
1203 }
1204 for (const int lf_output_i : group_lazy_function_.outputs.input_usages) {
1205 params.set_output(lf_output_i, false);
1206 }
1207 return;
1208 }
1209 if (has_many_nodes_) {
1210 /* If the called node group has many nodes, it's likely that executing it takes a while even
1211 * if every individual node is very small. */
1213 }
1214
1215 Storage *storage = static_cast<Storage *>(context.storage);
1216
1217 /* The compute context changes when entering a node group. */
1218 bke::GroupNodeComputeContext compute_context{
1219 user_data->compute_context, group_node_.identifier, &group_node_.owner_tree()};
1220
1221 GeoNodesUserData group_user_data = *user_data;
1222 group_user_data.compute_context = &compute_context;
1223 group_user_data.verbose_log = should_log_verbose_in_context(*user_data,
1224 compute_context.hash());
1225
1226 GeoNodesLocalUserData group_local_user_data{group_user_data};
1227 lf::Context group_context{storage->group_storage, &group_user_data, &group_local_user_data};
1228
1229 ScopedComputeContextTimer timer(group_context);
1230 group_lazy_function_.function->execute(params, group_context);
1231 }
1232
1233 void *init_storage(LinearAllocator<> &allocator) const override
1234 {
1235 Storage *s = allocator.construct<Storage>().release();
1236 s->group_storage = group_lazy_function_.function->init_storage(allocator);
1237 return s;
1238 }
1239
1240 void destruct_storage(void *storage) const override
1241 {
1242 Storage *s = static_cast<Storage *>(storage);
1243 group_lazy_function_.function->destruct_storage(s->group_storage);
1244 std::destroy_at(s);
1245 }
1246
1247 std::string name() const override
1248 {
1249 return fmt::format(
1250 fmt::runtime(TIP_("Group '{}' ({})")), group_node_.id->name + 2, group_node_.name);
1251 }
1252
1253 std::string input_name(const int i) const override
1254 {
1255 return group_lazy_function_.function->input_name(i);
1256 }
1257
1258 std::string output_name(const int i) const override
1259 {
1260 return group_lazy_function_.function->output_name(i);
1261 }
1262};
1263
1265{
1266 debug_name_ = "Logical Or";
1267 for ([[maybe_unused]] const int i : IndexRange(inputs_num)) {
1268 inputs_.append_as("Input", CPPType::get<bool>(), lf::ValueUsage::Maybe);
1269 }
1270 outputs_.append_as("Output", CPPType::get<bool>());
1271}
1272
1274 const lf::Context & /*context*/) const
1275{
1276 Vector<int, 16> unavailable_inputs;
1277 /* First check all inputs for available values without requesting more inputs. If any of the
1278 * available inputs is true already, the others don't have to be requested anymore. */
1279 for (const int i : inputs_.index_range()) {
1280 if (const bool *value = params.try_get_input_data_ptr<bool>(i)) {
1281 if (*value) {
1282 params.set_output(0, true);
1283 return;
1284 }
1285 }
1286 else {
1287 unavailable_inputs.append(i);
1288 }
1289 }
1290 if (unavailable_inputs.is_empty()) {
1291 params.set_output(0, false);
1292 return;
1293 }
1294 /* Request the next unavailable input. Note that a value might be available now even if it was
1295 * not available before, because it might have been computed in the mean-time. */
1296 for (const int i : unavailable_inputs) {
1297 if (const bool *value = params.try_get_input_data_ptr_or_request<bool>(i)) {
1298 if (*value) {
1299 params.set_output(0, true);
1300 return;
1301 }
1302 }
1303 else {
1304 /* The input has been requested and it's not available yet, so wait until it is ready. */
1305 return;
1306 }
1307 }
1308 /* All inputs were available now and all of them were false, so the final output is false. */
1309 params.set_output(0, false);
1310}
1311
1316class LazyFunctionForSwitchSocketUsage : public lf::LazyFunction {
1317 public:
1319 {
1320 debug_name_ = "Switch Socket Usage";
1321 inputs_.append_as("Condition", CPPType::get<SocketValueVariant>());
1322 outputs_.append_as("False", CPPType::get<bool>());
1323 outputs_.append_as("True", CPPType::get<bool>());
1324 }
1325
1326 void execute_impl(lf::Params &params, const lf::Context & /*context*/) const override
1327 {
1328 const SocketValueVariant &condition_variant = params.get_input<SocketValueVariant>(0);
1329 if (condition_variant.is_context_dependent_field()) {
1330 params.set_output(0, true);
1331 params.set_output(1, true);
1332 }
1333 else {
1334 const bool value = condition_variant.copy_as<bool>();
1335 params.set_output(0, !value);
1336 params.set_output(1, value);
1337 }
1338 }
1339};
1340
1341class LazyFunctionForEnableOutputSocketUsage : public lf::LazyFunction {
1342 public:
1344 {
1345 debug_name_ = "Enable Output Socket Usage";
1346 inputs_.append_as("Enable", CPPType::get<SocketValueVariant>());
1347 outputs_.append_as("Usage", CPPType::get<bool>());
1348 }
1349
1350 void execute_impl(lf::Params &params, const lf::Context & /*context*/) const override
1351 {
1352 const SocketValueVariant &keep_variant = params.get_input<SocketValueVariant>(0);
1353 if (keep_variant.is_single()) {
1354 if (keep_variant.copy_as<bool>() == true) {
1355 params.set_output(0, true);
1356 return;
1357 }
1358 }
1359 params.set_output(0, false);
1360 }
1361};
1362
1367class LazyFunctionForIndexSwitchSocketUsage : public lf::LazyFunction {
1368 public:
1370 {
1371 debug_name_ = "Index Switch Socket Usage";
1372 inputs_.append_as("Index", CPPType::get<SocketValueVariant>());
1373 for (const bNodeSocket *socket : bnode.input_sockets().drop_front(1)) {
1374 outputs_.append_as(socket->identifier, CPPType::get<bool>());
1375 }
1376 }
1377
1378 void execute_impl(lf::Params &params, const lf::Context & /*context*/) const override
1379 {
1380 const SocketValueVariant &index_variant = params.get_input<SocketValueVariant>(0);
1381 if (index_variant.is_context_dependent_field()) {
1382 for (const int i : outputs_.index_range()) {
1383 params.set_output(i, true);
1384 }
1385 }
1386 else {
1387 const int value = index_variant.copy_as<int>();
1388 for (const int i : outputs_.index_range()) {
1389 params.set_output(i, i == value);
1390 }
1391 }
1392 }
1393};
1394
1399class LazyFunctionForExtractingReferenceSet : public lf::LazyFunction {
1400 public:
1402 {
1403 debug_name_ = "Extract References";
1404 inputs_.append_as("Use", CPPType::get<bool>());
1405 inputs_.append_as("Value", CPPType::get<SocketValueVariant>(), lf::ValueUsage::Maybe);
1406 outputs_.append_as("References", CPPType::get<GeometryNodesReferenceSet>());
1407 }
1408
1409 void execute_impl(lf::Params &params, const lf::Context & /*context*/) const override
1410 {
1411 const bool use = params.get_input<bool>(0);
1412 if (!use) {
1413 params.set_output<GeometryNodesReferenceSet>(0, {});
1414 return;
1415 }
1416 const SocketValueVariant *value_variant =
1417 params.try_get_input_data_ptr_or_request<SocketValueVariant>(1);
1418 if (value_variant == nullptr) {
1419 /* Wait until the field is computed. */
1420 return;
1421 }
1422
1423 using namespace bke::socket_value_visitor;
1424 GeometryNodesReferenceSet references;
1425 auto scan_field = [&](const GField &field) {
1426 this->gather_references_from_field(field, references);
1427 return VisitParams::continue_check(true);
1428 };
1429 VisitParams visit_params;
1430 visit_params.check_non_editable = true;
1431 visit_params.ignore_non_geometry_instances = true;
1432 visit_params.check_GField = scan_field;
1433 check_recursive(*value_variant, visit_params);
1434
1435 params.set_output(0, std::move(references));
1436 }
1437
1439 GeometryNodesReferenceSet &r_references) const
1440 {
1441 Stack<fn::GFieldRef> fields_to_check;
1442 fields_to_check.push(field);
1443 while (!fields_to_check.is_empty()) {
1444 const fn::GFieldRef &field_to_check = fields_to_check.pop();
1445 const fn::FieldInputsPtr &field_inputs = field_to_check.field_inputs();
1446 if (field_inputs) {
1447 for (const fn::FieldInput &field_input : field_inputs->inputs) {
1448 field_input.foreach_recursive_field(
1449 [&](const GField &recursive_field) { fields_to_check.push(recursive_field); });
1450 if (const auto *attr_field_input = dynamic_cast<const AttributeFieldInput *>(
1451 &field_input))
1452 {
1453 const StringRef name = attr_field_input->attribute_name();
1455 if (!r_references.names) {
1456 r_references.names = std::make_shared<Set<std::string>>();
1457 }
1458 r_references.names->add_as(name);
1459 }
1460 }
1461 }
1462 }
1463 }
1464 }
1465};
1466
1471class LazyFunctionForJoinReferenceSets : public lf::LazyFunction {
1472 const int amount_;
1473
1474 public:
1475 LazyFunctionForJoinReferenceSets(const int amount) : amount_(amount)
1476 {
1477 debug_name_ = "Join Reference Sets";
1478 for ([[maybe_unused]] const int i : IndexRange(amount)) {
1479 inputs_.append_as("Use", CPPType::get<bool>());
1480 inputs_.append_as(
1481 "Reference Set", CPPType::get<GeometryNodesReferenceSet>(), lf::ValueUsage::Maybe);
1482 }
1483 outputs_.append_as("Reference Set", CPPType::get<GeometryNodesReferenceSet>());
1484 }
1485
1486 void execute_impl(lf::Params &params, const lf::Context & /*context*/) const override
1487 {
1489 bool set_is_missing = false;
1490 for (const int i : IndexRange(amount_)) {
1491 if (params.get_input<bool>(this->get_use_input(i))) {
1492 if (GeometryNodesReferenceSet *set =
1493 params.try_get_input_data_ptr_or_request<GeometryNodesReferenceSet>(
1494 this->get_reference_set_input(i)))
1495 {
1496 sets.append(set);
1497 }
1498 else {
1499 set_is_missing = true;
1500 }
1501 }
1502 }
1503 if (set_is_missing) {
1504 return;
1505 }
1506 GeometryNodesReferenceSet joined_set;
1507 if (sets.is_empty()) {
1508 /* Nothing to do. */
1509 }
1510 else if (sets.size() == 1) {
1511 joined_set.names = std::move(sets[0]->names);
1512 }
1513 else {
1514 joined_set.names = std::make_shared<Set<std::string>>();
1515 for (const GeometryNodesReferenceSet *set : sets) {
1516 if (set->names) {
1517 for (const std::string &name : *set->names) {
1518 joined_set.names->add(name);
1519 }
1520 }
1521 }
1522 }
1523 params.set_output(0, std::move(joined_set));
1524 }
1525
1526 int get_use_input(const int i) const
1527 {
1528 return 2 * i;
1529 }
1530
1531 int get_reference_set_input(const int i) const
1532 {
1533 return 2 * i + 1;
1534 }
1535
1539 static const LazyFunctionForJoinReferenceSets &get_cached(const int amount, ResourceScope &scope)
1540 {
1541 constexpr int cache_amount = 16;
1542 static std::array<LazyFunctionForJoinReferenceSets, cache_amount> cached_functions = get_cache(
1543 std::make_index_sequence<cache_amount>{});
1544 if (amount < cached_functions.size()) {
1545 return cached_functions[amount];
1546 }
1547
1548 return scope.construct<LazyFunctionForJoinReferenceSets>(amount);
1549 }
1550
1551 private:
1552 template<size_t... I>
1553 static std::array<LazyFunctionForJoinReferenceSets, sizeof...(I)> get_cache(
1554 std::index_sequence<I...> /*indices*/)
1555 {
1557 }
1558};
1559
1560class LazyFunctionForSimulationZone : public LazyFunction {
1561 private:
1562 const bNode &sim_output_bnode_;
1563 const LazyFunction &fn_;
1564
1565 public:
1566 LazyFunctionForSimulationZone(const bNode &sim_output_bnode, const LazyFunction &fn)
1567 : sim_output_bnode_(sim_output_bnode), fn_(fn)
1568 {
1569 debug_name_ = "Simulation Zone";
1570 inputs_ = fn.inputs();
1571 outputs_ = fn.outputs();
1572 }
1573
1574 void execute_impl(lf::Params &params, const lf::Context &context) const override
1575 {
1576 ScopedNodeTimer node_timer{context, sim_output_bnode_};
1577 GeoNodesUserData &user_data = *static_cast<GeoNodesUserData *>(context.user_data);
1578
1579 bke::SimulationZoneComputeContext compute_context{user_data.compute_context,
1580 sim_output_bnode_};
1581
1582 GeoNodesUserData zone_user_data = user_data;
1583 zone_user_data.compute_context = &compute_context;
1584 zone_user_data.verbose_log = should_log_verbose_in_context(user_data, compute_context.hash());
1585
1586 GeoNodesLocalUserData zone_local_user_data{zone_user_data};
1587 lf::Context zone_context{context.storage, &zone_user_data, &zone_local_user_data};
1588 fn_.execute(params, zone_context);
1589 }
1590
1591 void *init_storage(LinearAllocator<> &allocator) const override
1592 {
1593 return fn_.init_storage(allocator);
1594 }
1595
1596 void destruct_storage(void *storage) const override
1597 {
1598 fn_.destruct_storage(storage);
1599 }
1600
1601 std::string input_name(const int i) const override
1602 {
1603 return fn_.input_name(i);
1604 }
1605
1606 std::string output_name(const int i) const override
1607 {
1608 return fn_.output_name(i);
1609 }
1610};
1611
1612void report_from_multi_function(const mf::Context &context,
1613 NodeWarningType type,
1614 std::string message)
1615{
1616 if (auto *shader_nodes_user_data = dynamic_cast<ShaderNodesMultiFunctionUserData *>(
1617 context.user_data))
1618 {
1619 shader_nodes_user_data->warnings.append({type, std::move(message)});
1620 return;
1621 }
1622
1623 const auto *user_data = dynamic_cast<const GeoNodesUserData *>(context.user_data);
1624 if (!user_data) {
1625 return;
1626 }
1627 eval_log::NodesEvalLog *log = user_data->call_data->eval_log;
1628 if (!log) {
1629 return;
1630 }
1631 const bke::NodeComputeContext *node_context = nullptr;
1632 for (const ComputeContext *compute_context = user_data->compute_context; compute_context;
1633 compute_context = compute_context->parent())
1634 {
1635 node_context = dynamic_cast<const bke::NodeComputeContext *>(compute_context);
1636 if (node_context) {
1637 break;
1638 }
1639 }
1640 if (!node_context) {
1641 return;
1642 }
1643 const auto *tree_context = node_context->parent();
1644 if (!tree_context) {
1645 return;
1646 }
1647 eval_log::NodeTreeLogger &logger = log->get_local_tree_logger(*tree_context);
1648 logger.node_warnings.append(*logger.allocator,
1649 {node_context->node_id(), {type, std::move(message)}});
1650}
1651
1653
1691
1692static bool ignore_zone_bsocket(const bNodeSocket &bsocket)
1693{
1694 if (!bsocket.is_available()) {
1695 return true;
1696 }
1697 if (!bsocket.typeinfo->geometry_nodes_default_value) {
1698 /* These are typically extend sockets. */
1699 return true;
1700 }
1701 return false;
1702}
1703
1705 ZoneBuildInfo &zone_info,
1706 const ZoneBodyFunction &body_fn,
1707 const bool expose_all_reference_sets,
1708 Vector<lf::Input> &r_inputs,
1709 Vector<lf::Output> &r_outputs)
1710{
1711 for (const bNodeSocket *socket : zone.input_node()->input_sockets()) {
1712 if (ignore_zone_bsocket(*socket)) {
1713 continue;
1714 }
1715 zone_info.indices.inputs.main.append(r_inputs.append_and_get_index_as(
1716 socket->name, CPPType::get<SocketValueVariant>(), lf::ValueUsage::Maybe));
1717 }
1718
1719 for (const bNodeLink *link : zone.border_links) {
1720 zone_info.indices.inputs.border_links.append(r_inputs.append_and_get_index_as(
1721 link->fromsock->name, CPPType::get<SocketValueVariant>(), lf::ValueUsage::Maybe));
1722 }
1723
1724 for (const bNodeSocket *socket : zone.output_node()->output_sockets()) {
1725 if (ignore_zone_bsocket(*socket)) {
1726 continue;
1727 }
1728 zone_info.indices.inputs.output_usages.append(
1729 r_inputs.append_and_get_index_as("Usage", CPPType::get<bool>(), lf::ValueUsage::Maybe));
1730 zone_info.indices.outputs.main.append(
1732 }
1733
1734 for ([[maybe_unused]] const bNodeSocket *socket : zone.input_node()->input_sockets()) {
1735 if (ignore_zone_bsocket(*socket)) {
1736 continue;
1737 }
1738 zone_info.indices.outputs.input_usages.append(
1739 r_outputs.append_and_get_index_as("Usage", CPPType::get<bool>()));
1740 }
1741
1742 for ([[maybe_unused]] const bNodeLink *link : zone.border_links) {
1743 zone_info.indices.outputs.border_link_usages.append(
1744 r_outputs.append_and_get_index_as("Border Link Usage", CPPType::get<bool>()));
1745 }
1746
1747 /* Some zone types (e.g. the closure zone) do not expose all reference sets. */
1748 if (expose_all_reference_sets) {
1749 for (const auto item : body_fn.indices.inputs.reference_sets.items()) {
1750 zone_info.indices.inputs.reference_sets.add_new(
1751 item.key,
1752 r_inputs.append_and_get_index_as(
1753 "Reference Set", CPPType::get<GeometryNodesReferenceSet>(), lf::ValueUsage::Maybe));
1754 }
1755 }
1756}
1757
1758std::string zone_wrapper_input_name(const ZoneBuildInfo &zone_info,
1759 const bNodeTreeZone &zone,
1760 const Span<lf::Input> inputs,
1761 const int lf_socket_i)
1762{
1763 if (zone_info.indices.inputs.output_usages.contains(lf_socket_i)) {
1764 const int output_usage_i = lf_socket_i - zone_info.indices.inputs.output_usages.first();
1765 int current_valid_i = 0;
1766 for (const bNodeSocket *bsocket : zone.output_node()->output_sockets()) {
1767 if (ignore_zone_bsocket(*bsocket)) {
1768 continue;
1769 }
1770 if (current_valid_i == output_usage_i) {
1771 return "Usage: " + StringRef(bsocket->name);
1772 }
1773 current_valid_i++;
1774 }
1775 }
1776 return inputs[lf_socket_i].debug_name;
1777}
1778
1779std::string zone_wrapper_output_name(const ZoneBuildInfo &zone_info,
1780 const bNodeTreeZone &zone,
1781 const Span<lf::Output> outputs,
1782 const int lf_socket_i)
1783{
1784 if (zone_info.indices.outputs.input_usages.contains(lf_socket_i)) {
1785 const int input_usage_i = lf_socket_i - zone_info.indices.outputs.input_usages.first();
1786 int current_valid_i = 0;
1787 for (const bNodeSocket *bsocket : zone.input_node()->input_sockets()) {
1788 if (ignore_zone_bsocket(*bsocket)) {
1789 continue;
1790 }
1791 if (current_valid_i == input_usage_i) {
1792 return "Usage: " + StringRef(bsocket->name);
1793 }
1794 current_valid_i++;
1795 }
1796 }
1797 return outputs[lf_socket_i].debug_name;
1798}
1799
1804class GeometryNodesLazyFunctionLogger : public lf::GraphExecutor::Logger {
1805 private:
1806 const GeometryNodesLazyFunctionGraphInfo &lf_graph_info_;
1807
1808 public:
1810 : lf_graph_info_(lf_graph_info)
1811 {
1812 }
1813
1814 LoggingEnabledState get_logging_enabled_state(const lf::Context &context) const override
1815 {
1816 auto &user_data = *static_cast<GeoNodesUserData *>(context.user_data);
1817 return LoggingEnabledState{user_data.verbose_log};
1818 }
1819
1820 void log_socket_value(const lf::Socket &lf_socket,
1821 const GPointer value,
1822 const lf::Context &context) const override
1823 {
1824 auto &user_data = *static_cast<GeoNodesUserData *>(context.user_data);
1825 if (!user_data.verbose_log) {
1826 return;
1827 }
1828 auto &local_user_data = *static_cast<GeoNodesLocalUserData *>(context.local_user_data);
1829 eval_log::NodeTreeLogger *tree_logger = local_user_data.try_get_tree_logger(user_data);
1830 if (tree_logger == nullptr) {
1831 return;
1832 }
1833
1834 Span<const bNodeSocket *> bsockets = lf_graph_info_.mapping.bsockets_by_lf_socket_map.lookup(
1835 &lf_socket);
1836 if (bsockets.is_empty()) {
1837 return;
1838 }
1839 if (bsockets[0]->owner_node().is_group_input()) {
1840 /* Only log a group input once instead of for every group input node separately. */
1841 bsockets = bsockets.take_front(1);
1842 }
1843
1844 for (const bNodeSocket *bsocket : bsockets) {
1845 /* Avoid logging to some sockets when the same value will also be logged to a linked socket.
1846 * This reduces the number of logged values without losing information. */
1847 if (bsocket->is_input() && bsocket->is_directly_linked()) {
1848 continue;
1849 }
1850 const bNode &bnode = bsocket->owner_node();
1851 if (bnode.is_reroute()) {
1852 continue;
1853 }
1854 tree_logger->log_value(bsocket->owner_node(), *bsocket, value);
1855 }
1856 }
1857
1859
1860 void dump_when_outputs_are_missing(const lf::FunctionNode &node,
1861 Span<const lf::OutputSocket *> missing_sockets,
1862 const lf::Context &context) const override
1863 {
1864 std::lock_guard lock{dump_error_context_mutex};
1865
1866 GeoNodesUserData *user_data = dynamic_cast<GeoNodesUserData *>(context.user_data);
1867 BLI_assert(user_data != nullptr);
1868 user_data->compute_context->print_stack(std::cout, node.name());
1869 std::cout << "Missing outputs:\n";
1870 for (const lf::OutputSocket *socket : missing_sockets) {
1871 std::cout << " " << socket->name() << "\n";
1872 }
1873 }
1874
1875 void dump_when_input_is_set_twice(const lf::InputSocket &target_socket,
1876 const lf::OutputSocket &from_socket,
1877 const lf::Context &context) const override
1878 {
1879 std::lock_guard lock{dump_error_context_mutex};
1880
1881 std::stringstream ss;
1882 ss << from_socket.node().name() << ":" << from_socket.name() << " -> "
1883 << target_socket.node().name() << ":" << target_socket.name();
1884
1885 GeoNodesUserData *user_data = dynamic_cast<GeoNodesUserData *>(context.user_data);
1886 BLI_assert(user_data != nullptr);
1887 user_data->compute_context->print_stack(std::cout, ss.str());
1888 }
1889
1890 void log_before_node_execute(const lf::FunctionNode &node,
1891 const lf::Params & /*params*/,
1892 const lf::Context &context) const override
1893 {
1894 /* Enable this to see the threads that invoked a node. */
1895 if constexpr (false) {
1896 this->add_thread_id_debug_message(node, context);
1897 }
1898 }
1899
1900 void add_thread_id_debug_message(const lf::FunctionNode &node, const lf::Context &context) const
1901 {
1902 static std::atomic<int> thread_id_source = 0;
1903 static thread_local const int thread_id = thread_id_source.fetch_add(1);
1904 static thread_local const std::string thread_id_str = "Thread: " + std::to_string(thread_id);
1905
1906 const auto &user_data = *static_cast<GeoNodesUserData *>(context.user_data);
1907 const auto &local_user_data = *static_cast<GeoNodesLocalUserData *>(context.local_user_data);
1908 eval_log::NodeTreeLogger *tree_logger = local_user_data.try_get_tree_logger(user_data);
1909 if (tree_logger == nullptr) {
1910 return;
1911 }
1912
1913 /* Find corresponding node based on the socket mapping. */
1914 auto check_sockets = [&](const Span<const lf::Socket *> lf_sockets) {
1915 for (const lf::Socket *lf_socket : lf_sockets) {
1916 const Span<const bNodeSocket *> bsockets =
1917 lf_graph_info_.mapping.bsockets_by_lf_socket_map.lookup(lf_socket);
1918 if (!bsockets.is_empty()) {
1919 const bNodeSocket &bsocket = *bsockets[0];
1920 const bNode &bnode = bsocket.owner_node();
1921 tree_logger->debug_messages.append(*tree_logger->allocator,
1922 {bnode.identifier, thread_id_str});
1923 return true;
1924 }
1925 }
1926 return false;
1927 };
1928
1929 if (check_sockets(node.inputs().cast<const lf::Socket *>())) {
1930 return;
1931 }
1932 check_sockets(node.outputs().cast<const lf::Socket *>());
1933 }
1934};
1935
1941class GeometryNodesLazyFunctionSideEffectProvider : public lf::GraphExecutor::SideEffectProvider {
1942 private:
1943 Span<const lf::FunctionNode *> local_side_effect_nodes_;
1944
1945 public:
1947 Span<const lf::FunctionNode *> local_side_effect_nodes = {})
1948 : local_side_effect_nodes_(local_side_effect_nodes)
1949 {
1950 }
1951
1953 const lf::Context &context) const override
1954 {
1955 GeoNodesUserData *user_data = dynamic_cast<GeoNodesUserData *>(context.user_data);
1956 BLI_assert(user_data != nullptr);
1957 const GeoNodesCallData &call_data = *user_data->call_data;
1958 if (!call_data.side_effect_nodes) {
1959 return {};
1960 }
1961 const ComputeContextHash &context_hash = user_data->compute_context->hash();
1962 Vector<const lf::FunctionNode *> side_effect_nodes =
1963 call_data.side_effect_nodes->nodes_by_context.lookup(context_hash);
1964 side_effect_nodes.extend(local_side_effect_nodes_);
1965 return side_effect_nodes;
1966 }
1967};
1968
1975 private:
1976 const bNodeTree &btree_;
1977 const ReferenceLifetimesInfo &reference_lifetimes_;
1978 ResourceScope &scope_;
1979 NodeMultiFunctions &node_multi_functions_;
1980 std::shared_ptr<GeometryNodesLazyFunctionGraphInfo> lf_graph_info_;
1982 const bke::DataTypeConversions *conversions_;
1983
1987 Map<const bNode *, lf::Node *> simulation_inputs_usage_nodes_;
1988
1989 const bNodeTreeZones *tree_zones_;
1990 MutableSpan<ZoneBuildInfo> zone_build_infos_;
1991
1992 std::optional<BuildGraphParams> root_graph_build_params_;
1993
1998 Vector<lf::GraphInputSocket *> group_input_sockets_;
2003 Vector<lf::GraphOutputSocket *> standard_group_output_sockets_;
2008 Vector<lf::GraphInputSocket *> group_output_used_sockets_;
2013 Vector<lf::GraphOutputSocket *> group_input_usage_sockets_;
2018 Map<int, lf::GraphInputSocket *> reference_set_by_output_;
2019
2021
2022 public:
2024 std::shared_ptr<GeometryNodesLazyFunctionGraphInfo> &lf_graph_info)
2025 : btree_(*lf_graph_info->tree),
2026 reference_lifetimes_(*lf_graph_info->tree->runtime->reference_lifetimes_info),
2027 scope_(lf_graph_info->scope),
2028 node_multi_functions_(
2029 lf_graph_info->scope.construct<NodeMultiFunctions>(btree_, lf_graph_info->tree)),
2030 lf_graph_info_(lf_graph_info)
2031 {
2032 }
2033
2034 void build()
2035 {
2036 btree_.ensure_topology_cache();
2037 btree_.ensure_interface_cache();
2038
2039 mapping_ = &lf_graph_info_->mapping;
2040 conversions_ = &bke::get_implicit_type_conversions();
2041 tree_zones_ = btree_.zones();
2042
2043 this->initialize_mapping_arrays();
2044 this->build_zone_functions();
2045 this->build_root_graph();
2046 this->build_geometry_nodes_group_function();
2047 }
2048
2049 private:
2050 void initialize_mapping_arrays()
2051 {
2053 btree_.all_output_sockets().size());
2056 btree_.all_output_sockets().size());
2058 mapping_->lf_index_by_bsocket.reinitialize(btree_.all_sockets().size());
2059 mapping_->lf_index_by_bsocket.fill(-1);
2060 }
2061
2065 void build_zone_functions()
2066 {
2067 zone_build_infos_ = scope_.construct<Array<ZoneBuildInfo>>(tree_zones_->zones.size());
2068
2069 const Array<int> zone_build_order = this->compute_zone_build_order();
2070
2071 for (const int zone_i : zone_build_order) {
2072 const bNodeTreeZone &zone = *tree_zones_->zones[zone_i];
2073 switch (zone.output_node()->type_legacy) {
2075 this->build_simulation_zone_function(zone);
2076 break;
2077 }
2079 this->build_repeat_zone_function(zone);
2080 break;
2081 }
2083 this->build_foreach_geometry_element_zone_function(zone);
2084 break;
2086 this->build_closure_zone_function(zone);
2087 break;
2088 default: {
2090 break;
2091 }
2092 }
2093 }
2094 }
2095
2096 Array<int> compute_zone_build_order()
2097 {
2098 /* Build nested zones first. */
2099 Array<int> zone_build_order(tree_zones_->zones.size());
2100 array_utils::fill_index_range<int>(zone_build_order);
2101 std::ranges::sort(zone_build_order, [&](const int zone_a, const int zone_b) {
2102 return tree_zones_->zones[zone_a]->depth > tree_zones_->zones[zone_b]->depth;
2103 });
2104 return zone_build_order;
2105 }
2106
2111 void build_simulation_zone_function(const bNodeTreeZone &zone)
2112 {
2113 const int zone_i = zone.index;
2114 ZoneBuildInfo &zone_info = zone_build_infos_[zone_i];
2115 lf::Graph &lf_graph = scope_.construct<lf::Graph>("Simulation Zone");
2116 const auto &sim_output_storage = *static_cast<const NodeGeometrySimulationOutput *>(
2117 zone.output_node()->storage);
2118
2119 Vector<lf::GraphInputSocket *> lf_zone_inputs;
2120 Vector<lf::GraphOutputSocket *> lf_zone_outputs;
2121
2122 if (zone.input_node() != nullptr) {
2123 for (const bNodeSocket *bsocket : zone.input_node()->input_sockets().drop_back(1)) {
2124 zone_info.indices.inputs.main.append(lf_zone_inputs.append_and_get_index(
2125 &lf_graph.add_input(CPPType::get<SocketValueVariant>(), bsocket->name)));
2126 zone_info.indices.outputs.input_usages.append(lf_zone_outputs.append_and_get_index(
2127 &lf_graph.add_output(CPPType::get<bool>(), "Usage: " + StringRef(bsocket->name))));
2128 }
2129 }
2130
2131 this->build_zone_border_links_inputs(
2132 zone, lf_graph, lf_zone_inputs, zone_info.indices.inputs.border_links);
2133 this->build_zone_border_link_input_usages(
2134 zone, lf_graph, lf_zone_outputs, zone_info.indices.outputs.border_link_usages);
2135
2136 for (const bNodeSocket *bsocket : zone.output_node()->output_sockets().drop_back(1)) {
2137 zone_info.indices.outputs.main.append(lf_zone_outputs.append_and_get_index(
2138 &lf_graph.add_output(CPPType::get<SocketValueVariant>(), bsocket->name)));
2139 zone_info.indices.inputs.output_usages.append(lf_zone_inputs.append_and_get_index(
2140 &lf_graph.add_input(CPPType::get<bool>(), "Usage: " + StringRef(bsocket->name))));
2141 }
2142
2143 lf::Node &lf_simulation_usage_node = [&]() -> lf::Node & {
2144 auto &lazy_function = scope_.construct<LazyFunctionForSimulationInputsUsage>(
2145 *zone.output_node());
2146 lf::Node &lf_node = lf_graph.add_function(lazy_function);
2147
2148 for (const int i : zone_info.indices.outputs.input_usages) {
2149 lf_graph.add_link(lf_node.output(0), *lf_zone_outputs[i]);
2150 }
2151
2152 return lf_node;
2153 }();
2154
2155 BuildGraphParams graph_params{lf_graph};
2156
2157 lf::FunctionNode *lf_simulation_input = nullptr;
2158 if (zone.input_node()) {
2159 lf_simulation_input = this->insert_simulation_input_node(
2160 btree_, *zone.input_node(), graph_params);
2161 }
2162 lf::FunctionNode &lf_simulation_output = this->insert_simulation_output_node(
2163 *zone.output_node(), graph_params);
2164
2165 for (const bNodeSocket *bsocket : zone.output_node()->input_sockets().drop_back(1)) {
2166 graph_params.usage_by_bsocket.add(bsocket, &lf_simulation_usage_node.output(1));
2167 }
2168
2169 /* Link simulation input node directly to simulation output node for skip behavior. */
2170 for (const int i : IndexRange(sim_output_storage.items_num)) {
2171 lf::InputSocket &lf_to = lf_simulation_output.input(i + 1);
2172 if (lf_simulation_input) {
2173 lf::OutputSocket &lf_from = lf_simulation_input->output(i + 1);
2174 lf_graph.add_link(lf_from, lf_to);
2175 }
2176 else {
2177 const bNodeSocket &bsocket = zone.output_node()->input_socket(i + 1);
2178 lf_to.set_default_value(bsocket.typeinfo->geometry_nodes_default_value);
2179 }
2180 }
2181
2182 this->insert_nodes_and_zones(zone.child_nodes(), zone.child_zones, graph_params);
2183
2184 if (zone.input_node()) {
2185 this->build_output_socket_usages(*zone.input_node(), graph_params);
2186 }
2187 for (const auto item : graph_params.lf_output_by_bsocket.items()) {
2188 this->insert_links_from_socket(*item.key, *item.value, graph_params);
2189 }
2190
2191 this->link_border_link_inputs_and_usages(zone,
2192 lf_zone_inputs,
2193 zone_info.indices.inputs.border_links,
2194 lf_zone_outputs,
2195 zone_info.indices.outputs.border_link_usages,
2196 graph_params);
2197
2198 for (const int i : zone_info.indices.inputs.main) {
2199 lf_graph.add_link(*lf_zone_inputs[i], lf_simulation_input->input(i));
2200 }
2201
2202 for (const int i : zone_info.indices.outputs.main.index_range()) {
2203 lf_graph.add_link(lf_simulation_output.output(i),
2204 *lf_zone_outputs[zone_info.indices.outputs.main[i]]);
2205 }
2206
2207 this->add_default_inputs(graph_params);
2208
2209 Map<ReferenceSetIndex, lf::OutputSocket *> lf_reference_sets;
2210 this->build_reference_set_for_zone(graph_params, lf_reference_sets);
2211 for (const auto item : lf_reference_sets.items()) {
2212 lf::OutputSocket &lf_attribute_set_socket = *item.value;
2213 if (lf_attribute_set_socket.node().is_interface()) {
2214 zone_info.indices.inputs.reference_sets.add_new(
2215 item.key, lf_zone_inputs.append_and_get_index(&lf_attribute_set_socket));
2216 }
2217 }
2218 this->link_reference_sets(graph_params, lf_reference_sets);
2219 this->fix_link_cycles(lf_graph, graph_params.socket_usage_inputs);
2220
2221 lf_graph.update_node_indices();
2222
2223 auto &logger = scope_.construct<GeometryNodesLazyFunctionLogger>(*lf_graph_info_);
2224 auto &side_effect_provider = scope_.construct<GeometryNodesLazyFunctionSideEffectProvider>();
2225
2226 const auto &lf_graph_fn = scope_.construct<lf::GraphExecutor>(lf_graph,
2227 lf_zone_inputs.as_span(),
2228 lf_zone_outputs.as_span(),
2229 &logger,
2230 &side_effect_provider,
2231 nullptr);
2232 const auto &zone_function = scope_.construct<LazyFunctionForSimulationZone>(
2233 *zone.output_node(), lf_graph_fn);
2234 zone_info.lazy_function = &zone_function;
2235
2236 lf_graph_info_->debug_zone_body_graphs.add(zone.output_node()->identifier, &lf_graph);
2237 // std::cout << "\n\n" << lf_graph.to_dot() << "\n\n";
2238 }
2239
2243 void build_repeat_zone_function(const bNodeTreeZone &zone)
2244 {
2245 ZoneBuildInfo &zone_info = zone_build_infos_[zone.index];
2246 /* Build a function for the loop body. */
2247 ZoneBodyFunction &body_fn = this->build_zone_body_function(
2248 zone, "Repeat Body", &scope_.construct<GeometryNodesLazyFunctionSideEffectProvider>());
2249 /* Wrap the loop body by another function that implements the repeat behavior. */
2250 auto &zone_fn = build_repeat_zone_lazy_function(scope_, btree_, zone, zone_info, body_fn);
2251 zone_info.lazy_function = &zone_fn;
2252 }
2253
2254 void build_foreach_geometry_element_zone_function(const bNodeTreeZone &zone)
2255 {
2256 ZoneBuildInfo &zone_info = zone_build_infos_[zone.index];
2257 /* Build a function for the loop body. */
2258 ZoneBodyFunction &body_fn = this->build_zone_body_function(
2259 zone, "Foreach Body", &scope_.construct<GeometryNodesLazyFunctionSideEffectProvider>());
2260 /* Wrap the loop body in another function that implements the foreach behavior. */
2262 scope_, btree_, zone, zone_info, body_fn);
2263 zone_info.lazy_function = &zone_fn;
2264 }
2265
2266 void build_closure_zone_function(const bNodeTreeZone &zone)
2267 {
2268 ZoneBuildInfo &zone_info = zone_build_infos_[zone.index];
2269 /* Build a function for the closure body. */
2270 ZoneBodyFunction &body_fn = this->build_zone_body_function(
2271 zone, "Closure Body", &scope_.construct<GeometryNodesLazyFunctionSideEffectProvider>());
2272 auto &zone_fn = build_closure_zone_lazy_function(
2273 scope_, btree_, zone, zone_info, body_fn, lf_graph_info_);
2274 zone_info.lazy_function = &zone_fn;
2275 }
2276
2280 ZoneBodyFunction &build_zone_body_function(
2281 const bNodeTreeZone &zone,
2282 const StringRef name,
2283 const lf::GraphExecutorSideEffectProvider *side_effect_provider)
2284 {
2285 lf::Graph &lf_body_graph = scope_.construct<lf::Graph>(name);
2286
2287 BuildGraphParams graph_params{lf_body_graph};
2288
2289 Vector<lf::GraphInputSocket *> lf_body_inputs;
2290 Vector<lf::GraphOutputSocket *> lf_body_outputs;
2291 ZoneBodyFunction &body_fn = scope_.construct<ZoneBodyFunction>();
2292
2293 for (const bNodeSocket *bsocket : zone.input_node()->output_sockets()) {
2294 if (ignore_zone_bsocket(*bsocket)) {
2295 continue;
2296 }
2297 lf::GraphInputSocket &lf_input = lf_body_graph.add_input(CPPType::get<SocketValueVariant>(),
2298 bsocket->name);
2299 lf::GraphOutputSocket &lf_input_usage = lf_body_graph.add_output(
2300 CPPType::get<bool>(), "Usage: " + StringRef(bsocket->name));
2301 body_fn.indices.inputs.main.append(lf_body_inputs.append_and_get_index(&lf_input));
2302 body_fn.indices.outputs.input_usages.append(
2303 lf_body_outputs.append_and_get_index(&lf_input_usage));
2304 graph_params.lf_output_by_bsocket.add_new(bsocket, &lf_input);
2305 }
2306
2307 this->build_zone_border_links_inputs(
2308 zone, lf_body_graph, lf_body_inputs, body_fn.indices.inputs.border_links);
2309 this->build_zone_border_link_input_usages(
2310 zone, lf_body_graph, lf_body_outputs, body_fn.indices.outputs.border_link_usages);
2311
2312 for (const bNodeSocket *bsocket : zone.output_node()->input_sockets()) {
2313 if (ignore_zone_bsocket(*bsocket)) {
2314 continue;
2315 }
2316 lf::GraphOutputSocket &lf_output = lf_body_graph.add_output(
2317 CPPType::get<SocketValueVariant>(), bsocket->name);
2318 lf::GraphInputSocket &lf_output_usage = lf_body_graph.add_input(
2319 CPPType::get<bool>(), "Usage: " + StringRef(bsocket->name));
2320 graph_params.lf_inputs_by_bsocket.add(bsocket, &lf_output);
2321 graph_params.usage_by_bsocket.add(bsocket, &lf_output_usage);
2322 body_fn.indices.outputs.main.append(lf_body_outputs.append_and_get_index(&lf_output));
2323 body_fn.indices.inputs.output_usages.append(
2324 lf_body_inputs.append_and_get_index(&lf_output_usage));
2325 }
2326
2327 this->insert_nodes_and_zones(zone.child_nodes(), zone.child_zones, graph_params);
2328
2329 this->build_output_socket_usages(*zone.input_node(), graph_params);
2330
2331 {
2332 int valid_socket_i = 0;
2333 for (const bNodeSocket *bsocket : zone.input_node()->output_sockets()) {
2334 if (ignore_zone_bsocket(*bsocket)) {
2335 continue;
2336 }
2337 lf::OutputSocket *lf_usage = graph_params.usage_by_bsocket.lookup_default(bsocket,
2338 nullptr);
2339 lf::GraphOutputSocket &lf_usage_output =
2340 *lf_body_outputs[body_fn.indices.outputs.input_usages[valid_socket_i]];
2341 if (lf_usage) {
2342 lf_body_graph.add_link(*lf_usage, lf_usage_output);
2343 }
2344 else {
2345 static const bool static_false = false;
2346 lf_usage_output.set_default_value(&static_false);
2347 }
2348 valid_socket_i++;
2349 }
2350 }
2351
2352 for (const auto item : graph_params.lf_output_by_bsocket.items()) {
2353 this->insert_links_from_socket(*item.key, *item.value, graph_params);
2354 }
2355
2356 this->link_border_link_inputs_and_usages(zone,
2357 lf_body_inputs,
2358 body_fn.indices.inputs.border_links,
2359 lf_body_outputs,
2360 body_fn.indices.outputs.border_link_usages,
2361 graph_params);
2362
2363 this->add_default_inputs(graph_params);
2364
2365 Map<int, lf::OutputSocket *> lf_reference_sets;
2366 this->build_reference_set_for_zone(graph_params, lf_reference_sets);
2367 for (const auto item : lf_reference_sets.items()) {
2368 lf::OutputSocket &lf_attribute_set_socket = *item.value;
2369 if (lf_attribute_set_socket.node().is_interface()) {
2370 body_fn.indices.inputs.reference_sets.add_new(
2371 item.key, lf_body_inputs.append_and_get_index(&lf_attribute_set_socket));
2372 }
2373 }
2374 this->link_reference_sets(graph_params, lf_reference_sets);
2375 this->fix_link_cycles(lf_body_graph, graph_params.socket_usage_inputs);
2376
2377 lf_body_graph.update_node_indices();
2378
2379 auto &logger = scope_.construct<GeometryNodesLazyFunctionLogger>(*lf_graph_info_);
2380
2381 body_fn.function = &scope_.construct<lf::GraphExecutor>(lf_body_graph,
2382 lf_body_inputs.as_span(),
2383 lf_body_outputs.as_span(),
2384 &logger,
2385 side_effect_provider,
2386 nullptr);
2387
2388 lf_graph_info_->debug_zone_body_graphs.add(zone.output_node()->identifier, &lf_body_graph);
2389
2390 // std::cout << "\n\n" << lf_body_graph.to_dot() << "\n\n";
2391
2392 return body_fn;
2393 }
2394
2395 void build_zone_border_links_inputs(const bNodeTreeZone &zone,
2396 lf::Graph &lf_graph,
2397 Vector<lf::GraphInputSocket *> &r_lf_graph_inputs,
2398 Vector<int> &r_indices)
2399 {
2400 for (const bNodeLink *border_link : zone.border_links) {
2401 r_indices.append(r_lf_graph_inputs.append_and_get_index(
2402 &lf_graph.add_input(CPPType::get<SocketValueVariant>(),
2403 StringRef("Link from ") + border_link->fromsock->name)));
2404 }
2405 }
2406
2407 void build_zone_border_link_input_usages(const bNodeTreeZone &zone,
2408 lf::Graph &lf_graph,
2409 Vector<lf::GraphOutputSocket *> &r_lf_graph_outputs,
2410 Vector<int> &r_indices)
2411 {
2412 for (const bNodeLink *border_link : zone.border_links) {
2413 r_indices.append(r_lf_graph_outputs.append_and_get_index(&lf_graph.add_output(
2414 CPPType::get<bool>(), StringRef("Usage: Link from ") + border_link->fromsock->name)));
2415 }
2416 }
2417
2418 void build_reference_set_for_zone(BuildGraphParams &graph_params,
2419 Map<ReferenceSetIndex, lf::OutputSocket *> &lf_reference_sets)
2420 {
2421 const Vector<ReferenceSetIndex> all_required_reference_sets =
2422 this->find_all_required_reference_sets(graph_params.lf_reference_set_input_by_output,
2423 graph_params.lf_reference_set_inputs);
2424
2425 auto add_reference_set_zone_input = [&](const ReferenceSetIndex reference_set_i) {
2426 lf::GraphInputSocket &lf_graph_input = graph_params.lf_graph.add_input(
2427 CPPType::get<GeometryNodesReferenceSet>(), "Reference Set");
2428 lf_reference_sets.add(reference_set_i, &lf_graph_input);
2429 };
2430
2431 VectorSet<ReferenceSetIndex> input_reference_sets;
2432 for (const ReferenceSetIndex reference_set_i : all_required_reference_sets) {
2433 const ReferenceSetInfo &reference_set = reference_lifetimes_.reference_sets[reference_set_i];
2434 switch (reference_set.type) {
2435 case ReferenceSetType::GroupOutputData:
2436 case ReferenceSetType::GroupInputReferenceSet: {
2437 add_reference_set_zone_input(reference_set_i);
2438 break;
2439 }
2440 case ReferenceSetType::LocalReferenceSet:
2441 case ReferenceSetType::ClosureOutputData:
2442 case ReferenceSetType::ClosureInputReferenceSet: {
2443 const bNodeSocket &bsocket = *reference_set.socket;
2444 if (lf::OutputSocket *lf_socket = graph_params.lf_output_by_bsocket.lookup_default(
2445 &bsocket, nullptr))
2446 {
2447 lf::OutputSocket *lf_usage_socket = graph_params.usage_by_bsocket.lookup_default(
2448 &bsocket, nullptr);
2449 lf::OutputSocket &lf_reference_set_socket = this->get_extracted_reference_set(
2450 *lf_socket, lf_usage_socket, graph_params);
2451 lf_reference_sets.add(reference_set_i, &lf_reference_set_socket);
2452 }
2453 else {
2454 /* The reference was not created in the zone, so it needs to come from the input. */
2455 add_reference_set_zone_input(reference_set_i);
2456 }
2457 break;
2458 }
2459 }
2460 }
2461 }
2462
2467 void build_root_graph()
2468 {
2469 lf::Graph &lf_graph = lf_graph_info_->graph;
2470
2471 this->build_main_group_inputs(lf_graph);
2472 if (btree_.group_output_node() == nullptr) {
2473 this->build_fallback_group_outputs(lf_graph);
2474 }
2475
2476 for (const bNodeTreeInterfaceSocket *interface_input : btree_.interface_inputs()) {
2477 lf::GraphOutputSocket &lf_socket = lf_graph.add_output(
2478 CPPType::get<bool>(), StringRef("Usage: ") + interface_input->name());
2479 group_input_usage_sockets_.append(&lf_socket);
2480 }
2481
2482 Vector<lf::GraphInputSocket *> lf_output_usages;
2483 for (const bNodeTreeInterfaceSocket *interface_output : btree_.interface_outputs()) {
2484 lf::GraphInputSocket &lf_socket = lf_graph.add_input(
2485 CPPType::get<bool>(), StringRef("Usage: ") + interface_output->name());
2486 group_output_used_sockets_.append(&lf_socket);
2487 lf_output_usages.append(&lf_socket);
2488 }
2489
2490 BuildGraphParams &graph_params = root_graph_build_params_.emplace(lf_graph);
2491 if (const bNode *group_output_bnode = btree_.group_output_node()) {
2492 for (const bNodeSocket *bsocket : group_output_bnode->input_sockets().drop_back(1)) {
2493 graph_params.usage_by_bsocket.add(bsocket, lf_output_usages[bsocket->index()]);
2494 }
2495 }
2496
2497 this->insert_nodes_and_zones(
2498 tree_zones_->nodes_outside_zones(), tree_zones_->root_zones, graph_params);
2499
2500 for (const auto item : graph_params.lf_output_by_bsocket.items()) {
2501 this->insert_links_from_socket(*item.key, *item.value, graph_params);
2502 }
2503 this->build_group_input_usages(graph_params);
2504 this->add_default_inputs(graph_params);
2505
2506 this->build_root_reference_set_inputs(lf_graph);
2507
2508 Map<ReferenceSetIndex, lf::OutputSocket *> lf_reference_sets;
2509 this->build_reference_sets_outside_of_zones(graph_params, lf_reference_sets);
2510 this->link_reference_sets(graph_params, lf_reference_sets);
2511
2512 this->fix_link_cycles(lf_graph, graph_params.socket_usage_inputs);
2513
2514 // std::cout << "\n\n" << lf_graph.to_dot() << "\n\n";
2515
2516 lf_graph.update_node_indices();
2517 lf_graph_info_->num_inline_nodes_approximate += lf_graph.nodes().size();
2518 }
2519
2524 void build_geometry_nodes_group_function()
2525 {
2526 GeometryNodesGroupFunction &function = lf_graph_info_->function;
2527
2528 Vector<const lf::GraphInputSocket *> lf_graph_inputs;
2529 Vector<const lf::GraphOutputSocket *> lf_graph_outputs;
2530
2531 lf_graph_inputs.extend(group_input_sockets_);
2532 function.inputs.main = lf_graph_inputs.index_range().take_back(group_input_sockets_.size());
2533
2534 lf_graph_inputs.extend(group_output_used_sockets_);
2535 function.inputs.output_usages = lf_graph_inputs.index_range().take_back(
2536 group_output_used_sockets_.size());
2537
2538 for (auto [output_index, lf_socket] : reference_set_by_output_.items()) {
2539 lf_graph_inputs.append(lf_socket);
2540 function.inputs.references_to_propagate.geometry_outputs.append(output_index);
2541 }
2542 function.inputs.references_to_propagate.range = lf_graph_inputs.index_range().take_back(
2543 reference_set_by_output_.size());
2544
2545 lf_graph_outputs.extend(standard_group_output_sockets_);
2546 function.outputs.main = lf_graph_outputs.index_range().take_back(
2547 standard_group_output_sockets_.size());
2548
2549 lf_graph_outputs.extend(group_input_usage_sockets_);
2550 function.outputs.input_usages = lf_graph_outputs.index_range().take_back(
2551 group_input_usage_sockets_.size());
2552
2553 Vector<const lf::FunctionNode *> &local_side_effect_nodes =
2554 scope_.construct<Vector<const lf::FunctionNode *>>();
2555 for (const bNode *bnode : btree_.nodes_by_type("GeometryNodeWarning"_ustr)) {
2556 if (bnode->output_socket(0).is_directly_linked()) {
2557 /* The warning node is not a side-effect node. Instead, the user explicitly used the output
2558 * socket to specify when the warning node should be used. */
2559 continue;
2560 }
2561 if (tree_zones_->get_zone_by_node(bnode->identifier)) {
2562 /* "Global" warning nodes that are evaluated whenever the node group is evaluated must not
2563 * be in a zone. */
2564 continue;
2565 }
2566 /* Add warning node as side-effect node so that it is always evaluated if the node group is
2567 * evaluated. */
2568 const lf::Socket *lf_socket = root_graph_build_params_->lf_inputs_by_bsocket.lookup(
2569 &bnode->input_socket(0))[0];
2570 const lf::FunctionNode &lf_node = static_cast<const lf::FunctionNode &>(lf_socket->node());
2571 local_side_effect_nodes.append(&lf_node);
2572 }
2573
2574 function.function = &scope_.construct<lf::GraphExecutor>(
2575 lf_graph_info_->graph,
2576 std::move(lf_graph_inputs),
2577 std::move(lf_graph_outputs),
2578 &scope_.construct<GeometryNodesLazyFunctionLogger>(*lf_graph_info_),
2579 &scope_.construct<GeometryNodesLazyFunctionSideEffectProvider>(local_side_effect_nodes),
2580 nullptr);
2581 }
2582
2583 void build_reference_sets_outside_of_zones(
2584 BuildGraphParams &graph_params,
2585 Map<ReferenceSetIndex, lf::OutputSocket *> &lf_reference_sets)
2586 {
2587 const Vector<ReferenceSetIndex> all_required_reference_sets =
2588 this->find_all_required_reference_sets(graph_params.lf_reference_set_input_by_output,
2589 graph_params.lf_reference_set_inputs);
2590 for (const ReferenceSetIndex reference_set_i : all_required_reference_sets) {
2591 const ReferenceSetInfo &reference_set = reference_lifetimes_.reference_sets[reference_set_i];
2592 switch (reference_set.type) {
2593 case ReferenceSetType::LocalReferenceSet: {
2594 const bNodeSocket &bsocket = *reference_set.socket;
2595 lf::OutputSocket &lf_socket = *graph_params.lf_output_by_bsocket.lookup(&bsocket);
2596 lf::OutputSocket *lf_usage_socket = graph_params.usage_by_bsocket.lookup_default(
2597 &bsocket, nullptr);
2598 lf::OutputSocket &lf_reference_set_socket = this->get_extracted_reference_set(
2599 lf_socket, lf_usage_socket, graph_params);
2600 lf_reference_sets.add_new(reference_set_i, &lf_reference_set_socket);
2601 break;
2602 }
2603 case ReferenceSetType::GroupInputReferenceSet: {
2604 const int group_input_i = reference_set.index;
2605 lf::GraphInputSocket &lf_socket = *group_input_sockets_[group_input_i];
2606 lf::OutputSocket *lf_usage_socket = group_input_usage_sockets_[group_input_i]->origin();
2607 lf::OutputSocket &lf_reference_set_socket = this->get_extracted_reference_set(
2608 lf_socket, lf_usage_socket, graph_params);
2609 lf_reference_sets.add_new(reference_set_i, &lf_reference_set_socket);
2610 break;
2611 }
2612 case ReferenceSetType::GroupOutputData: {
2613 const int group_output_i = reference_set.index;
2614 lf::GraphInputSocket *lf_reference_set_socket = reference_set_by_output_.lookup(
2615 group_output_i);
2616 lf_reference_sets.add_new(reference_set_i, lf_reference_set_socket);
2617 break;
2618 }
2619 case ReferenceSetType::ClosureOutputData:
2620 case ReferenceSetType::ClosureInputReferenceSet: {
2621 /* These reference sets are not used outside of zones. */
2623 break;
2624 }
2625 }
2626 }
2627 }
2628
2629 Vector<ReferenceSetIndex> find_all_required_reference_sets(
2630 const Map<const bNodeSocket *, lf::InputSocket *> &lf_reference_set_input_by_output,
2631 const MultiValueMap<ReferenceSetIndex, lf::InputSocket *> &lf_reference_set_inputs)
2632 {
2633 BitVector<> all_required_reference_sets(reference_lifetimes_.reference_sets.size(), false);
2634 for (const bNodeSocket *bsocket : lf_reference_set_input_by_output.keys()) {
2635 all_required_reference_sets |=
2636 reference_lifetimes_.required_data_by_socket[bsocket->index_in_tree()];
2637 }
2638 for (const ReferenceSetIndex reference_set_i : lf_reference_set_inputs.keys()) {
2639 all_required_reference_sets[reference_set_i].set();
2640 }
2641 Vector<ReferenceSetIndex> indices;
2642 bits::foreach_1_index(all_required_reference_sets,
2643 [&](const int index) { indices.append(index); });
2644 return indices;
2645 }
2646
2647 void link_reference_sets(BuildGraphParams &graph_params,
2648 const Map<ReferenceSetIndex, lf::OutputSocket *> &lf_reference_sets)
2649 {
2650 JoinReferenceSetsCache join_reference_sets_cache;
2651 /* Pass reference sets to nodes so that they know which attributes to propagate. */
2652 for (const auto &item : graph_params.lf_reference_set_input_by_output.items()) {
2653 const bNodeSocket &output_bsocket = *item.key;
2654 lf::InputSocket &lf_reference_set_input = *item.value;
2655
2656 Vector<lf::OutputSocket *> lf_reference_sets_to_join;
2657 const BoundedBitSpan required_reference_sets =
2658 reference_lifetimes_.required_data_by_socket[output_bsocket.index_in_tree()];
2659 bits::foreach_1_index(required_reference_sets, [&](const ReferenceSetIndex reference_set_i) {
2660 const ReferenceSetInfo &reference_set =
2661 reference_lifetimes_.reference_sets[reference_set_i];
2662 if (reference_set.type == ReferenceSetType::LocalReferenceSet) {
2663 if (&reference_set.socket->owner_node() == &output_bsocket.owner_node()) {
2664 /* This reference is created in the current node, so it should not be an input. */
2665 return;
2666 }
2667 }
2668 lf_reference_sets_to_join.append(lf_reference_sets.lookup(reference_set_i));
2669 });
2670
2671 if (lf::OutputSocket *lf_joined_reference_set = this->join_reference_sets(
2672 lf_reference_sets_to_join,
2673 join_reference_sets_cache,
2674 graph_params.lf_graph,
2675 graph_params.socket_usage_inputs))
2676 {
2677 graph_params.lf_graph.add_link(*lf_joined_reference_set, lf_reference_set_input);
2678 }
2679 else {
2680 static const GeometryNodesReferenceSet empty_reference_set;
2681 lf_reference_set_input.set_default_value(&empty_reference_set);
2682 }
2683 }
2684
2685 /* Pass reference sets to e.g. sub-zones. */
2686 for (const auto &item : graph_params.lf_reference_set_inputs.items()) {
2687 const ReferenceSetIndex reference_set_i = item.key;
2688 lf::OutputSocket &lf_reference_set = *lf_reference_sets.lookup(reference_set_i);
2689 for (lf::InputSocket *lf_reference_set_input : item.value) {
2690 graph_params.lf_graph.add_link(lf_reference_set, *lf_reference_set_input);
2691 }
2692 }
2693 }
2694
2695 void insert_nodes_and_zones(const Span<const bNode *> bnodes,
2696 const Span<const bNodeTreeZone *> zones,
2697 BuildGraphParams &graph_params)
2698 {
2699 Vector<const bNode *> nodes_to_insert = bnodes;
2700 Map<const bNode *, const bNodeTreeZone *> zone_by_output;
2701 for (const bNodeTreeZone *zone : zones) {
2702 nodes_to_insert.append(zone->output_node());
2703 zone_by_output.add(zone->output_node(), zone);
2704 }
2705 /* Insert nodes from right to left so that usage sockets can be build in the same pass. */
2706 std::ranges::sort(nodes_to_insert, [](const bNode *a, const bNode *b) {
2707 return a->runtime->toposort_right_to_left_index < b->runtime->toposort_right_to_left_index;
2708 });
2709
2710 for (const bNode *bnode : nodes_to_insert) {
2711 this->build_output_socket_usages(*bnode, graph_params);
2712 if (const bNodeTreeZone *zone = zone_by_output.lookup_default(bnode, nullptr)) {
2713 this->insert_child_zone_node(*zone, graph_params);
2714 }
2715 else {
2716 this->insert_node_in_graph(*bnode, graph_params);
2717 }
2718 }
2719 }
2720
2721 void link_border_link_inputs_and_usages(const bNodeTreeZone &zone,
2722 const Span<lf::GraphInputSocket *> lf_inputs,
2723 const Span<int> lf_border_link_input_indices,
2724 const Span<lf::GraphOutputSocket *> lf_usages,
2725 const Span<int> lf_border_link_usage_indices,
2726 BuildGraphParams &graph_params)
2727 {
2728 lf::Graph &lf_graph = graph_params.lf_graph;
2729 for (const int border_link_i : zone.border_links.index_range()) {
2730 const bNodeLink &border_link = *zone.border_links[border_link_i];
2731 lf::GraphInputSocket &lf_from = *lf_inputs[lf_border_link_input_indices[border_link_i]];
2732 const Vector<lf::InputSocket *> lf_link_targets = this->find_link_targets(border_link,
2733 graph_params);
2734 for (lf::InputSocket *lf_to : lf_link_targets) {
2735 lf_graph.add_link(lf_from, *lf_to);
2736 }
2737 lf::GraphOutputSocket &lf_usage_output =
2738 *lf_usages[lf_border_link_usage_indices[border_link_i]];
2739 if (lf::OutputSocket *lf_usage = graph_params.usage_by_bsocket.lookup_default(
2740 border_link.tosock, nullptr))
2741 {
2742 lf_graph.add_link(*lf_usage, lf_usage_output);
2743 }
2744 else {
2745 static const bool static_false = false;
2746 lf_usage_output.set_default_value(&static_false);
2747 }
2748 }
2749 }
2750
2751 lf::OutputSocket &get_extracted_reference_set(lf::OutputSocket &lf_field_socket,
2752 lf::OutputSocket *lf_usage_socket,
2753 BuildGraphParams &graph_params)
2754 {
2755 auto &lazy_function = scope_.construct<LazyFunctionForExtractingReferenceSet>();
2756 lf::Node &lf_node = graph_params.lf_graph.add_function(lazy_function);
2757 lf::InputSocket &lf_use_input = lf_node.input(0);
2758 lf::InputSocket &lf_field_input = lf_node.input(1);
2759 graph_params.socket_usage_inputs.add_new(&lf_use_input);
2760 if (lf_usage_socket) {
2761 graph_params.lf_graph.add_link(*lf_usage_socket, lf_use_input);
2762 }
2763 else {
2764 static const bool static_false = false;
2765 lf_use_input.set_default_value(&static_false);
2766 }
2767 graph_params.lf_graph.add_link(lf_field_socket, lf_field_input);
2768 return lf_node.output(0);
2769 }
2770
2774 lf::OutputSocket *join_reference_sets(const Span<lf::OutputSocket *> lf_reference_set_sockets,
2775 JoinReferenceSetsCache &cache,
2776 lf::Graph &lf_graph,
2777 Set<lf::InputSocket *> &socket_usage_inputs)
2778 {
2779 if (lf_reference_set_sockets.is_empty()) {
2780 return nullptr;
2781 }
2782 if (lf_reference_set_sockets.size() == 1) {
2783 return lf_reference_set_sockets[0];
2784 }
2785
2786 Vector<lf::OutputSocket *, 16> key = lf_reference_set_sockets;
2787 std::ranges::sort(key);
2788 return cache.lookup_or_add_cb(key, [&]() {
2789 const auto &lazy_function = LazyFunctionForJoinReferenceSets::get_cached(
2790 lf_reference_set_sockets.size(), scope_);
2791 lf::Node &lf_node = lf_graph.add_function(lazy_function);
2792 for (const int i : lf_reference_set_sockets.index_range()) {
2793 lf::OutputSocket &lf_reference_set_socket = *lf_reference_set_sockets[i];
2794 lf::InputSocket &lf_use_input = lf_node.input(lazy_function.get_use_input(i));
2795
2796 /* Some reference sets could potentially be set unused in the future based on more dynamic
2797 * analysis of the node tree. */
2798 static const bool static_true = true;
2799 lf_use_input.set_default_value(&static_true);
2800
2801 socket_usage_inputs.add(&lf_use_input);
2802 lf::InputSocket &lf_reference_set_input = lf_node.input(
2803 lazy_function.get_reference_set_input(i));
2804 lf_graph.add_link(lf_reference_set_socket, lf_reference_set_input);
2805 }
2806 return &lf_node.output(0);
2807 });
2808 }
2809
2810 void insert_child_zone_node(const bNodeTreeZone &child_zone, BuildGraphParams &graph_params)
2811 {
2812 const int child_zone_i = child_zone.index;
2813 ZoneBuildInfo &child_zone_info = zone_build_infos_[child_zone_i];
2814 lf::FunctionNode &child_zone_node = graph_params.lf_graph.add_function(
2815 *child_zone_info.lazy_function);
2816 mapping_->zone_node_map.add_new(*child_zone.output_node_id, &child_zone_node);
2817
2818 {
2819 int valid_socket_i = 0;
2820 for (const bNodeSocket *bsocket : child_zone.input_node()->input_sockets()) {
2821 if (ignore_zone_bsocket(*bsocket)) {
2822 continue;
2823 }
2824 lf::InputSocket &lf_input_socket = child_zone_node.input(
2825 child_zone_info.indices.inputs.main[valid_socket_i]);
2826 lf::OutputSocket &lf_usage_socket = child_zone_node.output(
2827 child_zone_info.indices.outputs.input_usages[valid_socket_i]);
2828 this->add_to_socket_map(graph_params, *bsocket, lf_input_socket);
2829 graph_params.usage_by_bsocket.add(bsocket, &lf_usage_socket);
2830 valid_socket_i++;
2831 }
2832 }
2833 {
2834 int valid_socket_i = 0;
2835 for (const bNodeSocket *bsocket : child_zone.output_node()->output_sockets()) {
2836 if (ignore_zone_bsocket(*bsocket)) {
2837 continue;
2838 }
2839 lf::OutputSocket &lf_output_socket = child_zone_node.output(
2840 child_zone_info.indices.outputs.main[valid_socket_i]);
2841 lf::InputSocket &lf_usage_input = child_zone_node.input(
2842 child_zone_info.indices.inputs.output_usages[valid_socket_i]);
2843 this->add_to_socket_map(graph_params, *bsocket, lf_output_socket);
2844 graph_params.socket_usage_inputs.add(&lf_usage_input);
2845 if (lf::OutputSocket *lf_usage = graph_params.usage_by_bsocket.lookup_default(bsocket,
2846 nullptr))
2847 {
2848 graph_params.lf_graph.add_link(*lf_usage, lf_usage_input);
2849 }
2850 else {
2851 static const bool static_false = false;
2852 lf_usage_input.set_default_value(&static_false);
2853 }
2854 valid_socket_i++;
2855 }
2856 }
2857
2858 const Span<const bNodeLink *> child_border_links = child_zone.border_links;
2859 for (const int child_border_link_i : child_border_links.index_range()) {
2860 lf::InputSocket &child_border_link_input = child_zone_node.input(
2861 child_zone_info.indices.inputs.border_links[child_border_link_i]);
2862 const bNodeLink &link = *child_border_links[child_border_link_i];
2863 graph_params.lf_input_by_border_link.add(&link, &child_border_link_input);
2864 lf::OutputSocket &lf_usage = child_zone_node.output(
2865 child_zone_info.indices.outputs.border_link_usages[child_border_link_i]);
2866 graph_params.lf_inputs_by_bsocket.add(link.tosock, &child_border_link_input);
2867 graph_params.usage_by_bsocket.add(link.tosock, &lf_usage);
2868 }
2869
2870 for (const auto &item : child_zone_info.indices.inputs.reference_sets.items()) {
2871 const ReferenceSetIndex reference_set_i = item.key;
2872 const int child_zone_input_i = item.value;
2873 lf::InputSocket &lf_reference_set_input = child_zone_node.input(child_zone_input_i);
2874 BLI_assert(lf_reference_set_input.type().is<GeometryNodesReferenceSet>());
2875 graph_params.lf_reference_set_inputs.add(reference_set_i, &lf_reference_set_input);
2876 }
2877 }
2878
2879 void build_main_group_inputs(lf::Graph &lf_graph)
2880 {
2881 const Span<const bNodeTreeInterfaceSocket *> interface_inputs = btree_.interface_inputs();
2882 for (const bNodeTreeInterfaceSocket *interface_input : interface_inputs) {
2883 lf::GraphInputSocket &lf_socket = lf_graph.add_input(CPPType::get<SocketValueVariant>(),
2884 interface_input->name());
2885 group_input_sockets_.append(&lf_socket);
2886 }
2887 }
2888
2893 void build_fallback_group_outputs(lf::Graph &lf_graph)
2894 {
2895 for (const bNodeTreeInterfaceSocket *interface_output : btree_.interface_outputs()) {
2896 const bke::bNodeSocketType *typeinfo = interface_output->socket_typeinfo();
2897 lf::GraphOutputSocket &lf_socket = lf_graph.add_output(CPPType::get<SocketValueVariant>(),
2898 interface_output->name());
2899 lf_socket.set_default_value(typeinfo->geometry_nodes_default_value);
2900 standard_group_output_sockets_.append(&lf_socket);
2901 }
2902 }
2903
2904 void insert_node_in_graph(const bNode &bnode, BuildGraphParams &graph_params)
2905 {
2906 const bke::bNodeType *node_type = bnode.typeinfo;
2907 if (node_type == nullptr) {
2908 return;
2909 }
2910 if (bnode.is_muted()) {
2911 this->build_muted_node(bnode, graph_params);
2912 return;
2913 }
2914 if (bnode.is_group()) {
2915 /* Have special handling because `bnode.type_legacy` and `node_type.type_legacy` can be
2916 * different for custom node groups. In other cases they should be identical. */
2917 this->build_group_node(bnode, graph_params);
2918 return;
2919 }
2920 switch (node_type->type_legacy) {
2921 case NODE_FRAME: {
2922 /* Ignored. */
2923 break;
2924 }
2925 case NODE_REROUTE: {
2926 this->build_reroute_node(bnode, graph_params);
2927 break;
2928 }
2929 case NODE_GROUP_INPUT: {
2930 this->handle_group_input_node(bnode, graph_params);
2931 break;
2932 }
2933 case NODE_GROUP_OUTPUT: {
2934 this->build_group_output_node(bnode, graph_params);
2935 break;
2936 }
2937 case GEO_NODE_VIEWER: {
2938 this->build_viewer_node(bnode, graph_params);
2939 break;
2940 }
2941 case GEO_NODE_SWITCH: {
2942 this->build_switch_node(bnode, graph_params);
2943 break;
2944 }
2945 case GEO_NODE_INDEX_SWITCH: {
2946 this->build_index_switch_node(bnode, graph_params);
2947 break;
2948 }
2949 case GEO_NODE_WARNING: {
2950 this->build_warning_node(bnode, graph_params);
2951 break;
2952 }
2956 this->build_gizmo_node(bnode, graph_params);
2957 break;
2958 }
2959 case GEO_NODE_BAKE: {
2960 this->build_bake_node(bnode, graph_params);
2961 break;
2962 }
2963 case GEO_NODE_MENU_SWITCH: {
2964 this->build_menu_switch_node(bnode, graph_params);
2965 break;
2966 }
2967 case NODE_EVALUATE_CLOSURE: {
2968 this->build_evaluate_closure_node(bnode, graph_params);
2969 break;
2970 }
2971 default: {
2972 if (node_type->geometry_node_execute) {
2973 this->build_geometry_node(bnode, graph_params);
2974 break;
2975 }
2976 const NodeMultiFunctions::Item &fn_item = node_multi_functions_.try_get(bnode);
2977 if (fn_item.fn != nullptr) {
2978 this->build_multi_function_node(bnode, fn_item, graph_params);
2979 break;
2980 }
2981 if (bnode.is_type("NodeEnableOutput"_ustr)) {
2982 this->build_enable_output_node(bnode, graph_params);
2983 break;
2984 }
2985 if (bnode.is_undefined()) {
2986 this->build_undefined_node(bnode, graph_params);
2987 break;
2988 }
2989 /* Nodes that don't match any of the criteria above are just ignored. */
2990 break;
2991 }
2992 }
2993 }
2994
2995 void build_muted_node(const bNode &bnode, BuildGraphParams &graph_params)
2996 {
2997 auto &lazy_function = scope_.construct<LazyFunctionForMutedNode>(
2998 bnode, mapping_->lf_index_by_bsocket);
2999 lf::Node &lf_node = graph_params.lf_graph.add_function(lazy_function);
3000 for (const bNodeSocket *bsocket : bnode.input_sockets()) {
3001 const int lf_index = mapping_->lf_index_by_bsocket[bsocket->index_in_tree()];
3002 if (lf_index == -1) {
3003 continue;
3004 }
3005 this->add_to_socket_map(graph_params, *bsocket, lf_node.input(lf_index));
3006 }
3007 for (const bNodeSocket *bsocket : bnode.output_sockets()) {
3008 const int lf_index = mapping_->lf_index_by_bsocket[bsocket->index_in_tree()];
3009 if (lf_index == -1) {
3010 continue;
3011 }
3012 this->add_to_socket_map(graph_params, *bsocket, lf_node.output(lf_index));
3013 }
3014
3015 this->build_muted_node_usages(bnode, graph_params);
3016 }
3017
3021 void build_muted_node_usages(const bNode &bnode, BuildGraphParams &graph_params)
3022 {
3023 /* Find all outputs that use a specific input. */
3024 MultiValueMap<const bNodeSocket *, const bNodeSocket *> outputs_by_input;
3025 for (const bNodeInternalLink &blink : bnode.internal_links()) {
3026 outputs_by_input.add(blink.in, blink.out);
3027 }
3028 for (const auto item : outputs_by_input.items()) {
3029 const bNodeSocket &input_bsocket = *item.key;
3030 const Span<const bNodeSocket *> output_bsockets = item.value;
3031
3032 /* The input is used if any of the internally linked outputs is used. */
3033 Vector<lf::OutputSocket *> lf_socket_usages;
3034 for (const bNodeSocket *output_bsocket : output_bsockets) {
3035 if (lf::OutputSocket *lf_socket = graph_params.usage_by_bsocket.lookup_default(
3036 output_bsocket, nullptr))
3037 {
3038 lf_socket_usages.append(lf_socket);
3039 }
3040 }
3041 graph_params.usage_by_bsocket.add(&input_bsocket,
3042 this->or_socket_usages(lf_socket_usages, graph_params));
3043 }
3044 }
3045
3046 void build_reroute_node(const bNode &bnode, BuildGraphParams &graph_params)
3047 {
3048 const bNodeSocket &input_bsocket = bnode.input_socket(0);
3049 const bNodeSocket &output_bsocket = bnode.output_socket(0);
3050 if (!input_bsocket.typeinfo->geometry_nodes_default_value) {
3051 return;
3052 }
3053
3054 auto &lazy_function = scope_.construct<LazyFunctionForRerouteNode>();
3055 lf::Node &lf_node = graph_params.lf_graph.add_function(lazy_function);
3056
3057 this->add_to_socket_map(graph_params, input_bsocket, lf_node.input(0));
3058 this->add_to_socket_map(graph_params, output_bsocket, lf_node.output(0));
3059
3060 if (lf::OutputSocket *lf_usage = graph_params.usage_by_bsocket.lookup_default(
3061 &bnode.output_socket(0), nullptr))
3062 {
3063 graph_params.usage_by_bsocket.add(&bnode.input_socket(0), lf_usage);
3064 }
3065 }
3066
3067 void handle_group_input_node(const bNode &bnode, BuildGraphParams &graph_params)
3068 {
3069 for (const int i : btree_.interface_inputs().index_range()) {
3070 const bNodeSocket &bsocket = bnode.output_socket(i);
3071 lf::GraphInputSocket &lf_socket = *const_cast<lf::GraphInputSocket *>(
3072 group_input_sockets_[i]);
3073 this->add_to_socket_map(graph_params, bsocket, lf_socket);
3074 }
3075 }
3076
3077 void build_group_output_node(const bNode &bnode, BuildGraphParams &graph_params)
3078 {
3079 Vector<lf::GraphOutputSocket *> lf_graph_outputs;
3080
3081 for (const int i : btree_.interface_outputs().index_range()) {
3082 const bNodeTreeInterfaceSocket &interface_output = *btree_.interface_outputs()[i];
3083 const bNodeSocket &bsocket = bnode.input_socket(i);
3084 lf::GraphOutputSocket &lf_socket = graph_params.lf_graph.add_output(
3085 CPPType::get<SocketValueVariant>(), interface_output.name());
3086 lf_graph_outputs.append(&lf_socket);
3087 this->add_to_socket_map(graph_params, bsocket, lf_socket);
3088 }
3089
3090 if (&bnode == btree_.group_output_node()) {
3091 standard_group_output_sockets_ = lf_graph_outputs.as_span();
3092 }
3093 }
3094
3095 void build_group_node(const bNode &bnode, BuildGraphParams &graph_params)
3096 {
3097 const bNodeTree *group_btree = reinterpret_cast<bNodeTree *>(bnode.id);
3098 if (group_btree == nullptr) {
3099 return;
3100 }
3101 const std::shared_ptr<const GeometryNodesLazyFunctionGraphInfo> &group_lf_graph_info =
3103 if (!group_lf_graph_info) {
3104 return;
3105 }
3106 /* Take ownership of the nested group. */
3107 scope_.add(group_lf_graph_info);
3108
3109 auto &lazy_function = scope_.construct<LazyFunctionForGroupNode>(
3110 bnode, *group_lf_graph_info, *lf_graph_info_);
3111 lf::FunctionNode &lf_node = graph_params.lf_graph.add_function(lazy_function);
3112
3113 for (const int i : bnode.input_sockets().index_range()) {
3114 const bNodeSocket &bsocket = bnode.input_socket(i);
3115 BLI_assert(!bsocket.is_multi_input());
3116 lf::InputSocket &lf_socket = lf_node.input(group_lf_graph_info->function.inputs.main[i]);
3117 this->add_to_socket_map(graph_params, bsocket, lf_socket);
3118 }
3119 for (const int i : bnode.output_sockets().index_range()) {
3120 const bNodeSocket &bsocket = bnode.output_socket(i);
3121 lf::OutputSocket &lf_socket = lf_node.output(group_lf_graph_info->function.outputs.main[i]);
3122 this->add_to_socket_map(graph_params, bsocket, lf_socket);
3123 }
3124 mapping_->group_node_map.add(bnode.identifier, &lf_node);
3125 lf_graph_info_->num_inline_nodes_approximate +=
3126 group_lf_graph_info->num_inline_nodes_approximate;
3127 static const bool static_false = false;
3128 for (const bNodeSocket *bsocket : bnode.output_sockets()) {
3129 {
3130 const int lf_input_index =
3131 mapping_->lf_input_index_for_output_bsocket_usage[bsocket->index_in_all_outputs()];
3132 if (lf_input_index != -1) {
3133 lf::InputSocket &lf_input = lf_node.input(lf_input_index);
3134 lf_input.set_default_value(&static_false);
3135 graph_params.socket_usage_inputs.add(&lf_input);
3136 }
3137 }
3138 {
3139 /* Keep track of reference set inputs that need to be populated later. */
3140 const int lf_input_index =
3141 mapping_->lf_input_index_for_reference_set_for_output[bsocket->index_in_all_outputs()];
3142 if (lf_input_index != -1) {
3143 lf::InputSocket &lf_input = lf_node.input(lf_input_index);
3144 graph_params.lf_reference_set_input_by_output.add(bsocket, &lf_input);
3145 }
3146 }
3147 }
3148
3149 this->build_group_node_socket_usage(bnode, lf_node, graph_params, *group_lf_graph_info);
3150 }
3151
3152 void build_group_node_socket_usage(const bNode &bnode,
3153 lf::FunctionNode &lf_group_node,
3154 BuildGraphParams &graph_params,
3155 const GeometryNodesLazyFunctionGraphInfo &group_lf_graph_info)
3156 {
3157 for (const bNodeSocket *input_bsocket : bnode.input_sockets()) {
3158 const int input_index = input_bsocket->index();
3159 const InputUsageHint &input_usage_hint =
3160 group_lf_graph_info.mapping.group_input_usage_hints[input_index];
3161 switch (input_usage_hint.type) {
3162 case InputUsageHintType::Never: {
3163 /* Nothing to do. */
3164 break;
3165 }
3166 case InputUsageHintType::DependsOnOutput: {
3167 Vector<lf::OutputSocket *> output_usages;
3168 for (const int i : input_usage_hint.output_dependencies) {
3169 if (lf::OutputSocket *lf_socket = graph_params.usage_by_bsocket.lookup_default(
3170 &bnode.output_socket(i), nullptr))
3171 {
3172 output_usages.append(lf_socket);
3173 }
3174 }
3175 graph_params.usage_by_bsocket.add(input_bsocket,
3176 this->or_socket_usages(output_usages, graph_params));
3177 break;
3178 }
3179 case InputUsageHintType::DynamicSocket: {
3180 graph_params.usage_by_bsocket.add(
3181 input_bsocket,
3182 &lf_group_node.output(
3183 group_lf_graph_info.function.outputs.input_usages[input_index]));
3184 break;
3185 }
3186 }
3187 }
3188
3189 for (const bNodeSocket *output_bsocket : bnode.output_sockets()) {
3190 const int lf_input_index =
3191 mapping_
3192 ->lf_input_index_for_output_bsocket_usage[output_bsocket->index_in_all_outputs()];
3193 BLI_assert(lf_input_index >= 0);
3194 lf::InputSocket &lf_socket = lf_group_node.input(lf_input_index);
3195 if (lf::OutputSocket *lf_output_is_used = graph_params.usage_by_bsocket.lookup_default(
3196 output_bsocket, nullptr))
3197 {
3198 graph_params.lf_graph.add_link(*lf_output_is_used, lf_socket);
3199 }
3200 else {
3201 static const bool static_false = false;
3202 lf_socket.set_default_value(&static_false);
3203 }
3204 }
3205 }
3206
3207 void build_geometry_node(const bNode &bnode, BuildGraphParams &graph_params)
3208 {
3209 auto &lazy_function = scope_.construct<LazyFunctionForGeometryNode>(bnode, *lf_graph_info_);
3210 lf::Node &lf_node = graph_params.lf_graph.add_function(lazy_function);
3211
3212 for (const bNodeSocket *bsocket : bnode.input_sockets()) {
3213 const int lf_index = mapping_->lf_index_by_bsocket[bsocket->index_in_tree()];
3214 if (lf_index == -1) {
3215 continue;
3216 }
3217 lf::InputSocket &lf_socket = lf_node.input(lf_index);
3218
3219 if (bsocket->is_multi_input()) {
3220 auto &multi_input_lazy_function = scope_.construct<LazyFunctionForMultiInput>(*bsocket);
3221 lf::Node &lf_multi_input_node = graph_params.lf_graph.add_function(
3222 multi_input_lazy_function);
3223 graph_params.lf_graph.add_link(lf_multi_input_node.output(0), lf_socket);
3224 for (const int i : multi_input_lazy_function.links.index_range()) {
3225 lf::InputSocket &lf_multi_input_socket = lf_multi_input_node.input(i);
3226 const bNodeLink *link = multi_input_lazy_function.links[i];
3227 graph_params.lf_input_by_multi_input_link.add(link, &lf_multi_input_socket);
3228 mapping_->bsockets_by_lf_socket_map.add(&lf_multi_input_socket, bsocket);
3229 lf_multi_input_socket.set_default_value(bsocket->typeinfo->geometry_nodes_default_value);
3230 }
3231 }
3232 else {
3233 this->add_to_socket_map(graph_params, *bsocket, lf_socket);
3234 }
3235 }
3236 for (const bNodeSocket *bsocket : bnode.output_sockets()) {
3237 const int lf_index = mapping_->lf_index_by_bsocket[bsocket->index_in_tree()];
3238 if (lf_index == -1) {
3239 continue;
3240 }
3241 lf::OutputSocket &lf_socket = lf_node.output(lf_index);
3242 this->add_to_socket_map(graph_params, *bsocket, lf_socket);
3243 }
3244
3245 for (const bNodeSocket *bsocket : bnode.output_sockets()) {
3246 {
3247 const int lf_input_index =
3248 mapping_->lf_input_index_for_output_bsocket_usage[bsocket->index_in_all_outputs()];
3249 if (lf_input_index != -1) {
3250 lf::InputSocket &lf_input_socket = lf_node.input(lf_input_index);
3251 if (lf::OutputSocket *lf_usage = graph_params.usage_by_bsocket.lookup_default(bsocket,
3252 nullptr))
3253 {
3254 graph_params.lf_graph.add_link(*lf_usage, lf_input_socket);
3255 }
3256 else {
3257 static const bool static_false = false;
3258 lf_input_socket.set_default_value(&static_false);
3259 }
3260 graph_params.socket_usage_inputs.add_new(&lf_node.input(lf_input_index));
3261 }
3262 }
3263 {
3264 /* Keep track of reference inputs that need to be populated later. */
3265 const int lf_input_index =
3266 mapping_->lf_input_index_for_reference_set_for_output[bsocket->index_in_all_outputs()];
3267 if (lf_input_index != -1) {
3268 graph_params.lf_reference_set_input_by_output.add(bsocket,
3269 &lf_node.input(lf_input_index));
3270 }
3271 }
3272 }
3273
3274 this->build_standard_node_input_socket_usage(bnode, graph_params);
3275 }
3276
3277 void build_standard_node_input_socket_usage(const bNode &bnode, BuildGraphParams &graph_params)
3278 {
3279 if (bnode.input_sockets().is_empty()) {
3280 return;
3281 }
3282
3283 Vector<lf::OutputSocket *> output_usages;
3284 for (const bNodeSocket *output_socket : bnode.output_sockets()) {
3285 if (!output_socket->is_available()) {
3286 continue;
3287 }
3288 if (lf::OutputSocket *is_used_socket = graph_params.usage_by_bsocket.lookup_default(
3289 output_socket, nullptr))
3290 {
3291 output_usages.append_non_duplicates(is_used_socket);
3292 }
3293 }
3294
3295 /* Assume every input is used when any output is used. */
3296 lf::OutputSocket *lf_usage = this->or_socket_usages(output_usages, graph_params);
3297 if (lf_usage == nullptr) {
3298 return;
3299 }
3300
3301 for (const bNodeSocket *input_socket : bnode.input_sockets()) {
3302 if (input_socket->is_available()) {
3303 graph_params.usage_by_bsocket.add(input_socket, lf_usage);
3304 }
3305 }
3306 }
3307
3308 void build_multi_function_node(const bNode &bnode,
3309 const NodeMultiFunctions::Item &fn_item,
3310 BuildGraphParams &graph_params)
3311 {
3312 auto &lazy_function = scope_.construct<LazyFunctionForMultiFunctionNode>(
3313 bnode, fn_item, mapping_->lf_index_by_bsocket);
3314 lf::FunctionNode &lf_node = graph_params.lf_graph.add_function(lazy_function);
3315
3316 for (const bNodeSocket *bsocket : bnode.input_sockets()) {
3317 const int lf_index = mapping_->lf_index_by_bsocket[bsocket->index_in_tree()];
3318 if (lf_index == -1) {
3319 continue;
3320 }
3321 BLI_assert(!bsocket->is_multi_input());
3322 this->add_to_socket_map(graph_params, *bsocket, lf_node.input(lf_index));
3323 }
3324 for (const bNodeSocket *bsocket : bnode.output_sockets()) {
3325 const int lf_index = mapping_->lf_index_by_bsocket[bsocket->index_in_tree()];
3326 if (lf_index == -1) {
3327 continue;
3328 }
3329 this->add_to_socket_map(graph_params, *bsocket, lf_node.output(lf_index));
3330 }
3331
3332 this->build_standard_node_input_socket_usage(bnode, graph_params);
3333 }
3334
3335 void build_viewer_node(const bNode &bnode, BuildGraphParams &graph_params)
3336 {
3337 auto &lazy_function = scope_.construct<LazyFunctionForViewerNode>(
3338 bnode, mapping_->lf_index_by_bsocket);
3339 lf::FunctionNode &lf_viewer_node = graph_params.lf_graph.add_function(lazy_function);
3340
3341 for (const bNodeSocket *bsocket : bnode.input_sockets().drop_back(1)) {
3342 const int lf_index = mapping_->lf_index_by_bsocket[bsocket->index_in_tree()];
3343 this->add_to_socket_map(graph_params, *bsocket, lf_viewer_node.input(lf_index));
3344 }
3345
3346 mapping_->possible_side_effect_node_map.add(bnode.identifier, &lf_viewer_node);
3347
3348 {
3349 auto &usage_lazy_function = scope_.construct<LazyFunctionForViewerInputUsage>(
3350 lf_viewer_node);
3351 lf::FunctionNode &lf_usage_node = graph_params.lf_graph.add_function(usage_lazy_function);
3352
3353 for (const bNodeSocket *bsocket : bnode.input_sockets().drop_back(1)) {
3354 graph_params.usage_by_bsocket.add(bsocket, &lf_usage_node.output(0));
3355 }
3356 }
3357 }
3358
3359 void build_gizmo_node(const bNode &bnode, BuildGraphParams &graph_params)
3360 {
3361 auto &lazy_function = scope_.construct<LazyFunctionForGizmoNode>(
3362 bnode, mapping_->lf_index_by_bsocket);
3363 lf::FunctionNode &lf_gizmo_node = graph_params.lf_graph.add_function(lazy_function);
3364 lazy_function.self_node = &lf_gizmo_node;
3365
3366 for (const int i : lazy_function.gizmo_links.index_range()) {
3367 const bNodeLink &link = *lazy_function.gizmo_links[i];
3368 lf::InputSocket &lf_socket = lf_gizmo_node.input(i);
3369 graph_params.lf_input_by_multi_input_link.add(&link, &lf_socket);
3370 }
3371 for (const int i : bnode.input_sockets().drop_front(1).index_range()) {
3372 this->add_to_socket_map(graph_params,
3373 bnode.input_socket(i + 1),
3374 lf_gizmo_node.input(i + lazy_function.gizmo_links.size()));
3375 }
3376 for (const int i : bnode.output_sockets().index_range()) {
3377 this->add_to_socket_map(graph_params, bnode.output_socket(i), lf_gizmo_node.output(i));
3378 }
3379
3380 this->build_gizmo_node_socket_usage(bnode, graph_params, lf_gizmo_node);
3381
3382 mapping_->possible_side_effect_node_map.add(bnode.identifier, &lf_gizmo_node);
3383 }
3384
3385 void build_gizmo_node_socket_usage(const bNode &bnode,
3386 BuildGraphParams &graph_params,
3387 const lf::FunctionNode &lf_gizmo_node)
3388 {
3389 const auto &usage_fn = scope_.construct<LazyFunctionForGizmoInputsUsage>(bnode, lf_gizmo_node);
3390 lf::FunctionNode &lf_usage_node = graph_params.lf_graph.add_function(usage_fn);
3391 for (const bNodeSocket *bsocket : bnode.input_sockets()) {
3392 graph_params.usage_by_bsocket.add(bsocket, &lf_usage_node.output(0));
3393 }
3394 }
3395
3396 lf::FunctionNode *insert_simulation_input_node(const bNodeTree &node_tree,
3397 const bNode &bnode,
3398 BuildGraphParams &graph_params)
3399 {
3400 const NodeGeometrySimulationInput *storage = static_cast<const NodeGeometrySimulationInput *>(
3401 bnode.storage);
3402 if (node_tree.node_by_id(storage->output_node_id) == nullptr) {
3403 return nullptr;
3404 }
3405
3406 std::unique_ptr<LazyFunction> lazy_function = get_simulation_input_lazy_function(
3407 node_tree, bnode, *lf_graph_info_);
3408 lf::FunctionNode &lf_node = graph_params.lf_graph.add_function(*lazy_function);
3409 scope_.add(std::move(lazy_function));
3410
3411 for (const int i : bnode.input_sockets().index_range().drop_back(1)) {
3412 const bNodeSocket &bsocket = bnode.input_socket(i);
3413 this->add_to_socket_map(
3414 graph_params,
3415 bsocket,
3416 lf_node.input(mapping_->lf_index_by_bsocket[bsocket.index_in_tree()]));
3417 }
3418 for (const int i : bnode.output_sockets().index_range().drop_back(1)) {
3419 const bNodeSocket &bsocket = bnode.output_socket(i);
3420 this->add_to_socket_map(
3421 graph_params,
3422 bsocket,
3423 lf_node.output(mapping_->lf_index_by_bsocket[bsocket.index_in_tree()]));
3424 }
3425 return &lf_node;
3426 }
3427
3428 lf::FunctionNode &insert_simulation_output_node(const bNode &bnode,
3429 BuildGraphParams &graph_params)
3430 {
3431 std::unique_ptr<LazyFunction> lazy_function = get_simulation_output_lazy_function(
3432 bnode, *lf_graph_info_);
3433 lf::FunctionNode &lf_node = graph_params.lf_graph.add_function(*lazy_function);
3434 scope_.add(std::move(lazy_function));
3435
3436 for (const int i : bnode.input_sockets().index_range().drop_back(1)) {
3437 const bNodeSocket &bsocket = bnode.input_socket(i);
3438 this->add_to_socket_map(
3439 graph_params,
3440 bsocket,
3441 lf_node.input(mapping_->lf_index_by_bsocket[bsocket.index_in_tree()]));
3442 }
3443 for (const int i : bnode.output_sockets().index_range().drop_back(1)) {
3444 const bNodeSocket &bsocket = bnode.output_socket(i);
3445 this->add_to_socket_map(
3446 graph_params,
3447 bsocket,
3448 lf_node.output(mapping_->lf_index_by_bsocket[bsocket.index_in_tree()]));
3449 }
3450
3451 mapping_->possible_side_effect_node_map.add(bnode.identifier, &lf_node);
3452
3453 return lf_node;
3454 }
3455
3456 void build_bake_node(const bNode &bnode, BuildGraphParams &graph_params)
3457 {
3458 std::unique_ptr<LazyFunction> lazy_function = get_bake_lazy_function(bnode, *lf_graph_info_);
3459 lf::FunctionNode &lf_node = graph_params.lf_graph.add_function(*lazy_function);
3460 scope_.add(std::move(lazy_function));
3461
3462 for (const int i : bnode.input_sockets().index_range().drop_back(1)) {
3463 const bNodeSocket &bsocket = bnode.input_socket(i);
3464 this->add_to_socket_map(
3465 graph_params,
3466 bsocket,
3467 lf_node.input(mapping_->lf_index_by_bsocket[bsocket.index_in_tree()]));
3468 }
3469 for (const int i : bnode.output_sockets().index_range().drop_back(1)) {
3470 const bNodeSocket &bsocket = bnode.output_socket(i);
3471 this->add_to_socket_map(
3472 graph_params,
3473 bsocket,
3474 lf_node.output(mapping_->lf_index_by_bsocket[bsocket.index_in_tree()]));
3475 }
3476
3477 mapping_->possible_side_effect_node_map.add(bnode.identifier, &lf_node);
3478
3479 this->build_bake_node_socket_usage(bnode, graph_params);
3480 }
3481
3482 void build_bake_node_socket_usage(const bNode &bnode, BuildGraphParams &graph_params)
3483 {
3484 const LazyFunction &usage_fn = scope_.construct<LazyFunctionForBakeInputsUsage>(bnode);
3485 lf::FunctionNode &lf_usage_node = graph_params.lf_graph.add_function(usage_fn);
3486 const int items_num = bnode.input_sockets().size() - 1;
3487 for (const int i : IndexRange(items_num)) {
3488 graph_params.usage_by_bsocket.add(&bnode.input_socket(i), &lf_usage_node.output(0));
3489 }
3490 }
3491
3492 void build_switch_node(const bNode &bnode, BuildGraphParams &graph_params)
3493 {
3494 std::unique_ptr<LazyFunction> lazy_function = get_switch_node_lazy_function(bnode);
3495 lf::FunctionNode &lf_node = graph_params.lf_graph.add_function(*lazy_function);
3496 scope_.add(std::move(lazy_function));
3497
3498 for (const int i : bnode.input_sockets().index_range()) {
3499 this->add_to_socket_map(graph_params, bnode.input_socket(i), lf_node.input(i));
3500 }
3501 this->add_to_socket_map(graph_params, bnode.output_socket(0), lf_node.output(0));
3502
3503 this->build_switch_node_socket_usage(bnode, graph_params);
3504 }
3505
3506 void build_switch_node_socket_usage(const bNode &bnode, BuildGraphParams &graph_params)
3507 {
3508 const bNodeSocket &switch_input_bsocket = bnode.input_socket(0);
3509 const bNodeSocket &false_input_bsocket = bnode.input_socket(1);
3510 const bNodeSocket &true_input_bsocket = bnode.input_socket(2);
3511 const bNodeSocket &output_bsocket = bnode.output_socket(0);
3512 lf::OutputSocket *output_is_used_socket = graph_params.usage_by_bsocket.lookup_default(
3513 &output_bsocket, nullptr);
3514 if (output_is_used_socket == nullptr) {
3515 return;
3516 }
3517 graph_params.usage_by_bsocket.add(&switch_input_bsocket, output_is_used_socket);
3518 if (switch_input_bsocket.is_directly_linked()) {
3519 /* The condition input is dynamic, so the usage of the other inputs is as well. */
3520 static const LazyFunctionForSwitchSocketUsage switch_socket_usage_fn;
3521 lf::Node &lf_node = graph_params.lf_graph.add_function(switch_socket_usage_fn);
3522 graph_params.lf_inputs_by_bsocket.add(&switch_input_bsocket, &lf_node.input(0));
3523 graph_params.usage_by_bsocket.add(&false_input_bsocket, &lf_node.output(0));
3524 graph_params.usage_by_bsocket.add(&true_input_bsocket, &lf_node.output(1));
3525 }
3526 else {
3527 if (switch_input_bsocket.default_value_typed<bNodeSocketValueBoolean>()->value) {
3528 graph_params.usage_by_bsocket.add(&true_input_bsocket, output_is_used_socket);
3529 }
3530 else {
3531 graph_params.usage_by_bsocket.add(&false_input_bsocket, output_is_used_socket);
3532 }
3533 }
3534 }
3535
3536 void build_enable_output_node(const bNode &bnode, BuildGraphParams &graph_params)
3537 {
3538 std::unique_ptr<LazyFunction> lazy_function = get_enable_output_node_lazy_function(
3539 bnode, *lf_graph_info_);
3540 lf::FunctionNode &lf_node = graph_params.lf_graph.add_function(*lazy_function);
3541 scope_.add(std::move(lazy_function));
3542
3543 for (const int i : bnode.input_sockets().index_range()) {
3544 this->add_to_socket_map(graph_params, bnode.input_socket(i), lf_node.input(i));
3545 }
3546 for (const int i : bnode.output_sockets().index_range()) {
3547 this->add_to_socket_map(graph_params, bnode.output_socket(i), lf_node.output(i));
3548 }
3549
3550 this->build_enable_output_node_socket_usage(bnode, graph_params);
3551 }
3552
3553 void build_enable_output_node_socket_usage(const bNode &bnode, BuildGraphParams &graph_params)
3554 {
3555 const bNodeSocket &enable_bsocket = *bnode.input_by_identifier("Enable"_ustr);
3556 const bNodeSocket &value_input_bsocket = *bnode.input_by_identifier("Value"_ustr);
3557 const bNodeSocket &output_bsocket = bnode.output_socket(0);
3558 lf::OutputSocket *output_is_used_socket = graph_params.usage_by_bsocket.lookup_default(
3559 &output_bsocket, nullptr);
3560 if (!output_is_used_socket) {
3561 return;
3562 }
3563 static LazyFunctionForEnableOutputSocketUsage socket_usage_fn;
3564 lf::Node &lf_node = graph_params.lf_graph.add_function(socket_usage_fn);
3565 graph_params.lf_inputs_by_bsocket.add(&enable_bsocket, &lf_node.input(0));
3566 graph_params.usage_by_bsocket.add(&enable_bsocket, output_is_used_socket);
3567 graph_params.usage_by_bsocket.add(&value_input_bsocket, &lf_node.output(0));
3568 }
3569
3570 void build_index_switch_node(const bNode &bnode, BuildGraphParams &graph_params)
3571 {
3572 std::unique_ptr<LazyFunction> lazy_function = get_index_switch_node_lazy_function(
3573 bnode, *lf_graph_info_);
3574 lf::FunctionNode &lf_node = graph_params.lf_graph.add_function(*lazy_function);
3575 scope_.add(std::move(lazy_function));
3576
3577 for (const int i : bnode.input_sockets().drop_back(1).index_range()) {
3578 this->add_to_socket_map(graph_params, bnode.input_socket(i), lf_node.input(i));
3579 }
3580 this->add_to_socket_map(graph_params, bnode.output_socket(0), lf_node.output(0));
3581
3582 this->build_index_switch_node_socket_usage(bnode, graph_params);
3583 }
3584
3585 void build_index_switch_node_socket_usage(const bNode &bnode, BuildGraphParams &graph_params)
3586 {
3587 const bNodeSocket &index_socket = bnode.input_socket(0);
3588 const int items_num = bnode.input_sockets().size() - 1;
3589
3590 lf::OutputSocket *output_is_used = graph_params.usage_by_bsocket.lookup_default(
3591 &bnode.output_socket(0), nullptr);
3592 if (output_is_used == nullptr) {
3593 return;
3594 }
3595 graph_params.usage_by_bsocket.add(&index_socket, output_is_used);
3596 if (index_socket.is_directly_linked()) {
3597 /* The condition input is dynamic, so the usage of the other inputs is as well. */
3598 auto usage_fn = std::make_unique<LazyFunctionForIndexSwitchSocketUsage>(bnode);
3599 lf::Node &lf_node = graph_params.lf_graph.add_function(*usage_fn);
3600 scope_.add(std::move(usage_fn));
3601
3602 graph_params.lf_inputs_by_bsocket.add(&index_socket, &lf_node.input(0));
3603 for (const int i : IndexRange(items_num)) {
3604 graph_params.usage_by_bsocket.add(&bnode.input_socket(i + 1), &lf_node.output(i));
3605 }
3606 }
3607 else {
3608 const int index = index_socket.default_value_typed<bNodeSocketValueInt>()->value;
3609 if (IndexRange(items_num).contains(index)) {
3610 graph_params.usage_by_bsocket.add(&bnode.input_socket(index + 1), output_is_used);
3611 }
3612 }
3613 }
3614
3615 void build_warning_node(const bNode &bnode, BuildGraphParams &graph_params)
3616 {
3617 auto lazy_function_ptr = get_warning_node_lazy_function(bnode);
3618 LazyFunction &lazy_function = *lazy_function_ptr;
3619 scope_.add(std::move(lazy_function_ptr));
3620
3621 lf::Node &lf_node = graph_params.lf_graph.add_function(lazy_function);
3622
3623 for (const int i : bnode.input_sockets().index_range()) {
3624 this->add_to_socket_map(graph_params, bnode.input_socket(i), lf_node.input(i));
3625 }
3626 for (const int i : bnode.output_sockets().index_range()) {
3627 this->add_to_socket_map(graph_params, bnode.output_socket(i), lf_node.output(i));
3628 }
3629
3630 const bNodeSocket &output_bsocket = bnode.output_socket(0);
3631
3632 lf::OutputSocket *lf_usage = nullptr;
3633 if (output_bsocket.is_directly_linked()) {
3634 /* The warning node is only used if the output socket is used. */
3635 lf_usage = graph_params.usage_by_bsocket.lookup_default(&output_bsocket, nullptr);
3636 }
3637 else {
3638 /* The warning node is used if any of the output sockets is used. */
3639 lf_usage = this->or_socket_usages(group_output_used_sockets_, graph_params);
3640 }
3641 if (lf_usage) {
3642 for (const bNodeSocket *socket : bnode.input_sockets()) {
3643 graph_params.usage_by_bsocket.add(socket, lf_usage);
3644 }
3645 }
3646 }
3647
3648 void build_menu_switch_node(const bNode &bnode, BuildGraphParams &graph_params)
3649 {
3650 const NodeMenuSwitch &storage = *static_cast<NodeMenuSwitch *>(bnode.storage);
3651
3652 /* The menu-switch node uses separate lazy-functions for the main output and all the boolean
3653 * outputs. This leads to better lazy evaluation in some cases because the boolean outputs more
3654 * obviously only depend on the menu input (and not on all the value inputs). */
3655 std::unique_ptr<LazyFunction> value_fn = get_menu_switch_node_lazy_function(bnode,
3656 *lf_graph_info_);
3657 std::unique_ptr<LazyFunction> bools_fn = get_menu_switch_node_boolean_outputs_lazy_function(
3658 bnode, *lf_graph_info_);
3659
3660 lf::FunctionNode &lf_value_node = graph_params.lf_graph.add_function(*value_fn);
3661 lf::FunctionNode &lf_bools_node = graph_params.lf_graph.add_function(*bools_fn);
3662 scope_.add(std::move(value_fn));
3663 scope_.add(std::move(bools_fn));
3664
3665 for (const int i : bnode.input_sockets().index_range().drop_back(1)) {
3666 const bNodeSocket &bsocket = bnode.input_socket(i);
3667 this->add_to_socket_map(graph_params, bsocket, lf_value_node.input(i));
3668 }
3669 this->add_to_socket_map(graph_params, bnode.input_socket(0), lf_bools_node.input(0));
3670
3671 this->add_to_socket_map(graph_params, bnode.output_socket(0), lf_value_node.output(0));
3672
3673 for (const int i : IndexRange(storage.enum_definition.items_num)) {
3674 const bNodeSocket &bsocket = bnode.output_socket(i + 1);
3675 this->add_to_socket_map(graph_params, bsocket, lf_bools_node.output(i));
3676 }
3677
3678 this->build_menu_switch_node_socket_usage(bnode, graph_params);
3679 }
3680
3681 void build_menu_switch_node_socket_usage(const bNode &bnode, BuildGraphParams &graph_params)
3682 {
3683 const NodeMenuSwitch &storage = *static_cast<NodeMenuSwitch *>(bnode.storage);
3684 const NodeEnumDefinition &enum_def = storage.enum_definition;
3685
3686 const bNodeSocket *switch_input_bsocket = bnode.input_sockets()[0];
3687 Vector<const bNodeSocket *> input_bsockets(enum_def.items_num);
3688 for (const int i : IndexRange(enum_def.items_num)) {
3689 input_bsockets[i] = bnode.input_sockets()[i + 1];
3690 }
3691 const bNodeSocket *output_bsocket = bnode.output_sockets()[0];
3692
3693 lf::OutputSocket *output_is_used_socket = graph_params.usage_by_bsocket.lookup_default(
3694 output_bsocket, nullptr);
3695 if (output_is_used_socket == nullptr) {
3696 return;
3697 }
3698 graph_params.usage_by_bsocket.add(switch_input_bsocket, output_is_used_socket);
3699 if (switch_input_bsocket->is_directly_linked()) {
3700 /* The condition input is dynamic, so the usage of the other inputs is as well. */
3701 std::unique_ptr<LazyFunction> lazy_function =
3703 lf::FunctionNode &lf_node = graph_params.lf_graph.add_function(*lazy_function);
3704 scope_.add(std::move(lazy_function));
3705
3706 graph_params.lf_inputs_by_bsocket.add(switch_input_bsocket, &lf_node.input(0));
3707 for (const int i : IndexRange(enum_def.items_num)) {
3708 graph_params.usage_by_bsocket.add(input_bsockets[i], &lf_node.output(i));
3709 }
3710 }
3711 else {
3712 const int condition =
3713 switch_input_bsocket->default_value_typed<bNodeSocketValueMenu>()->value;
3714 for (const int i : IndexRange(enum_def.items_num)) {
3715 const NodeEnumItem &enum_item = enum_def.items()[i];
3716 if (enum_item.identifier == condition) {
3717 graph_params.usage_by_bsocket.add(input_bsockets[i], output_is_used_socket);
3718 break;
3719 }
3720 }
3721 }
3722 }
3723
3724 void build_evaluate_closure_node(const bNode &bnode, BuildGraphParams &graph_params)
3725 {
3726 const EvaluateClosureFunction function = build_evaluate_closure_node_lazy_function(scope_,
3727 bnode);
3728 lf::FunctionNode &lf_node = graph_params.lf_graph.add_function(*function.lazy_function);
3729 const int inputs_num = bnode.input_sockets().size() - 1;
3730 const int outputs_num = bnode.output_sockets().size() - 1;
3731 BLI_assert(inputs_num == function.indices.inputs.main.size());
3732 BLI_assert(inputs_num == function.indices.outputs.input_usages.size());
3733 BLI_assert(outputs_num == function.indices.outputs.main.size());
3734 BLI_assert(outputs_num == function.indices.inputs.output_usages.size());
3735
3736 mapping_->possible_side_effect_node_map.add(bnode.identifier, &lf_node);
3737
3738 for (const int i : IndexRange(inputs_num)) {
3739 const bNodeSocket &bsocket = bnode.input_socket(i);
3740 lf::InputSocket &lf_socket = lf_node.input(function.indices.inputs.main[i]);
3741 this->add_to_socket_map(graph_params, bsocket, lf_socket);
3742 graph_params.usage_by_bsocket.add(&bsocket,
3743 &lf_node.output(function.indices.outputs.input_usages[i]));
3744 }
3745 for (const int i : IndexRange(outputs_num)) {
3746 const bNodeSocket &bsocket = bnode.output_socket(i);
3747 lf::OutputSocket &lf_socket = lf_node.output(function.indices.outputs.main[i]);
3748 this->add_to_socket_map(graph_params, bsocket, lf_socket);
3749 lf::InputSocket &lf_usage_socket = lf_node.input(function.indices.inputs.output_usages[i]);
3750 graph_params.socket_usage_inputs.add(&lf_usage_socket);
3751 if (lf::OutputSocket *output_is_used = graph_params.usage_by_bsocket.lookup(&bsocket)) {
3752 graph_params.lf_graph.add_link(*output_is_used, lf_usage_socket);
3753 }
3754 else {
3755 static const bool static_false = false;
3756 lf_usage_socket.set_default_value(&static_false);
3757 }
3758 }
3759 for (const auto item : function.indices.inputs.reference_set_by_output.items()) {
3760 const bNodeSocket &bsocket = bnode.output_socket(item.key);
3761 lf_graph_info_->mapping
3762 .lf_input_index_for_reference_set_for_output[bsocket.index_in_all_outputs()] =
3763 item.value;
3764 graph_params.lf_reference_set_input_by_output.add(&bsocket, &lf_node.input(item.value));
3765 }
3766 }
3767
3768 void build_undefined_node(const bNode &bnode, BuildGraphParams &graph_params)
3769 {
3770 auto &lazy_function = scope_.construct<LazyFunctionForUndefinedNode>(
3771 bnode, mapping_->lf_index_by_bsocket);
3772 lf::FunctionNode &lf_node = graph_params.lf_graph.add_function(lazy_function);
3773
3774 for (const bNodeSocket *bsocket : bnode.output_sockets()) {
3775 const int lf_index = mapping_->lf_index_by_bsocket[bsocket->index_in_tree()];
3776 if (lf_index == -1) {
3777 continue;
3778 }
3779 this->add_to_socket_map(graph_params, *bsocket, lf_node.output(lf_index));
3780 }
3781 }
3782
3783 void add_to_socket_map(BuildGraphParams &graph_params,
3784 const bNodeSocket &bsocket,
3785 lf::InputSocket &lf_socket)
3786 {
3787 graph_params.lf_inputs_by_bsocket.add(&bsocket, &lf_socket);
3788 mapping_->bsockets_by_lf_socket_map.add(&lf_socket, &bsocket);
3789 }
3790
3791 void add_to_socket_map(BuildGraphParams &graph_params,
3792 const bNodeSocket &bsocket,
3793 lf::OutputSocket &lf_socket)
3794 {
3795 graph_params.lf_output_by_bsocket.add(&bsocket, &lf_socket);
3796 mapping_->bsockets_by_lf_socket_map.add(&lf_socket, &bsocket);
3797 }
3798
3799 struct TypeWithLinks {
3800 const bke::bNodeSocketType *typeinfo;
3801 Vector<const bNodeLink *> links;
3802 };
3803
3804 void insert_links_from_socket(const bNodeSocket &from_bsocket,
3805 lf::OutputSocket &from_lf_socket,
3806 BuildGraphParams &graph_params)
3807 {
3808 if (from_bsocket.owner_node().is_dangling_reroute()) {
3809 return;
3810 }
3811
3812 const bke::bNodeSocketType &from_typeinfo = *from_bsocket.typeinfo;
3813
3814 /* Group available target sockets by type so that they can be handled together. */
3815 const Vector<TypeWithLinks> types_with_links = this->group_link_targets_by_type(from_bsocket);
3816
3817 for (const TypeWithLinks &type_with_links : types_with_links) {
3818 if (!type_with_links.typeinfo) {
3819 continue;
3820 }
3821 if (!type_with_links.typeinfo->geometry_nodes_default_value) {
3822 continue;
3823 }
3824 const bke::bNodeSocketType &to_typeinfo = *type_with_links.typeinfo;
3825 const Span<const bNodeLink *> links = type_with_links.links;
3826
3827 lf::OutputSocket *converted_from_lf_socket = this->insert_type_conversion_if_necessary(
3828 from_lf_socket, from_typeinfo, to_typeinfo, graph_params.lf_graph);
3829
3830 for (const bNodeLink *link : links) {
3831 const Vector<lf::InputSocket *> lf_link_targets = this->find_link_targets(*link,
3832 graph_params);
3833 if (converted_from_lf_socket == nullptr) {
3834 for (lf::InputSocket *to_lf_socket : lf_link_targets) {
3835 to_lf_socket->set_default_value(to_typeinfo.geometry_nodes_default_value);
3836 }
3837 }
3838 else {
3839 for (lf::InputSocket *to_lf_socket : lf_link_targets) {
3840 graph_params.lf_graph.add_link(*converted_from_lf_socket, *to_lf_socket);
3841 }
3842 }
3843 }
3844 }
3845 }
3846
3847 Vector<TypeWithLinks> group_link_targets_by_type(const bNodeSocket &from_bsocket)
3848 {
3849 const Span<const bNodeLink *> links_from_bsocket = from_bsocket.directly_linked_links();
3850 Vector<TypeWithLinks> types_with_links;
3851 for (const bNodeLink *link : links_from_bsocket) {
3852 if (link->is_muted()) {
3853 continue;
3854 }
3855 if (!link->is_available()) {
3856 continue;
3857 }
3858 const bNodeSocket &to_bsocket = *link->tosock;
3859 bool inserted = false;
3860 for (TypeWithLinks &types_with_links : types_with_links) {
3861 if (types_with_links.typeinfo == to_bsocket.typeinfo) {
3862 types_with_links.links.append(link);
3863 inserted = true;
3864 break;
3865 }
3866 }
3867 if (inserted) {
3868 continue;
3869 }
3870 types_with_links.append({to_bsocket.typeinfo, {link}});
3871 }
3872 return types_with_links;
3873 }
3874
3875 Vector<lf::InputSocket *> find_link_targets(const bNodeLink &link,
3876 const BuildGraphParams &graph_params)
3877 {
3878 if (lf::InputSocket *lf_input_socket = graph_params.lf_input_by_border_link.lookup_default(
3879 &link, nullptr))
3880 {
3881 return {lf_input_socket};
3882 }
3883
3884 const bNodeSocket &to_bsocket = *link.tosock;
3885 if (to_bsocket.is_multi_input()) {
3886 /* TODO: Cache this index on the link. */
3887 int link_index = 0;
3888 for (const bNodeLink *multi_input_link : to_bsocket.directly_linked_links()) {
3889 if (multi_input_link == &link) {
3890 break;
3891 }
3892 if (multi_input_link->is_muted() || !multi_input_link->fromsock->is_available() ||
3893 multi_input_link->fromnode->is_dangling_reroute())
3894 {
3895 continue;
3896 }
3897 link_index++;
3898 }
3899 if (to_bsocket.owner_node().is_muted()) {
3900 if (link_index == 0) {
3901 return Vector<lf::InputSocket *>(graph_params.lf_inputs_by_bsocket.lookup(&to_bsocket));
3902 }
3903 }
3904 else {
3905 lf::InputSocket *lf_multi_input_socket =
3906 graph_params.lf_input_by_multi_input_link.lookup_default(&link, nullptr);
3907 if (!lf_multi_input_socket) {
3908 return {};
3909 }
3910 return {lf_multi_input_socket};
3911 }
3912 }
3913 else {
3914 return Vector<lf::InputSocket *>(graph_params.lf_inputs_by_bsocket.lookup(&to_bsocket));
3915 }
3916 return {};
3917 }
3918
3919 lf::OutputSocket *insert_type_conversion_if_necessary(lf::OutputSocket &from_socket,
3920 const bke::bNodeSocketType &from_typeinfo,
3921 const bke::bNodeSocketType &to_typeinfo,
3922 lf::Graph &lf_graph)
3923 {
3924 if (from_typeinfo.type == to_typeinfo.type) {
3925 return &from_socket;
3926 }
3927 if (const LazyFunction *conversion_fn = build_implicit_conversion_lazy_function(
3928 from_typeinfo, to_typeinfo, scope_))
3929 {
3930 lf::Node &conversion_node = lf_graph.add_function(*conversion_fn);
3931 lf_graph.add_link(from_socket, conversion_node.input(0));
3932 return &conversion_node.output(0);
3933 }
3934 return nullptr;
3935 }
3936
3937 void add_default_inputs(BuildGraphParams &graph_params)
3938 {
3939 for (auto item : graph_params.lf_inputs_by_bsocket.items()) {
3940 const bNodeSocket &bsocket = *item.key;
3941 const Span<lf::InputSocket *> lf_sockets = item.value;
3942 for (lf::InputSocket *lf_socket : lf_sockets) {
3943 if (lf_socket->origin() != nullptr) {
3944 /* Is linked already. */
3945 continue;
3946 }
3947 this->add_default_input(bsocket, *lf_socket, graph_params);
3948 }
3949 }
3950 }
3951
3952 void add_default_input(const bNodeSocket &input_bsocket,
3953 lf::InputSocket &input_lf_socket,
3954 BuildGraphParams &graph_params)
3955 {
3956 if (this->try_add_implicit_input(input_bsocket, input_lf_socket, graph_params)) {
3957 return;
3958 }
3959 input_lf_socket.set_default_value(&scope_.add_value(
3960 input_bsocket.typeinfo->get_geometry_nodes_cpp_value(input_bsocket.default_value)));
3961 }
3962
3963 bool try_add_implicit_input(const bNodeSocket &input_bsocket,
3964 lf::InputSocket &input_lf_socket,
3965 BuildGraphParams &graph_params)
3966 {
3967 const bNode &bnode = input_bsocket.owner_node();
3968 const SocketDeclaration *socket_decl = input_bsocket.runtime->declaration;
3969 if (socket_decl == nullptr) {
3970 return false;
3971 }
3972 if (socket_decl->default_input_type == NODE_DEFAULT_INPUT_VALUE) {
3973 return false;
3974 }
3975 lf::LazyFunction *lazy_function = nullptr;
3976 if (std::optional<ImplicitInputValueFn> implicit_input_fn = get_implicit_input_value_fn(
3977 socket_decl->default_input_type))
3978 {
3979 std::function<void(void *)> init_fn = [&bnode, implicit_input_fn](void *r_value) {
3980 (*implicit_input_fn)(bnode, r_value);
3981 };
3982 const CPPType &type = input_lf_socket.type();
3983 lazy_function = &scope_.construct<LazyFunctionForImplicitInput>(type, std::move(init_fn));
3984 }
3985 else if (socket_decl->default_input_type == NODE_DEFAULT_INPUT_SCENE_FRAME) {
3986 if (input_bsocket.type == SOCK_INT) {
3987 static LazyFunctionForImplicitSceneFrame<int> scene_frame_int;
3988 lazy_function = &scene_frame_int;
3989 }
3990 else if (input_bsocket.type == SOCK_FLOAT) {
3991 static LazyFunctionForImplicitSceneFrame<float> scene_frame_float;
3992 lazy_function = &scene_frame_float;
3993 }
3994 }
3995 else if (socket_decl->default_input_type == NODE_DEFAULT_INPUT_SELF_OBJECT) {
3996 if (input_bsocket.type == SOCK_OBJECT) {
3997 static LazyFunctionForImplicitSelfObject self_object;
3998 lazy_function = &self_object;
3999 }
4000 }
4001 if (!lazy_function) {
4002 return false;
4003 }
4004 lf::Node &lf_node = graph_params.lf_graph.add_function(*lazy_function);
4005 graph_params.lf_graph.add_link(lf_node.output(0), input_lf_socket);
4006 return true;
4007 }
4008
4014 void build_root_reference_set_inputs(lf::Graph &lf_graph)
4015 {
4016 const rl::RelationsInNode &tree_relations = reference_lifetimes_.tree_relations;
4017 Vector<int> output_indices;
4018 for (const rl::DataPropagation &relation : tree_relations.data_propagations) {
4019 output_indices.append_non_duplicates(relation.to_output);
4020 }
4021
4022 for (const int i : output_indices.index_range()) {
4023 const int output_index = output_indices[i];
4024 const StringRef name = btree_.interface_outputs()[output_index]->name();
4025 lf::GraphInputSocket &lf_socket = lf_graph.add_input(
4026 CPPType::get<GeometryNodesReferenceSet>(), "Propagate: " + name);
4027 reference_set_by_output_.add(output_index, &lf_socket);
4028 }
4029 }
4030
4035 lf::OutputSocket *or_socket_usages(const Span<lf::OutputSocket *> usages,
4036 BuildGraphParams &graph_params)
4037 {
4038 if (usages.is_empty()) {
4039 return nullptr;
4040 }
4041 if (usages.size() == 1) {
4042 return usages[0];
4043 }
4044
4045 /* Sort usages to produce a deterministic key for the same set of sockets. */
4046 Vector<lf::OutputSocket *> usages_sorted(usages);
4047 std::ranges::sort(usages_sorted);
4048 return graph_params.socket_usages_combination_cache.lookup_or_add_cb(
4049 std::move(usages_sorted), [&]() {
4050 auto &logical_or_fn = scope_.construct<LazyFunctionForLogicalOr>(usages.size());
4051 lf::Node &logical_or_node = graph_params.lf_graph.add_function(logical_or_fn);
4052
4053 for (const int i : usages_sorted.index_range()) {
4054 graph_params.lf_graph.add_link(*usages_sorted[i], logical_or_node.input(i));
4055 }
4056 return &logical_or_node.output(0);
4057 });
4058 }
4059
4060 void build_output_socket_usages(const bNode &bnode, BuildGraphParams &graph_params)
4061 {
4062 /* Output sockets are used when any of their linked inputs are used. */
4063 for (const bNodeSocket *socket : bnode.output_sockets()) {
4064 if (!socket->is_available()) {
4065 continue;
4066 }
4067 /* Determine when linked target sockets are used. */
4068 Vector<lf::OutputSocket *> target_usages;
4069 for (const bNodeLink *link : socket->directly_linked_links()) {
4070 if (!link->is_used()) {
4071 continue;
4072 }
4073 const bNodeSocket &target_socket = *link->tosock;
4074 if (lf::OutputSocket *is_used_socket = graph_params.usage_by_bsocket.lookup_default(
4075 &target_socket, nullptr))
4076 {
4077 target_usages.append_non_duplicates(is_used_socket);
4078 }
4079 }
4080 /* Combine target socket usages into the usage of the current socket. */
4081 graph_params.usage_by_bsocket.add(socket,
4082 this->or_socket_usages(target_usages, graph_params));
4083 }
4084 }
4085
4086 void build_group_input_usages(BuildGraphParams &graph_params)
4087 {
4088 const Span<const bNode *> group_input_nodes = btree_.group_input_nodes();
4089 for (const int i : btree_.interface_inputs().index_range()) {
4090 Vector<lf::OutputSocket *> target_usages;
4091 for (const bNode *group_input_node : group_input_nodes) {
4092 if (lf::OutputSocket *lf_socket = graph_params.usage_by_bsocket.lookup_default(
4093 &group_input_node->output_socket(i), nullptr))
4094 {
4095 target_usages.append_non_duplicates(lf_socket);
4096 }
4097 }
4098
4099 lf::OutputSocket *lf_socket = this->or_socket_usages(target_usages, graph_params);
4100 lf::InputSocket *lf_group_output = const_cast<lf::InputSocket *>(
4101 group_input_usage_sockets_[i]);
4102 InputUsageHint input_usage_hint;
4103 if (lf_socket == nullptr) {
4104 static const bool static_false = false;
4105 lf_group_output->set_default_value(&static_false);
4106 input_usage_hint.type = InputUsageHintType::Never;
4107 }
4108 else {
4109 graph_params.lf_graph.add_link(*lf_socket, *lf_group_output);
4110 if (lf_socket->node().is_interface()) {
4111 /* Can support slightly more complex cases where it depends on more than one output in
4112 * the future. */
4113 input_usage_hint.type = InputUsageHintType::DependsOnOutput;
4114 input_usage_hint.output_dependencies = {
4115 group_output_used_sockets_.first_index_of(lf_socket)};
4116 }
4117 else {
4118 input_usage_hint.type = InputUsageHintType::DynamicSocket;
4119 }
4120 }
4121 lf_graph_info_->mapping.group_input_usage_hints.append(std::move(input_usage_hint));
4122 }
4123 }
4124
4136 void fix_link_cycles(lf::Graph &lf_graph, const Set<lf::InputSocket *> &socket_usage_inputs)
4137 {
4138 lf_graph.update_socket_indices();
4139 const int sockets_num = lf_graph.socket_num();
4140
4141 struct SocketState {
4142 bool done = false;
4143 bool in_stack = false;
4144 };
4145
4146 Array<SocketState> socket_states(sockets_num);
4147
4148 Vector<lf::Socket *> lf_sockets_to_check;
4149 for (lf::Node *lf_node : lf_graph.nodes()) {
4150 if (lf_node->is_function()) {
4151 for (lf::OutputSocket *lf_socket : lf_node->outputs()) {
4152 if (lf_socket->targets().is_empty()) {
4153 lf_sockets_to_check.append(lf_socket);
4154 }
4155 }
4156 }
4157 if (lf_node->outputs().is_empty()) {
4158 for (lf::InputSocket *lf_socket : lf_node->inputs()) {
4159 lf_sockets_to_check.append(lf_socket);
4160 }
4161 }
4162 }
4163 Vector<lf::Socket *> lf_socket_stack;
4164 while (!lf_sockets_to_check.is_empty()) {
4165 lf::Socket *lf_inout_socket = lf_sockets_to_check.last();
4166 lf::Node &lf_node = lf_inout_socket->node();
4167 SocketState &state = socket_states[lf_inout_socket->index_in_graph()];
4168
4169 if (!state.in_stack) {
4170 lf_socket_stack.append(lf_inout_socket);
4171 state.in_stack = true;
4172 }
4173
4174 Vector<lf::Socket *, 16> lf_origin_sockets;
4175 if (lf_inout_socket->is_input()) {
4176 lf::InputSocket &lf_input_socket = lf_inout_socket->as_input();
4177 if (lf::OutputSocket *lf_origin_socket = lf_input_socket.origin()) {
4178 lf_origin_sockets.append(lf_origin_socket);
4179 }
4180 }
4181 else {
4182 lf::OutputSocket &lf_output_socket = lf_inout_socket->as_output();
4183 if (lf_node.is_function()) {
4184 lf::FunctionNode &lf_function_node = static_cast<lf::FunctionNode &>(lf_node);
4185 const lf::LazyFunction &fn = lf_function_node.function();
4186 fn.possible_output_dependencies(
4187 lf_output_socket.index(), [&](const Span<int> input_indices) {
4188 for (const int input_index : input_indices) {
4189 lf_origin_sockets.append(&lf_node.input(input_index));
4190 }
4191 });
4192 }
4193 }
4194
4195 bool pushed_socket = false;
4196 bool detected_cycle = false;
4197 for (lf::Socket *lf_origin_socket : lf_origin_sockets) {
4198 if (socket_states[lf_origin_socket->index_in_graph()].in_stack) {
4199 /* A cycle has been detected. The cycle is broken by removing a link and replacing it
4200 * with a constant "true" input. This can only affect inputs which determine whether a
4201 * specific value is used. Therefore, setting it to a constant true can result in more
4202 * computation later, but does not change correctness.
4203 *
4204 * After the cycle is broken, the cycle-detection is "rolled back" to the socket where
4205 * the first socket of the cycle was found. This is necessary in case another cycle
4206 * goes through this socket. */
4207
4208 detected_cycle = true;
4209 const int index_in_socket_stack = lf_socket_stack.first_index_of(lf_origin_socket);
4210 const int index_in_sockets_to_check = lf_sockets_to_check.first_index_of(
4211 lf_origin_socket);
4212 const Span<lf::Socket *> cycle = lf_socket_stack.as_span().drop_front(
4213 index_in_socket_stack);
4214
4215 bool broke_cycle = false;
4216 for (lf::Socket *lf_cycle_socket : cycle) {
4217 if (lf_cycle_socket->is_input() &&
4218 socket_usage_inputs.contains(&lf_cycle_socket->as_input()))
4219 {
4220 lf::InputSocket &lf_cycle_input_socket = lf_cycle_socket->as_input();
4221 lf_graph.clear_origin(lf_cycle_input_socket);
4222 static const bool static_true = true;
4223 lf_cycle_input_socket.set_default_value(&static_true);
4224 broke_cycle = true;
4225 }
4226 /* This is actually removed from the stack when it is resized below. */
4227 SocketState &lf_cycle_socket_state = socket_states[lf_cycle_socket->index_in_graph()];
4228 lf_cycle_socket_state.in_stack = false;
4229 }
4230 if (!broke_cycle) {
4232 }
4233 /* Roll back algorithm by removing the sockets that corresponded to the cycle from the
4234 * stacks. */
4235 lf_socket_stack.resize(index_in_socket_stack);
4236 /* The +1 is there so that the socket itself is not removed. */
4237 lf_sockets_to_check.resize(index_in_sockets_to_check + 1);
4238 break;
4239 }
4240 if (!socket_states[lf_origin_socket->index_in_graph()].done) {
4241 lf_sockets_to_check.append(lf_origin_socket);
4242 pushed_socket = true;
4243 }
4244 }
4245 if (detected_cycle) {
4246 continue;
4247 }
4248 if (pushed_socket) {
4249 continue;
4250 }
4251
4252 state.done = true;
4253 state.in_stack = false;
4254 lf_sockets_to_check.pop_last();
4255 lf_socket_stack.pop_last();
4256 }
4257 }
4258};
4259
4261 : graph(debug_name)
4262{
4263}
4264
4265static std::shared_ptr<GeometryNodesLazyFunctionGraphInfo>
4267{
4268 btree.ensure_topology_cache();
4269 btree.ensure_interface_cache();
4270
4271 if (btree.has_available_link_cycle()) {
4272 return nullptr;
4273 }
4274 if (btree.type != NTREE_GEOMETRY) {
4275 /* It's possible to get into this situation when localizing a linked node group that is
4276 * missing (#133524). */
4277 return nullptr;
4278 }
4279 const bNodeTreeZones *tree_zones = btree.zones();
4280 if (tree_zones == nullptr) {
4281 return nullptr;
4282 }
4283 for (const bNodeTreeZone *zone : tree_zones->zones) {
4284 if (zone->input_node() == nullptr || zone->output_node() == nullptr) {
4285 /* Simulations and repeats need input and output nodes. */
4286 return nullptr;
4287 }
4288 }
4289 if (const ID *id_orig = DEG_get_original(&btree.id)) {
4290 if (id_orig->tag & ID_TAG_MISSING) {
4291 return nullptr;
4292 }
4293 }
4294 for (const bNodeTreeInterfaceSocket *interface_bsocket : btree.interface_inputs()) {
4295 const bke::bNodeSocketType *typeinfo = interface_bsocket->socket_typeinfo();
4296 if (!typeinfo || !typeinfo->geometry_nodes_default_value) {
4297 return nullptr;
4298 }
4299 }
4300 for (const bNodeTreeInterfaceSocket *interface_bsocket : btree.interface_outputs()) {
4301 const bke::bNodeSocketType *typeinfo = interface_bsocket->socket_typeinfo();
4302 if (!typeinfo || !typeinfo->geometry_nodes_default_value) {
4303 return nullptr;
4304 }
4305 }
4306
4307 /* Make a copy of the node tree so that the execution graph can be independent of the original
4308 * tree. */
4309 std::shared_ptr<bNodeTree> btree_copy{
4310 bke::node_tree_copy_tree_ex(btree, nullptr, false),
4311 [](bNodeTree *btree) { BKE_id_free(nullptr, &btree->id); }};
4312
4313 auto lf_graph_info = std::make_shared<GeometryNodesLazyFunctionGraphInfo>(
4314 BKE_id_name(btree_copy->id));
4315 lf_graph_info->tree = btree_copy;
4316
4317 if (const bNodeTree *original_tree = DEG_get_original(&btree)) {
4318 lf_graph_info->original_tree_session_uid = original_tree->id.session_uid;
4319 }
4320 else {
4321 lf_graph_info->original_tree_session_uid = btree.id.session_uid;
4322 }
4323
4324 btree_copy->ensure_topology_cache();
4325 BLI_assert(btree.all_sockets().size() == btree_copy->all_sockets().size());
4326
4327 btree_copy->runtime->self_geometry_nodes_lazy_function_graph_info = lf_graph_info.get();
4328
4329 GeometryNodesLazyFunctionBuilder builder{lf_graph_info};
4330 builder.build();
4331 return lf_graph_info;
4332}
4333
4334const std::shared_ptr<const GeometryNodesLazyFunctionGraphInfo> &
4343
4348
4349void GeoNodesLocalUserData::ensure_tree_logger(const GeoNodesUserData &user_data) const
4350{
4351 if (eval_log::NodesEvalLog *log = user_data.call_data->eval_log) {
4352 tree_logger_.emplace(&log->get_local_tree_logger(*user_data.compute_context));
4353 return;
4354 }
4355 this->tree_logger_.emplace(nullptr);
4356}
4357
4358std::optional<FoundNestedNodeID> find_nested_node_id(const GeoNodesUserData &user_data,
4359 const int node_id)
4360{
4362 *user_data.call_data->root_ntree, user_data.compute_context, node_id);
4363}
4364
4366{
4367 if (Depsgraph *graph = this->extra) {
4368 DEG_graph_free(graph);
4369 }
4370}
4371
4372static const ID *get_only_evaluated_id(const Depsgraph &depsgraph, const ID &id_orig)
4373{
4374 const ID *id = DEG_get_evaluated(&depsgraph, &id_orig);
4375 if (id == &id_orig) {
4376 return nullptr;
4377 }
4378 return id;
4379}
4380
4382{
4383 if (!ID_TYPE_USE_COPY_ON_EVAL(GS(id_orig.name))) {
4384 return &id_orig;
4385 }
4386 if (const Depsgraph *graph = this->active) {
4387 if (const ID *id = get_only_evaluated_id(*graph, id_orig)) {
4388 return id;
4389 }
4390 }
4391 if (const Depsgraph *graph = this->extra) {
4392 if (const ID *id = get_only_evaluated_id(*graph, id_orig)) {
4393 return id;
4394 }
4395 }
4396 return nullptr;
4397}
4398
4400{
4401 if (this->modifier_data) {
4402 return this->modifier_data->self_object;
4403 }
4404 if (this->operator_data) {
4406 const_cast<Object *>(this->operator_data->self_object_orig));
4407 }
4408 return nullptr;
4409}
4410
4411} // namespace blender::nodes
Low-level operations for grease pencil.
#define NODE_REROUTE
Definition BKE_node.hh:867
#define NODE_GROUP_OUTPUT
Definition BKE_node.hh:869
#define NODE_FRAME
Definition BKE_node.hh:866
#define NODE_GROUP_INPUT
Definition BKE_node.hh:868
#define NODE_EVALUATE_CLOSURE
#define GEO_NODE_MENU_SWITCH
#define GEO_NODE_GIZMO_LINEAR
#define GEO_NODE_VIEWER
#define GEO_NODE_GIZMO_DIAL
#define GEO_NODE_FOREACH_GEOMETRY_ELEMENT_OUTPUT
#define GEO_NODE_SIMULATION_OUTPUT
#define GEO_NODE_SWITCH
#define NODE_CLOSURE_OUTPUT
#define GEO_NODE_BAKE
#define GEO_NODE_WARNING
#define GEO_NODE_GIZMO_TRANSFORM
#define GEO_NODE_REPEAT_OUTPUT
#define GEO_NODE_INDEX_SWITCH
#define TIP_(msgid)
ID and Library types, which are fundamental for SDNA.
#define ID_TYPE_USE_COPY_ON_EVAL(_id_type)
Definition DNA_ID.h:746
volatile int lock
__forceinline float extract(const int4 &b)
Definition binning.cpp:27
#define BLI_assert_unreachable()
#define BLI_assert(a)
#define ELEM(...)
#define output
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 fill(const T &value) const
Definition BLI_array.hh:283
void reinitialize(const int64_t new_size)
Definition BLI_array.hh:430
static const CPPType & get()
void move_construct(void *src, void *dst) const
void ensure(const FunctionRef< void()> compute_cache)
const ComputeContext * parent() const
void print_stack(std::ostream &stream, StringRef name) const
const ComputeContextHash & hash() const
destruct_ptr< T > construct(Args &&...args)
bool add(const Key &key, const Value &value)
Definition BLI_map.hh:295
const Value & lookup(const Key &key) const
Definition BLI_map.hh:545
Value lookup_default(const Key &key, const Value &default_value) const
Definition BLI_map.hh:570
void add_new(const Key &key, const Value &value)
Definition BLI_map.hh:265
int64_t size() const
Definition BLI_map.hh:976
ItemIterator items() const &
Definition BLI_map.hh:902
T & construct(Args &&...args)
T * add(std::unique_ptr< T > resource)
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
constexpr Span take_front(int64_t n) const
Definition BLI_span.hh:197
constexpr bool is_empty() const
Definition BLI_span.hh:264
constexpr bool contains(const T &value) const
Definition BLI_span.hh:281
bool is_empty() const
Definition BLI_stack.hh:310
void push(const T &value)
Definition BLI_stack.hh:215
constexpr StringRef()
int64_t size() const
bool contains(const T &value) const
void append(const T &value)
bool is_empty() const
int64_t append_and_get_index_as(ForwardValue &&...value)
int64_t first_index_of(const T &value) const
void extend(Span< T > array)
Span< T > as_span() const
bool is_convertible(const CPPType &from_type, const CPPType &to_type) const
const mf::MultiFunction * get_conversion_multi_function(mf::DataType from, mf::DataType to) const
std::unique_ptr< GizmoEditHints > gizmo_edit_hints_
void * allocate_single(const CPPType &type)
static SocketValueVariant from(T &&value)
CacheMutex geometry_nodes_lazy_function_graph_info_mutex
std::shared_ptr< const nodes::GeometryNodesLazyFunctionGraphInfo > geometry_nodes_lazy_function_graph_info
const nodes::GeometryNodesLazyFunctionGraphInfo * self_geometry_nodes_lazy_function_graph_info
const bNode * output_node() const
Vector< const bNodeLink * > border_links
const bNode * input_node() const
Vector< const bNode * > nodes_outside_zones() const
Vector< bNodeTreeZone * > root_zones
Vector< bNodeTreeZone * > zones
const bNodeTreeZone * get_zone_by_node(const int32_t node_id) const
virtual void foreach_recursive_field(FunctionRef< void(const GField &)> fn) const
Definition field.cc:195
static FieldOperationPtr from(std::shared_ptr< const mf::MultiFunction > fn, Vector< GField > inputs)
Definition field.cc:252
const FieldInputsPtr & field_inputs() const
Definition field.cc:398
static GField from_input(Args &&...args)
Definition FN_field.hh:482
virtual BakeNodeBehavior * get(const int id) const =0
virtual SimulationZoneBehavior * get(const int zone_id) const =0
void dump_when_outputs_are_missing(const lf::FunctionNode &node, Span< const lf::OutputSocket * > missing_sockets, const lf::Context &context) const override
void dump_when_input_is_set_twice(const lf::InputSocket &target_socket, const lf::OutputSocket &from_socket, const lf::Context &context) const override
LoggingEnabledState get_logging_enabled_state(const lf::Context &context) const override
void add_thread_id_debug_message(const lf::FunctionNode &node, const lf::Context &context) const
void log_socket_value(const lf::Socket &lf_socket, const GPointer value, const lf::Context &context) const override
GeometryNodesLazyFunctionLogger(const GeometryNodesLazyFunctionGraphInfo &lf_graph_info)
void log_before_node_execute(const lf::FunctionNode &node, const lf::Params &, const lf::Context &context) const override
GeometryNodesLazyFunctionSideEffectProvider(Span< const lf::FunctionNode * > local_side_effect_nodes={})
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
void execute_impl(lf::Params &params, const lf::Context &) const override
void gather_references_from_field(const GField &field, GeometryNodesReferenceSet &r_references) const
void execute_impl(lf::Params &params, const lf::Context &) const override
void execute_impl(lf::Params &params, const lf::Context &context) const override
std::string anonymous_attribute_name_for_output(const GeoNodesUserData &user_data, const int output_index) const
void output_anonymous_attribute_field(lf::Params &params, const GeoNodesUserData &user_data, const int lf_index, const bNodeSocket &socket) const
LazyFunctionForGeometryNode(const bNode &node, GeometryNodesLazyFunctionGraphInfo &own_lf_graph_info)
std::string input_name(const int index) const override
std::string output_name(const int index) const override
LazyFunctionForGizmoInputsUsage(const bNode &gizmo_node, const lf::FunctionNode &lf_gizmo_node)
void execute_impl(lf::Params &params, const lf::Context &context) const override
void execute_impl(lf::Params &params, const lf::Context &context) const override
LazyFunctionForGizmoNode(const bNode &bnode, MutableSpan< int > r_lf_index_by_bsocket)
std::string output_name(const int i) const override
LazyFunctionForGroupNode(const bNode &group_node, const GeometryNodesLazyFunctionGraphInfo &group_lf_graph_info, GeometryNodesLazyFunctionGraphInfo &own_lf_graph_info)
void * init_storage(LinearAllocator<> &allocator) const override
std::string input_name(const int i) const override
void execute_impl(lf::Params &params, const lf::Context &context) const override
void execute_impl(lf::Params &params, const lf::Context &) const override
LazyFunctionForImplicitConversion(const MultiFunction &fn, const bke::bNodeSocketType &dst_type)
void execute_impl(lf::Params &params, const lf::Context &) const override
LazyFunctionForImplicitInput(const CPPType &type, std::function< void(void *)> init_fn)
void execute_impl(lf::Params &params, const lf::Context &context) const override
void execute_impl(lf::Params &params, const lf::Context &context) const override
void execute_impl(lf::Params &params, const lf::Context &) const override
void execute_impl(lf::Params &params, const lf::Context &) const override
static const LazyFunctionForJoinReferenceSets & get_cached(const int amount, ResourceScope &scope)
void execute_impl(lf::Params &params, const lf::Context &context) const override
LazyFunctionForMultiFunctionNode(const bNode &node, NodeMultiFunctions::Item fn_item, MutableSpan< int > r_lf_index_by_bsocket)
void execute_impl(lf::Params &params, const lf::Context &context) const override
void execute_impl(lf::Params &params, const lf::Context &) const override
void execute_impl(lf::Params &params, const lf::Context &) const override
LazyFunctionForMutedNode(const bNode &node, MutableSpan< int > r_lf_index_by_bsocket)
void execute_impl(lf::Params &params, const lf::Context &) const override
void execute_impl(lf::Params &params, const lf::Context &context) const override
void * init_storage(LinearAllocator<> &allocator) const override
void execute_impl(lf::Params &params, const lf::Context &context) const override
LazyFunctionForSimulationZone(const bNode &sim_output_bnode, const LazyFunction &fn)
void execute_impl(lf::Params &params, const lf::Context &) const override
LazyFunctionForUndefinedNode(const bNode &node, MutableSpan< int > r_lf_index_by_bsocket)
void execute_impl(lf::Params &params, const lf::Context &) const override
void execute_impl(lf::Params &params, const lf::Context &context) const override
LazyFunctionForViewerInputUsage(const lf::FunctionNode &lf_viewer_node)
LazyFunctionForViewerNode(const bNode &bnode, MutableSpan< int > r_lf_index_by_bsocket)
void execute_impl(lf::Params &params, const lf::Context &context) const override
const rl::RelationsInNode * reference_lifetime_relations() const
Vector< SocketDeclaration * > outputs
const Item & try_get(const bNode &node) const
static SocketValueVariant & construct_in(void *ptr, T &&value)
static SocketValueVariant from(T &&value)
Vector< const bNode * > child_nodes() const
const bNode * output_node() const
Vector< const bNodeLink * > border_links
Vector< bNodeTreeZone * > child_zones
const bNode * input_node() const
linear_allocator::ChunkedList< ViewerNodeLogWithNode > viewer_node_logs
linear_allocator::ChunkedList< DebugMessage > debug_messages
linear_allocator::ChunkedList< WarningWithNode > node_warnings
void log_value(const bNode &node, const bNodeSocket &socket, GPointer value)
Definition eval_log.cc:319
#define storage(slot, qualifiers)
#define index(i)
#define condition(cond)
#define log
uint to_type(bool)
const int state
#define T
bool contains(const VArray< bool > &varray, const IndexMask &indices_to_check, bool value)
bool attribute_name_is_anonymous(const StringRef name)
const DataTypeConversions & get_implicit_type_conversions()
bNodeTree * node_tree_copy_tree_ex(const bNodeTree &ntree, Main *bmain, bool do_id_user)
Definition node.cc:5013
std::string hash_to_anonymous_attribute_name(Args &&...args)
std::optional< nodes::FoundNestedNodeID > find_nested_node_id_in_root(const SpaceNode &snode, const bNode &node)
ImplicitSharingPtr< FieldInputs > FieldInputsPtr
Definition FN_field.hh:45
static const ID * get_only_evaluated_id(const Depsgraph &depsgraph, const ID &id_orig)
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)
std::unique_ptr< LazyFunction > get_simulation_output_lazy_function(const bNode &node, GeometryNodesLazyFunctionGraphInfo &own_lf_graph_info)
std::unique_ptr< LazyFunction > get_index_switch_node_lazy_function(const bNode &node, GeometryNodesLazyFunctionGraphInfo &lf_graph_info)
LazyFunction & build_closure_zone_lazy_function(ResourceScope &scope, const bNodeTree &btree, const bke::bNodeTreeZone &zone, ZoneBuildInfo &zone_info, const ZoneBodyFunction &body_fn, std::shared_ptr< GeometryNodesLazyFunctionGraphInfo > &lf_graph_info)
std::unique_ptr< LazyFunction > get_warning_node_lazy_function(const bNode &node)
std::optional< ImplicitInputValueFn > get_implicit_input_value_fn(const NodeDefaultInputType type)
static bool ignore_zone_bsocket(const bNodeSocket &bsocket)
void construct_socket_default_value(const bke::bNodeSocketType &stype, void *r_value)
std::unique_ptr< LazyFunction > get_menu_switch_node_socket_usage_lazy_function(const bNode &node)
bool execute_multi_function_on_value_variant__list(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)
std::unique_ptr< LazyFunction > get_simulation_input_lazy_function(const bNodeTree &node_tree, const bNode &node, GeometryNodesLazyFunctionGraphInfo &own_lf_graph_info)
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)
const LazyFunction * build_implicit_conversion_lazy_function(const bke::bNodeSocketType &from_type, const bke::bNodeSocketType &to_type, ResourceScope &scope)
bool should_log_verbose_in_context(const GeoNodesUserData &user_data, const ComputeContextHash hash)
Map< Vector< lf::OutputSocket * >, lf::OutputSocket * > JoinReferenceSetsCache
std::optional< SocketValueVariant > implicitly_convert_socket_value(const bke::bNodeSocketType &from_type, const SocketValueVariant &from_value, const bke::bNodeSocketType &to_type)
LazyFunction & build_repeat_zone_lazy_function(ResourceScope &scope, const bNodeTree &btree, const bke::bNodeTreeZone &zone, ZoneBuildInfo &zone_info, const ZoneBodyFunction &body_fn)
std::unique_ptr< LazyFunction > get_switch_node_lazy_function(const bNode &node)
std::string make_anonymous_attribute_socket_inspection_string(const bNodeSocket &socket)
std::unique_ptr< LazyFunction > get_bake_lazy_function(const bNode &node, GeometryNodesLazyFunctionGraphInfo &lf_graph_info)
const std::shared_ptr< const GeometryNodesLazyFunctionGraphInfo > & ensure_geometry_nodes_lazy_function_graph(const bNodeTree &btree)
std::optional< FoundNestedNodeID > find_nested_node_id(const GeoNodesUserData &user_data, const int node_id)
void set_default_remaining_node_outputs(lf::Params &params, const bNode &node)
void report_from_multi_function(const mf::Context &context, NodeWarningType type, std::string message)
std::unique_ptr< LazyFunction > get_menu_switch_node_boolean_outputs_lazy_function(const bNode &node, GeometryNodesLazyFunctionGraphInfo &lf_graph_info)
static bool gizmo_is_used(const GeoNodesUserData &user_data, const lf::FunctionNode &lf_gizmo_node)
static void execute_multi_function_on_value_variant__single(const MultiFunction &fn, const Span< SocketValueVariant * > input_values, const Span< SocketValueVariant * > output_values, GeoNodesUserData *user_data)
std::unique_ptr< LazyFunction > get_enable_output_node_lazy_function(const bNode &node, GeometryNodesLazyFunctionGraphInfo &own_lf_graph_info)
void set_default_value_for_output_socket(lf::Params &params, const int lf_index, const bNodeSocket &bsocket)
bool execute_multi_function_on_value_variant__volume_grid(const mf::MultiFunction &, const Span< bke::SocketValueVariant * >, const Span< bke::SocketValueVariant * >, std::string &r_error_message)
std::string zone_wrapper_output_name(const ZoneBuildInfo &zone_info, const bNodeTreeZone &zone, const Span< lf::Output > outputs, const int lf_socket_i)
std::unique_ptr< LazyFunction > get_menu_switch_node_lazy_function(const bNode &node, GeometryNodesLazyFunctionGraphInfo &lf_graph_info)
LazyFunction & build_foreach_geometry_element_zone_lazy_function(ResourceScope &scope, const bNodeTree &btree, const bke::bNodeTreeZone &zone, ZoneBuildInfo &zone_info, const ZoneBodyFunction &body_fn)
static void lazy_function_interface_from_node(const bNode &node, Vector< lf::Input > &r_inputs, Vector< lf::Output > &r_outputs, MutableSpan< int > r_lf_index_by_bsocket)
static std::shared_ptr< GeometryNodesLazyFunctionGraphInfo > ensure_geometry_nodes_lazy_function_graph_impl(const bNodeTree &btree)
static void execute_multi_function_on_value_variant__field(const MultiFunction &fn, const std::shared_ptr< MultiFunction > &owned_fn, const Span< SocketValueVariant * > input_values, const Span< SocketValueVariant * > output_values)
std::string zone_wrapper_input_name(const ZoneBuildInfo &zone_info, const bNodeTreeZone &zone, const Span< lf::Input > inputs, const int lf_socket_i)
EvaluateClosureFunction build_evaluate_closure_node_lazy_function(ResourceScope &scope, const bNode &bnode)
void geo_viewer_node_log(const bNode &node, const Span< bke::SocketValueVariant * > input_values, eval_log::ViewerNodeLog &r_log)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void DEG_graph_free(Depsgraph *graph)
Definition depsgraph.cc:307
std::unique_ptr< T, DestructValueAtAddress< T > > destruct_ptr
const char * BKE_id_name(const ID &id)
T * DEG_get_evaluated(const Depsgraph *depsgraph, T *id)
void BKE_id_free(Main *bmain, void *idv)
T * DEG_get_original(T *id)
float BKE_scene_ctime_get(const Scene *scene)
Definition scene.cc:2581
std::mutex Mutex
Definition BLI_mutex.hh:51
ID_Type GS(const char *name)
Definition DNA_ID.h:410
Scene * DEG_get_input_scene(const Depsgraph *graph)
@ ID_TAG_MISSING
Definition DNA_ID.h:870
#define I
#define hash
Definition noise_c.cc:156
char name[258]
Definition DNA_ID.h:433
unsigned int session_uid
Definition DNA_ID.h:463
bke::bNodeSocketType * typeinfo
bke::bNodeTreeType * typeinfo
eNodeTree_Type type
bke::bNodeTreeRuntime * runtime
Defines a socket type.
Definition BKE_node.hh:163
const CPPType * base_cpp_type
Definition BKE_node.hh:210
eNodeSocketDatatype type
Definition BKE_node.hh:198
const SocketValueVariant * geometry_nodes_default_value
Definition BKE_node.hh:216
MultiValueMap< ReferenceSetIndex, lf::InputSocket * > lf_reference_set_inputs
Map< Vector< lf::OutputSocket * >, lf::OutputSocket * > socket_usages_combination_cache
Map< const bNodeSocket *, lf::OutputSocket * > lf_output_by_bsocket
Map< const bNodeLink *, lf::InputSocket * > lf_input_by_border_link
MultiValueMap< const bNodeSocket *, lf::InputSocket * > lf_inputs_by_bsocket
Map< const bNodeSocket *, lf::OutputSocket * > usage_by_bsocket
Map< const bNodeSocket *, lf::InputSocket * > lf_reference_set_input_by_output
Map< const bNodeLink *, lf::InputSocket * > lf_input_by_multi_input_link
const Set< ComputeContextHash > * verbose_log_contexts
const GeoNodesSideEffectNodes * side_effect_nodes
MultiValueMap< ComputeContextHash, const lf::FunctionNode * > nodes_by_context
destruct_ptr< fn::LocalUserData > get_local(LinearAllocator<> &allocator) override
MultiValueMap< const lf::Socket *, const bNodeSocket * > bsockets_by_lf_socket_map
struct blender::nodes::GeometryNodesGroupFunction::@172250372114350111302221310316304130074374314150 inputs
GeometryNodesLazyFunctionBuilder(std::shared_ptr< GeometryNodesLazyFunctionGraphInfo > &lf_graph_info)
struct blender::nodes::ZoneFunctionIndices::@132143137367244025376024316142102322341106322023 outputs
struct blender::nodes::ZoneFunctionIndices::@342054057300321050315260123310012173322070035365 inputs