Blender V5.3
geometry_nodes_closure_zone.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2025 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <fmt/format.h>
10
13
16#include "BKE_node_runtime.hh"
19
20#include "NOD_geo_closure.hh"
23
25
27
29
30namespace blender::nodes {
31
32using bke::node_tree_reference_lifetimes::ReferenceSetInfo;
34
42class ClosureIntermediateGraphSideEffectProvider : public lf::GraphExecutorSideEffectProvider {
43 private:
48 const lf::FunctionNode *body_node_;
49
50 public:
51 ClosureIntermediateGraphSideEffectProvider(const lf::FunctionNode &body_node)
52 : body_node_(&body_node)
53 {
54 }
55
57 const lf::Context &context) const override
58 {
59 const GeoNodesUserData &user_data = *dynamic_cast<GeoNodesUserData *>(context.user_data);
60 const ComputeContextHash &context_hash = user_data.compute_context->hash();
61 if (!user_data.call_data->side_effect_nodes) {
62 /* There are no requested side effect nodes at all. */
63 return {};
64 }
65 const Span<const lf::FunctionNode *> side_effect_nodes_in_closure =
66 user_data.call_data->side_effect_nodes->nodes_by_context.lookup(context_hash);
67 if (side_effect_nodes_in_closure.is_empty()) {
68 /* The closure does not have any side effect nodes, so the wrapper also does not have any. */
69 return {};
70 }
71 return {body_node_};
72 }
73};
74
79class LazyFunctionForClosureZone : public LazyFunction {
80 private:
81 const bNodeTree &btree_;
82 const bke::bNodeTreeZone &zone_;
83 const bNode &output_bnode_;
84 const ZoneBuildInfo &zone_info_;
85 const ZoneBodyFunction &body_fn_;
86 std::shared_ptr<ClosureSignature> closure_signature_;
92 std::weak_ptr<const GeometryNodesLazyFunctionGraphInfo> lf_graph_info_;
93
94 public:
96 const bke::bNodeTreeZone &zone,
97 ZoneBuildInfo &zone_info,
98 const ZoneBodyFunction &body_fn,
99 std::shared_ptr<GeometryNodesLazyFunctionGraphInfo> &lf_graph_info)
100 : btree_(btree),
101 zone_(zone),
102 output_bnode_(*zone.output_node()),
103 zone_info_(zone_info),
104 body_fn_(body_fn),
105 lf_graph_info_(lf_graph_info)
106 {
107 debug_name_ = "Closure Zone";
108
109 initialize_zone_wrapper(zone, zone_info, body_fn, false, inputs_, outputs_);
110 for (const auto item : body_fn.indices.inputs.reference_sets.items()) {
111 const ReferenceSetInfo &reference_set =
112 btree.runtime->reference_lifetimes_info->reference_sets[item.key];
114 BLI_assert(&reference_set.socket->owner_node() != zone_.input_node());
115 }
116 if (reference_set.type == ReferenceSetType::ClosureOutputData) {
117 if (&reference_set.socket->owner_node() == zone_.output_node()) {
118 /* This reference set comes from the caller of the closure and is not captured at the
119 * place where the closure is created. */
120 continue;
121 }
122 }
123 zone_info.indices.inputs.reference_sets.add_new(
124 item.key,
125 inputs_.append_and_get_index_as("Reference Set",
127 }
128
129 /* All border links are used. */
130 for (const int i : zone_.border_links.index_range()) {
131 inputs_[zone_info.indices.inputs.border_links[i]].usage = lf::ValueUsage::Used;
132 }
133
134 const auto &storage = *static_cast<const NodeClosureOutput *>(output_bnode_.storage);
135
136 closure_signature_ = std::make_shared<ClosureSignature>();
137
138 for (const int i : IndexRange(storage.input_items.items_num)) {
139 const bNodeSocket &bsocket = zone_.input_node()->output_socket(i);
140 closure_signature_->inputs.add({bsocket.name, bsocket.typeinfo});
141 }
142 for (const int i : IndexRange(storage.output_items.items_num)) {
143 const bNodeSocket &bsocket = zone_.output_node()->input_socket(i);
144 closure_signature_->outputs.add({bsocket.name, bsocket.typeinfo});
145 }
146 }
147
148 void execute_impl(lf::Params &params, const lf::Context &context) const override
149 {
150 auto &user_data = *static_cast<GeoNodesUserData *>(context.user_data);
151
152 /* All border links are captured currently. */
153 for (const int i : zone_.border_links.index_range()) {
154 params.set_output(zone_info_.indices.outputs.border_link_usages[i], true);
155 }
156
157 const auto &storage = *static_cast<const NodeClosureOutput *>(output_bnode_.storage);
158
159 std::unique_ptr<ResourceScope> closure_scope = std::make_unique<ResourceScope>();
160
161 lf::Graph &lf_graph = closure_scope->construct<lf::Graph>("Closure Graph");
162 lf::FunctionNode &lf_body_node = lf_graph.add_function(*body_fn_.function);
163 ClosureFunctionIndices closure_indices;
164 Vector<bke::SocketValueVariant> default_input_values;
165
166 for (const int i : IndexRange(storage.input_items.items_num)) {
167 const NodeClosureInputItem &item = storage.input_items.items[i];
168 const bNodeSocket &bsocket = zone_.input_node()->output_socket(i);
169
170 lf::GraphInputSocket &lf_graph_input = lf_graph.add_input(
172 lf_graph.add_link(lf_graph_input, lf_body_node.input(body_fn_.indices.inputs.main[i]));
173
174 lf::GraphOutputSocket &lf_graph_input_usage = lf_graph.add_output(
175 CPPType::get<bool>(), "Usage: " + StringRef(item.name));
176 lf_graph.add_link(lf_body_node.output(body_fn_.indices.outputs.input_usages[i]),
177 lf_graph_input_usage);
178
179 default_input_values.append(*bsocket.typeinfo->geometry_nodes_default_value);
180 }
181 closure_indices.inputs.main = lf_graph.graph_inputs().index_range().take_back(
182 storage.input_items.items_num);
183 closure_indices.outputs.input_usages = lf_graph.graph_outputs().index_range().take_back(
184 storage.input_items.items_num);
185
186 for (const int i : IndexRange(storage.output_items.items_num)) {
187 const NodeClosureOutputItem &item = storage.output_items.items[i];
188
189 lf::GraphOutputSocket &lf_graph_output = lf_graph.add_output(
191 lf_graph.add_link(lf_body_node.output(body_fn_.indices.outputs.main[i]), lf_graph_output);
192
193 lf::GraphInputSocket &lf_graph_output_usage = lf_graph.add_input(
194 CPPType::get<bool>(), "Usage: " + StringRef(item.name));
195 lf_graph.add_link(lf_graph_output_usage,
196 lf_body_node.input(body_fn_.indices.inputs.output_usages[i]));
197 }
198 closure_indices.outputs.main = lf_graph.graph_outputs().index_range().take_back(
199 storage.output_items.items_num);
200 closure_indices.inputs.output_usages = lf_graph.graph_inputs().index_range().take_back(
201 storage.output_items.items_num);
202
204 for (const int i : zone_.border_links.index_range()) {
205 bke::SocketValueVariant *input_ptr = params.try_get_input_data_ptr<bke::SocketValueVariant>(
206 zone_info_.indices.inputs.border_links[i]);
207 bke::SocketValueVariant &stored_ptr = closure_scope->construct<bke::SocketValueVariant>(
208 std::move(*input_ptr));
209 /* The value is captured here and we need to make sure that it doesn't reference data which
210 * may become dangling. */
211 stored_ptr.ensure_owns_direct_data();
212 captured_values.append(&stored_ptr);
213 lf_body_node.input(body_fn_.indices.inputs.border_links[i]).set_default_value(&stored_ptr);
214 }
215
216 for (const auto &item : body_fn_.indices.inputs.reference_sets.items()) {
217 const ReferenceSetInfo &reference_set =
218 btree_.runtime->reference_lifetimes_info->reference_sets[item.key];
219 if (reference_set.type == ReferenceSetType::ClosureOutputData) {
220 const bNodeSocket &socket = *reference_set.socket;
221 const bNode &node = socket.owner_node();
222 if (&node == zone_.output_node()) {
223 /* This reference set is passed in by the code that invokes the closure. */
224 lf::GraphInputSocket &lf_graph_input = lf_graph.add_input(
226 StringRef("Reference Set: ") + reference_set.socket->name);
227 lf_graph.add_link(
228 lf_graph_input,
229 lf_body_node.input(body_fn_.indices.inputs.reference_sets.lookup(item.key)));
230 closure_indices.inputs.output_data_reference_sets.add_new(reference_set.socket->index(),
231 lf_graph_input.index());
232 continue;
233 }
234 }
235
236 auto &input_reference_set = *params.try_get_input_data_ptr<bke::GeometryNodesReferenceSet>(
237 zone_info_.indices.inputs.reference_sets.lookup(item.key));
238 auto &stored = closure_scope->construct<bke::GeometryNodesReferenceSet>(
239 std::move(input_reference_set));
240 lf_body_node.input(body_fn_.indices.inputs.reference_sets.lookup(item.key))
241 .set_default_value(&stored);
242 }
243
244 const bNodeTree &btree_orig = *DEG_get_original(&btree_);
245 if (btree_orig.runtime->logged_zone_graphs) {
246 std::lock_guard lock{btree_orig.runtime->logged_zone_graphs->mutex};
247 btree_orig.runtime->logged_zone_graphs->graph_by_zone_id.lookup_or_add_cb(
248 output_bnode_.identifier, [&]() { return lf_graph.to_dot(); });
249 }
250
251 lf_graph.update_node_indices();
252
253 /* This is expected to work when the closure is created. */
254 std::shared_ptr<const GeometryNodesLazyFunctionGraphInfo> lf_graph_info =
255 lf_graph_info_.lock();
256 BLI_assert(lf_graph_info);
257 /* The closure has to take ownership of its execution information. */
258 closure_scope->add(std::move(lf_graph_info));
259
260 const auto &side_effect_provider =
261 closure_scope->construct<ClosureIntermediateGraphSideEffectProvider>(lf_body_node);
262 lf::GraphExecutor &lf_graph_executor = closure_scope->construct<lf::GraphExecutor>(
263 lf_graph, nullptr, &side_effect_provider, nullptr);
264 ClosureSourceLocation source_location{
265 &btree_,
266 output_bnode_.identifier,
267 user_data.compute_context->hash(),
268 };
269 ClosurePtr closure{MEM_new<Closure>(__func__,
270 closure_signature_,
271 std::move(closure_scope),
272 lf_graph_executor,
273 closure_indices,
274 std::move(default_input_values),
275 source_location,
276 std::make_shared<ClosureEvalLog>(),
277 std::move(captured_values))};
278
279 params.set_output(zone_info_.indices.outputs.main[0],
280 bke::SocketValueVariant::from(std::move(closure)));
281 }
282};
283
287 lf::Graph graph;
288 std::optional<lf::GraphExecutor> graph_executor;
289 std::optional<ClosureIntermediateGraphSideEffectProvider> side_effect_provider;
290 void *graph_executor_storage = nullptr;
291};
292
298class LazyFunctionForEvaluateClosureNode : public LazyFunction {
299 private:
300 const bNodeTree &btree_;
301 const bNode &bnode_;
303
304 public:
306 : btree_(bnode.owner_tree()), bnode_(bnode)
307 {
308 debug_name_ = bnode.name;
309 for (const int i : bnode.input_sockets().index_range().drop_back(1)) {
310 const bNodeSocket &bsocket = bnode.input_socket(i);
311 indices_.inputs.main.append(inputs_.append_and_get_index_as(
312 bsocket.name, CPPType::get<bke::SocketValueVariant>(), lf::ValueUsage::Maybe));
313 indices_.outputs.input_usages.append(
314 outputs_.append_and_get_index_as("Usage", CPPType::get<bool>()));
315 }
316 /* The closure input is always used. */
317 inputs_[indices_.inputs.main[0]].usage = lf::ValueUsage::Used;
318 for (const int i : bnode.output_sockets().index_range().drop_back(1)) {
319 const bNodeSocket &bsocket = bnode.output_socket(i);
320 indices_.outputs.main.append(
321 outputs_.append_and_get_index_as(bsocket.name, CPPType::get<bke::SocketValueVariant>()));
322 indices_.inputs.output_usages.append(
323 inputs_.append_and_get_index_as("Usage", CPPType::get<bool>(), lf::ValueUsage::Maybe));
324 if (bke::node_tree_reference_lifetimes::can_contain_referenced_data(bsocket.type)) {
325 const int input_i = inputs_.append_and_get_index_as(
326 "Reference Set",
327 CPPType::get<bke::GeometryNodesReferenceSet>(),
328 lf::ValueUsage::Maybe);
329 indices_.inputs.reference_set_by_output.add(i, input_i);
330 }
331 }
332 }
333
335 {
336 return indices_;
337 }
338
339 void *init_storage(LinearAllocator<> &allocator) const override
340 {
341 return allocator.construct<EvaluateClosureEvalStorage>().release();
342 }
343
344 void destruct_storage(void *storage) const override
345 {
346 auto *s = static_cast<EvaluateClosureEvalStorage *>(storage);
347 if (s->graph_executor_storage) {
348 s->graph_executor->destruct_storage(s->graph_executor_storage);
349 }
350 std::destroy_at(s);
351 }
352
353 void execute_impl(lf::Params &params, const lf::Context &context) const override
354 {
355 const ScopedNodeTimer node_timer{context, bnode_};
356
357 auto &user_data = *static_cast<GeoNodesUserData *>(context.user_data);
358 auto &eval_storage = *static_cast<EvaluateClosureEvalStorage *>(context.storage);
359 auto local_user_data = *static_cast<GeoNodesLocalUserData *>(context.local_user_data);
360
361 if (!eval_storage.graph_executor) {
362 eval_storage.closure = params.extract_input<bke::SocketValueVariant>(indices_.inputs.main[0])
364 if (eval_storage.closure) {
365 if (user_data.is_stack_limit_reached()) {
366 this->initialize_pass_through_graph(eval_storage);
367 if (eval_log::NodeTreeLogger *tree_logger = local_user_data.try_get_tree_logger(
368 user_data))
369 {
370 tree_logger->node_warnings.append(
371 *tree_logger->allocator,
372 {bnode_.identifier,
373 {NodeWarningType::Error,
374 TIP_("Stack limit reached. Closure becomes pass-through.")}});
375 }
376 }
377 else {
378 this->generate_closure_compatibility_warnings(*eval_storage.closure, context);
379 this->initialize_execution_graph(eval_storage);
380
381 const bNodeTree &btree_orig = *DEG_get_original(&btree_);
382 ClosureEvalLocation eval_location{
383 btree_orig.id.session_uid, bnode_.identifier, user_data.compute_context->hash()};
384 eval_storage.closure->log_evaluation(eval_location);
385 }
386 }
387 else {
388 /* If no closure is provided, the Evaluate Closure node behaves as if it was muted. So some
389 * values may be passed through if there are internal links. */
390 this->initialize_pass_through_graph(eval_storage);
391 }
392 }
393
394 const std::optional<ClosureSourceLocation> closure_source_location =
395 eval_storage.closure ? eval_storage.closure->source_location() : std::nullopt;
396
397 bke::EvaluateClosureComputeContext closure_compute_context{
398 user_data.compute_context, bnode_.identifier, &btree_, closure_source_location};
399 GeoNodesUserData closure_user_data = user_data;
400 closure_user_data.compute_context = &closure_compute_context;
401 closure_user_data.verbose_log = should_log_verbose_in_context(user_data,
402 closure_compute_context.hash());
403 GeoNodesLocalUserData closure_local_user_data{closure_user_data};
404
405 lf::Context eval_graph_context{
406 eval_storage.graph_executor_storage, &closure_user_data, &closure_local_user_data};
407 eval_storage.graph_executor->execute(params, eval_graph_context);
408 }
409
410 bool is_recursive_call(const GeoNodesUserData &user_data) const
411 {
412 for (const ComputeContext *context = user_data.compute_context; context;
413 context = context->parent())
414 {
415 if (const auto *closure_context = dynamic_cast<const bke::EvaluateClosureComputeContext *>(
416 context))
417 {
418 if (closure_context->node() == &bnode_) {
419 return true;
420 }
421 }
422 }
423 return false;
424 }
425
426 void set_default_outputs(lf::Params &params) const
427 {
428 for (const bNodeSocket *bsocket : bnode_.output_sockets().drop_back(1)) {
429 const int index = bsocket->index();
430 set_default_value_for_output_socket(params, indices_.outputs.main[index], *bsocket);
431 }
432 for (const bNodeSocket *bsocket : bnode_.input_sockets().drop_back(1)) {
433 params.set_output(indices_.outputs.input_usages[bsocket->index()], false);
434 }
435 }
436
438 const lf::Context &context) const
439 {
440 const auto &node_storage = *static_cast<const NodeEvaluateClosure *>(bnode_.storage);
441 const auto &user_data = *static_cast<GeoNodesUserData *>(context.user_data);
442 const auto &local_user_data = *static_cast<GeoNodesLocalUserData *>(context.local_user_data);
443 eval_log::NodeTreeLogger *tree_logger = local_user_data.try_get_tree_logger(user_data);
444 if (tree_logger == nullptr) {
445 return;
446 }
447 const ClosureSignature &signature = closure.signature();
448 for (const NodeEvaluateClosureInputItem &item :
449 Span{node_storage.input_items.items, node_storage.input_items.items_num})
450 {
451 const bke::bNodeSocketType *item_type = bke::node_socket_type_find_static(item.socket_type);
452 if (const std::optional<int> i = signature.find_input_index(item.name)) {
453 const ClosureSignature::Item &closure_item = signature.inputs[*i];
454 if (!btree_.typeinfo->validate_link(item.socket_type, closure_item.type->type)) {
455 tree_logger->node_warnings.append(
456 *tree_logger->allocator,
457 {bnode_.identifier,
458 {NodeWarningType::Error,
459 fmt::format("{}: {} \"{}\" ({} " BLI_STR_UTF8_BLACK_RIGHT_POINTING_SMALL_TRIANGLE
460 " {})",
461 TIP_("Conversion not supported when evaluating closure"),
462 TIP_("Input"),
463 item.name,
464 TIP_(item_type->label),
465 TIP_(closure_item.type->label))}});
466 }
467 else if (item.socket_type != closure_item.type->type) {
468 tree_logger->node_warnings.append(
469 *tree_logger->allocator,
470 {bnode_.identifier,
471 {NodeWarningType::Info,
472 fmt::format("{}: {} \"{}\" ({} " BLI_STR_UTF8_BLACK_RIGHT_POINTING_SMALL_TRIANGLE
473 " {})",
474 TIP_("Implicit type conversion when evaluating closure"),
475 TIP_("Input"),
476 item.name,
477 TIP_(item_type->label),
478 TIP_(closure_item.type->label))}});
479 }
480 }
481 else {
482 tree_logger->node_warnings.append(
483 *tree_logger->allocator,
484 {bnode_.identifier,
485 {
486 NodeWarningType::Error,
487 fmt::format(fmt::runtime(TIP_("Closure does not have input: \"{}\"")), item.name),
488 }});
489 }
490 }
491 for (const NodeEvaluateClosureOutputItem &item :
492 Span{node_storage.output_items.items, node_storage.output_items.items_num})
493 {
494 const bke::bNodeSocketType *item_type = bke::node_socket_type_find_static(item.socket_type);
495 if (const std::optional<int> i = signature.find_output_index(item.name)) {
496 const ClosureSignature::Item &closure_item = signature.outputs[*i];
497 if (!btree_.typeinfo->validate_link(closure_item.type->type, item.socket_type)) {
498 tree_logger->node_warnings.append(
499 *tree_logger->allocator,
500 {bnode_.identifier,
501 {NodeWarningType::Error,
502 fmt::format("{}: {} \"{}\" ({} " BLI_STR_UTF8_BLACK_RIGHT_POINTING_SMALL_TRIANGLE
503 " {})",
504 TIP_("Conversion not supported when evaluating closure"),
505 TIP_("Output"),
506 item.name,
507 TIP_(closure_item.type->label),
508 TIP_(item_type->label))}});
509 }
510 else if (item.socket_type != closure_item.type->type) {
511 tree_logger->node_warnings.append(
512 *tree_logger->allocator,
513 {bnode_.identifier,
514 {NodeWarningType::Info,
515 fmt::format("{}: {} \"{}\" ({} " BLI_STR_UTF8_BLACK_RIGHT_POINTING_SMALL_TRIANGLE
516 " {})",
517 TIP_("Implicit type conversion when evaluating closure"),
518 TIP_("Output"),
519 item.name,
520 TIP_(closure_item.type->label),
521 TIP_(item_type->label))}});
522 }
523 }
524 else {
525 tree_logger->node_warnings.append(
526 *tree_logger->allocator,
527 {bnode_.identifier,
528 {NodeWarningType::Error,
529 fmt::format(fmt::runtime(TIP_("Closure does not have output: \"{}\"")),
530 item.name)}});
531 }
532 }
533 }
534
536 {
537 const auto &node_storage = *static_cast<const NodeEvaluateClosure *>(bnode_.storage);
538
539 lf::Graph &lf_graph = eval_storage.graph;
540
541 for (const lf::Input &input : inputs_) {
542 lf_graph.add_input(*input.type, input.debug_name);
543 }
544 for (const lf::Output &output : outputs_) {
545 lf_graph.add_output(*output.type, output.debug_name);
546 }
547 const Span<lf::GraphInputSocket *> lf_graph_inputs = lf_graph.graph_inputs();
548 const Span<lf::GraphOutputSocket *> lf_graph_outputs = lf_graph.graph_outputs();
549
550 const Closure &closure = *eval_storage.closure;
551 const ClosureSignature &closure_signature = closure.signature();
552 const ClosureFunctionIndices &closure_indices = closure.indices();
553
554 Array<std::optional<int>> inputs_map(node_storage.input_items.items_num);
555 for (const int i : inputs_map.index_range()) {
556 inputs_map[i] = closure_signature.find_input_index(node_storage.input_items.items[i].name);
557 }
558 Array<std::optional<int>> outputs_map(node_storage.output_items.items_num);
559 for (const int i : outputs_map.index_range()) {
560 outputs_map[i] = closure_signature.find_output_index(
561 node_storage.output_items.items[i].name);
562 }
563
564 lf::FunctionNode &lf_closure_node = lf_graph.add_function(closure.function());
565
566 static constexpr bool static_true = true;
567 static constexpr bool static_false = false;
568 /* The closure input is always used. */
569 lf_graph_outputs[indices_.outputs.input_usages[0]]->set_default_value(&static_true);
570
571 for (const int input_item_i : IndexRange(node_storage.input_items.items_num)) {
572 lf::GraphOutputSocket &lf_usage_output =
573 *lf_graph_outputs[indices_.outputs.input_usages[input_item_i + 1]];
574 if (const std::optional<int> mapped_i = inputs_map[input_item_i]) {
575 const bke::bNodeSocketType &from_type = *bnode_.input_socket(input_item_i + 1).typeinfo;
576 const bke::bNodeSocketType &to_type = *closure_signature.inputs[*mapped_i].type;
577 lf::OutputSocket *lf_from = lf_graph_inputs[indices_.inputs.main[input_item_i + 1]];
578 lf::InputSocket &lf_to = lf_closure_node.input(closure_indices.inputs.main[*mapped_i]);
579 if (&from_type != &to_type) {
580 if (const LazyFunction *conversion_fn = build_implicit_conversion_lazy_function(
581 from_type, to_type, eval_storage.scope))
582 {
583 /* The provided type when evaluating the closure may be different from what the closure
584 * expects exactly, so do an implicit conversion. */
585 lf::Node &conversion_node = lf_graph.add_function(*conversion_fn);
586 lf_graph.add_link(*lf_from, conversion_node.input(0));
587 lf_from = &conversion_node.output(0);
588 }
589 else {
590 /* Use the default value if the provided input value is not compatible with what the
591 * closure expects. */
592 lf_to.set_default_value(&closure.default_input_value(*mapped_i));
593 lf_usage_output.set_default_value(&static_false);
594 continue;
595 }
596 }
597 lf_graph.add_link(*lf_from, lf_to);
598 lf_graph.add_link(lf_closure_node.output(closure_indices.outputs.input_usages[*mapped_i]),
599 lf_usage_output);
600 }
601 else {
602 lf_usage_output.set_default_value(&static_false);
603 }
604 }
605
606 for (const int output_item_i : IndexRange(node_storage.output_items.items_num)) {
607 lf::GraphOutputSocket &lf_main_output =
608 *lf_graph_outputs[indices_.outputs.main[output_item_i]];
609 const bke::bNodeSocketType &main_output_type = *bnode_.output_socket(output_item_i).typeinfo;
610 if (const std::optional<int> mapped_i = outputs_map[output_item_i]) {
611 const bke::bNodeSocketType &closure_output_type =
612 *closure_signature.outputs[*mapped_i].type;
613 lf::OutputSocket *lf_from = &lf_closure_node.output(
614 closure_indices.outputs.main[*mapped_i]);
615 if (&closure_output_type != &main_output_type) {
616 if (const LazyFunction *conversion_fn = build_implicit_conversion_lazy_function(
617 closure_output_type, main_output_type, eval_storage.scope))
618 {
619 /* Convert the type of the value coming out of the closure to the output socket type of
620 * the evaluation. */
621 lf::Node &conversion_node = lf_graph.add_function(*conversion_fn);
622 lf_graph.add_link(*lf_from, conversion_node.input(0));
623 lf_from = &conversion_node.output(0);
624 }
625 else {
626 /* The socket types are not compatible, so use the default value. */
627 lf_main_output.set_default_value(main_output_type.geometry_nodes_default_value);
628 continue;
629 }
630 }
631 /* Link the output of the closure to the output of the entire evaluation. */
632 lf_graph.add_link(*lf_from, lf_main_output);
633 lf_graph.add_link(*lf_graph_inputs[indices_.inputs.output_usages[output_item_i]],
634 lf_closure_node.input(closure_indices.inputs.output_usages[*mapped_i]));
635 }
636 else {
637 lf_main_output.set_default_value(main_output_type.geometry_nodes_default_value);
638 }
639 }
640
641 for (const int i : closure_indices.inputs.main.index_range()) {
642 lf::InputSocket &lf_closure_input = lf_closure_node.input(closure_indices.inputs.main[i]);
643 if (lf_closure_input.origin()) {
644 /* Handled already. */
645 continue;
646 }
647 lf_closure_input.set_default_value(&closure.default_input_value(i));
648 }
649
650 static const bke::GeometryNodesReferenceSet static_empty_reference_set;
651 for (const int i : closure_indices.outputs.main.index_range()) {
652 lf::OutputSocket &lf_closure_output = lf_closure_node.output(
653 closure_indices.outputs.main[i]);
654 if (const std::optional<int> lf_reference_set_input_i =
655 closure_indices.inputs.output_data_reference_sets.lookup_try(i))
656 {
657 lf::InputSocket &lf_reference_set_input = lf_closure_node.input(*lf_reference_set_input_i);
658 const int node_output_i = outputs_map.as_span().first_index_try(i);
659 if (node_output_i == -1) {
660 lf_reference_set_input.set_default_value(&static_empty_reference_set);
661 }
662 else {
663 if (const std::optional<int> lf_evaluate_node_reference_set_input_i =
664 indices_.inputs.reference_set_by_output.lookup_try(node_output_i))
665 {
666 lf_graph.add_link(*lf_graph_inputs[*lf_evaluate_node_reference_set_input_i],
667 lf_reference_set_input);
668 }
669 else {
670 lf_reference_set_input.set_default_value(&static_empty_reference_set);
671 }
672 }
673 }
674 if (!lf_closure_output.targets().is_empty()) {
675 /* Handled already. */
676 continue;
677 }
678 lf_closure_node.input(closure_indices.inputs.output_usages[i])
679 .set_default_value(&static_false);
680 }
681
682 lf_graph.update_node_indices();
683 eval_storage.side_effect_provider.emplace(lf_closure_node);
684 eval_storage.graph_executor.emplace(
685 lf_graph, nullptr, &*eval_storage.side_effect_provider, nullptr);
686 eval_storage.graph_executor_storage = eval_storage.graph_executor->init_storage(
687 eval_storage.scope.allocator());
688
689 /* Log graph for debugging purposes. */
690 const bNodeTree &btree_orig = *DEG_get_original(&btree_);
691 if (btree_orig.runtime->logged_zone_graphs) {
692 std::lock_guard lock{btree_orig.runtime->logged_zone_graphs->mutex};
693 btree_orig.runtime->logged_zone_graphs->graph_by_zone_id.lookup_or_add_cb(
694 bnode_.identifier, [&]() { return lf_graph.to_dot(); });
695 }
696 }
697
699 {
700 const auto &node_storage = *static_cast<const NodeEvaluateClosure *>(bnode_.storage);
701 lf::Graph &lf_graph = eval_storage.graph;
702 for (const lf::Input &input : inputs_) {
703 lf_graph.add_input(*input.type, input.debug_name);
704 }
705 for (const lf::Output &output : outputs_) {
706 lf_graph.add_output(*output.type, output.debug_name);
707 }
708 const Span<lf::GraphInputSocket *> lf_graph_inputs = lf_graph.graph_inputs();
709 const Span<lf::GraphOutputSocket *> lf_graph_outputs = lf_graph.graph_outputs();
710
711 for (const int output_item_i : IndexRange(node_storage.output_items.items_num)) {
712 const bNodeSocket &output_bsocket = bnode_.output_socket(output_item_i);
714 output_bsocket);
715 lf::GraphOutputSocket &lf_main_output =
716 *lf_graph_outputs[indices_.outputs.main[output_item_i]];
717 lf::GraphInputSocket &lf_usage_input =
718 *lf_graph_inputs[indices_.inputs.output_usages[output_item_i]];
719 const bke::bNodeSocketType &output_type = *output_bsocket.typeinfo;
720 if (input_bsocket) {
721 lf::OutputSocket &lf_main_input =
722 *lf_graph_inputs[indices_.inputs.main[input_bsocket->index()]];
723 lf::GraphOutputSocket &lf_usage_output =
724 *lf_graph_outputs[indices_.outputs.input_usages[input_bsocket->index()]];
725 const bke::bNodeSocketType &input_type = *input_bsocket->typeinfo;
726 if (&input_type == &output_type) {
727 lf_graph.add_link(lf_main_input, lf_main_output);
728 lf_graph.add_link(lf_usage_input, lf_usage_output);
729 continue;
730 }
731 if (const LazyFunction *conversion_fn = build_implicit_conversion_lazy_function(
732 input_type, output_type, eval_storage.scope))
733 {
734 lf::Node &conversion_node = lf_graph.add_function(*conversion_fn);
735 lf_graph.add_link(lf_main_input, conversion_node.input(0));
736 lf_graph.add_link(conversion_node.output(0), lf_main_output);
737 lf_graph.add_link(lf_usage_input, lf_usage_output);
738 continue;
739 }
740 }
741 lf_main_output.set_default_value(output_type.geometry_nodes_default_value);
742 }
743
744 static constexpr bool static_false = false;
745 for (const int usage_i : indices_.outputs.input_usages) {
746 lf::GraphOutputSocket &lf_usage_output = *lf_graph_outputs[usage_i];
747 if (!lf_usage_output.origin()) {
748 lf_usage_output.set_default_value(&static_false);
749 }
750 }
751
752 lf_graph.update_node_indices();
753 eval_storage.graph_executor.emplace(lf_graph, nullptr, nullptr, nullptr);
754 eval_storage.graph_executor_storage = eval_storage.graph_executor->init_storage(
755 eval_storage.scope.allocator());
756 }
757};
758
760{
761 const LazyFunction &fn = closure.function();
762 const ClosureFunctionIndices &indices = closure.indices();
763 const ClosureSignature &signature = closure.signature();
764 const int fn_inputs_num = fn.inputs().size();
765 const int fn_outputs_num = fn.outputs().size();
766
767 ResourceScope scope;
768 LinearAllocator<> &allocator = scope.allocator();
769
770 GeoNodesLocalUserData local_user_data(*params.user_data);
771 void *storage = fn.init_storage(allocator);
772 lf::Context lf_context{storage, params.user_data, &local_user_data};
773
774 Array<GMutablePointer> lf_input_values(fn_inputs_num);
775 Array<GMutablePointer> lf_output_values(fn_outputs_num);
776 Array<std::optional<lf::ValueUsage>> lf_input_usages(fn_inputs_num);
777 Array<lf::ValueUsage> lf_output_usages(fn_outputs_num, lf::ValueUsage::Unused);
778 Array<bool> lf_set_outputs(fn_outputs_num, false);
779
780 Array<std::optional<int>> inputs_map(params.inputs.size());
781 for (const int i : inputs_map.index_range()) {
782 inputs_map[i] = signature.find_input_index(params.inputs[i].key);
783 }
784 Array<std::optional<int>> outputs_map(params.outputs.size());
785 for (const int i : outputs_map.index_range()) {
786 outputs_map[i] = signature.find_output_index(params.outputs[i].key);
787 }
788
789 for (const int input_item_i : params.inputs.index_range()) {
790 ClosureEagerEvalParams::InputItem &item = params.inputs[input_item_i];
791 if (const std::optional<int> mapped_i = inputs_map[input_item_i]) {
792 const bke::bNodeSocketType &from_type = *item.type;
793 const bke::bNodeSocketType &to_type = *signature.inputs[*mapped_i].type;
794 bke::SocketValueVariant input_value;
795 if (std::optional<bke::SocketValueVariant> value = implicitly_convert_socket_value(
796 from_type, item.value, to_type))
797 {
798 input_value = *value;
799 }
800 else {
801 input_value = *to_type.geometry_nodes_default_value;
802 }
803 lf_input_values[indices.inputs.main[*mapped_i]] = {
805 allocator.construct<bke::SocketValueVariant>(std::move(input_value)).release()};
806 }
807 else {
808 /* Provided input value is ignored. */
809 }
810 }
811 for (const int output_item_i : params.outputs.index_range()) {
812 if (const std::optional<int> mapped_i = outputs_map[output_item_i]) {
813 /* Tell the closure that this output is used. */
814 lf_input_values[indices.inputs.output_usages[*mapped_i]] = {
815 CPPType::get<bool>(), allocator.construct<bool>(true).release()};
816 lf_output_usages[indices.outputs.main[*mapped_i]] = lf::ValueUsage::Used;
817 }
818 }
819
820 /* Set remaining main inputs to their default values. */
821 for (const int main_input_i : indices.inputs.main.index_range()) {
822 const int lf_input_i = indices.inputs.main[main_input_i];
823 if (!lf_input_values[lf_input_i]) {
824 auto value = allocator.construct<bke::SocketValueVariant>(
825 closure.default_input_value(main_input_i));
826 lf_input_values[lf_input_i] = value.release();
827 }
828 lf_output_values[indices.outputs.input_usages[main_input_i]] = allocator.allocate<bool>();
829 }
830 /* Set remaining output usages to false. */
831 for (const int output_usage_i : indices.inputs.output_usages.index_range()) {
832 const int lf_input_i = indices.inputs.output_usages[output_usage_i];
833 if (!lf_input_values[lf_input_i]) {
834 lf_input_values[lf_input_i] = {CPPType::get<bool>(),
835 allocator.construct<bool>(false).release()};
836 }
837 }
839 for (auto &&[main_output_i, lf_input_i] : indices.inputs.output_data_reference_sets.items()) {
840 /* TODO: Propagate all attributes or let the caller decide. */
841 auto value = allocator.construct<bke::GeometryNodesReferenceSet>();
842 lf_input_values[lf_input_i] = {value.release()};
843 }
845 for (const int main_output_i : indices.outputs.main.index_range()) {
846 lf_output_values[indices.outputs.main[main_output_i]] =
848 }
849
850 lf::BasicParams lf_params{
851 fn, lf_input_values, lf_output_values, lf_input_usages, lf_output_usages, lf_set_outputs};
852 fn.execute(lf_params, lf_context);
853 fn.destruct_storage(storage);
854
855 for (const int output_item_i : params.outputs.index_range()) {
856 ClosureEagerEvalParams::OutputItem &item = params.outputs[output_item_i];
857 if (const std::optional<int> mapped_i = outputs_map[output_item_i]) {
858 const bke::bNodeSocketType &from_type = *signature.outputs[*mapped_i].type;
859 const bke::bNodeSocketType &to_type = *item.type;
860 if (std::optional<bke::SocketValueVariant> value = implicitly_convert_socket_value(
861 from_type,
862 *lf_output_values[indices.outputs.main[*mapped_i]].get<bke::SocketValueVariant>(),
863 to_type))
864 {
865 new (item.value) bke::SocketValueVariant(std::move(*value));
866 }
867 else {
868 new (item.value) bke::SocketValueVariant(*to_type.geometry_nodes_default_value);
869 }
870 }
871 else {
872 /* This output item is not computed by the closure, so set it to the default value. */
874 }
875 }
876
877 for (GMutablePointer value : lf_input_values) {
878 if (value) {
879 value.destruct();
880 }
881 }
882 for (const int i : lf_output_values.index_range()) {
883 if (lf_set_outputs[i]) {
884 lf_output_values[i].destruct();
885 }
886 }
887}
888
890 ResourceScope &scope,
891 const bNodeTree &btree,
892 const bke::bNodeTreeZone &zone,
893 ZoneBuildInfo &zone_info,
894 const ZoneBodyFunction &body_fn,
895 std::shared_ptr<GeometryNodesLazyFunctionGraphInfo> &lf_graph_info)
896{
898 btree, zone, zone_info, body_fn, lf_graph_info);
899}
900
902 const bNode &bnode)
903{
905 auto &fn = scope.construct<LazyFunctionForEvaluateClosureNode>(bnode);
906 info.lazy_function = &fn;
907 info.indices = fn.indices();
908 return info;
909}
910
911} // namespace blender::nodes
volatile int lock
__forceinline float extract(const int4 &b)
Definition binning.cpp:27
#define output
Span< T > as_span() const
Definition BLI_array.hh:254
IndexRange index_range() const
Definition BLI_array.hh:371
static const CPPType & get()
const ComputeContextHash & hash() const
constexpr IndexRange()=default
destruct_ptr< T > construct(Args &&...args)
void * allocate(const int64_t size, const int64_t alignment)
T & construct(Args &&...args)
LinearAllocator & allocator()
constexpr bool is_empty() const
Definition BLI_span.hh:264
constexpr StringRef()
void append(const T &value)
static SocketValueVariant from(T &&value)
std::unique_ptr< LoggedZoneGraphs > logged_zone_graphs
std::unique_ptr< node_tree_reference_lifetimes::ReferenceLifetimesInfo > reference_lifetimes_info
Vector< const lf::FunctionNode * > get_nodes_with_side_effects(const lf::Context &context) const override
std::optional< int > find_output_index(StringRef key) const
CustomIDVectorSet< Item, ItemKeyGetter > inputs
std::optional< int > find_input_index(StringRef key) const
CustomIDVectorSet< Item, ItemKeyGetter > outputs
const ClosureSignature & signature() const
const fn::lazy_function::LazyFunction & function() const
const bke::SocketValueVariant & default_input_value(const int index) const
const ClosureFunctionIndices & indices() const
void execute_impl(lf::Params &params, const lf::Context &context) const override
LazyFunctionForClosureZone(const bNodeTree &btree, const bke::bNodeTreeZone &zone, ZoneBuildInfo &zone_info, const ZoneBodyFunction &body_fn, std::shared_ptr< GeometryNodesLazyFunctionGraphInfo > &lf_graph_info)
bool is_recursive_call(const GeoNodesUserData &user_data) const
void initialize_execution_graph(EvaluateClosureEvalStorage &eval_storage) const
void initialize_pass_through_graph(EvaluateClosureEvalStorage &eval_storage) const
void generate_closure_compatibility_warnings(const Closure &closure, const lf::Context &context) const
void * init_storage(LinearAllocator<> &allocator) const override
void execute_impl(lf::Params &params, const lf::Context &context) const override
linear_allocator::ChunkedList< WarningWithNode > node_warnings
#define storage(slot, qualifiers)
uint to_type(bool)
bNodeSocketType * node_socket_type_find_static(int type, int subtype=0)
Definition node.cc:2975
void evaluate_closure_eagerly(const Closure &closure, ClosureEagerEvalParams &params)
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)
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)
void construct_socket_default_value(const bke::bNodeSocketType &stype, void *r_value)
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)
std::optional< SocketValueVariant > implicitly_convert_socket_value(const bke::bNodeSocketType &from_type, const SocketValueVariant &from_value, const bke::bNodeSocketType &to_type)
const bNodeSocket * evaluate_closure_node_internally_linked_input(const bNodeSocket &output_socket)
ImplicitSharingPtr< Closure > ClosurePtr
void set_default_value_for_output_socket(lf::Params &params, const int lf_index, const bNodeSocket &bsocket)
EvaluateClosureFunction build_evaluate_closure_node_lazy_function(ResourceScope &scope, const bNode &bnode)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
T * DEG_get_original(T *id)
unsigned int session_uid
Definition DNA_ID.h:463
bke::bNodeSocketType * typeinfo
bke::bNodeTreeRuntime * runtime
Defines a socket type.
Definition BKE_node.hh:163
eNodeSocketDatatype type
Definition BKE_node.hh:198
const SocketValueVariant * geometry_nodes_default_value
Definition BKE_node.hh:216
struct blender::nodes::ClosureFunctionIndices::@160307352137314066326363125174013160024306142302 outputs
struct blender::nodes::ClosureFunctionIndices::@322073305126251315255160374026131265320171306337 inputs
std::optional< ClosureIntermediateGraphSideEffectProvider > side_effect_provider
const GeoNodesSideEffectNodes * side_effect_nodes
MultiValueMap< ComputeContextHash, const lf::FunctionNode * > nodes_by_context
struct blender::nodes::ZoneFunctionIndices::@342054057300321050315260123310012173322070035365 inputs