Blender V5.3
node_runtime.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
8
9#include "BKE_node.hh"
10#include "BKE_node_runtime.hh"
11
12#include "DNA_node_types.h"
13
14#include "BLI_function_ref.hh"
15#include "BLI_listbase.hh"
16#include "BLI_stack.hh"
17#include "BLI_task.hh"
18
22
23namespace blender {
24
25namespace bke::node_tree_runtime {
26
28{
29 BLI_assert(tree_cow.type == NTREE_GEOMETRY);
30 /* Rebuild geometry nodes lazy function graph. */
33}
34
35static void update_node_vector(const bNodeTree &ntree)
36{
37 bNodeTreeRuntime &tree_runtime = *ntree.runtime;
38 const Span<bNode *> nodes = tree_runtime.nodes_by_id;
39 tree_runtime.group_nodes.clear();
40 tree_runtime.has_undefined_nodes_or_sockets = false;
41 for (const int i : nodes.index_range()) {
42 bNode &node = *nodes[i];
43 node.runtime->index_in_tree = i;
44 node.runtime->owner_tree = const_cast<bNodeTree *>(&ntree);
45 tree_runtime.has_undefined_nodes_or_sockets |= node.is_undefined();
46 if (node.is_group()) {
47 tree_runtime.group_nodes.append(&node);
48 }
49 }
50}
51
52static void update_link_vector(const bNodeTree &ntree)
53{
54 bNodeTreeRuntime &tree_runtime = *ntree.runtime;
55 tree_runtime.links.clear();
56 for (bNodeLink &link : ntree.links) {
57 /* Check that the link connects nodes within this tree. */
58 BLI_assert(tree_runtime.nodes_by_id.contains(link.fromnode));
59 BLI_assert(tree_runtime.nodes_by_id.contains(link.tonode));
60
61 tree_runtime.links.append(&link);
62 }
63}
64
66{
67 bNodeTreeRuntime &tree_runtime = *ntree.runtime;
68 tree_runtime.sockets.clear();
69 tree_runtime.input_sockets.clear();
70 tree_runtime.output_sockets.clear();
71 for (bNode *node : tree_runtime.nodes_by_id) {
72 bNodeRuntime &node_runtime = *node->runtime;
73 node_runtime.inputs.clear();
74 node_runtime.outputs.clear();
75 for (bNodeSocket &socket : node->inputs) {
76 socket.runtime->index_in_node = node_runtime.inputs.append_and_get_index(&socket);
77 socket.runtime->index_in_all_sockets = tree_runtime.sockets.append_and_get_index(&socket);
78 socket.runtime->index_in_inout_sockets = tree_runtime.input_sockets.append_and_get_index(
79 &socket);
80 socket.runtime->owner_node = node;
81 tree_runtime.has_undefined_nodes_or_sockets |= socket.typeinfo ==
83 }
84 for (bNodeSocket &socket : node->outputs) {
85 socket.runtime->index_in_node = node_runtime.outputs.append_and_get_index(&socket);
86 socket.runtime->index_in_all_sockets = tree_runtime.sockets.append_and_get_index(&socket);
87 socket.runtime->index_in_inout_sockets = tree_runtime.output_sockets.append_and_get_index(
88 &socket);
89 socket.runtime->owner_node = node;
90 tree_runtime.has_undefined_nodes_or_sockets |= socket.typeinfo ==
92 }
93 }
94}
95
96static void update_panels(const bNodeTree &ntree)
97{
98 bNodeTreeRuntime &tree_runtime = *ntree.runtime;
99 for (bNode *node : tree_runtime.nodes_by_id) {
100 bNodeRuntime &node_runtime = *node->runtime;
101 node_runtime.panels.reinitialize(node->num_panel_states);
102 }
103}
104
105static void update_internal_link_inputs(const bNodeTree &ntree)
106{
107 bNodeTreeRuntime &tree_runtime = *ntree.runtime;
108 for (bNode *node : tree_runtime.nodes_by_id) {
109 for (bNodeSocket *socket : node->runtime->outputs) {
110 socket->runtime->internal_link_input = nullptr;
111 }
112 for (bNodeInternalLink &link : node->runtime->internal_links) {
113 link.out->runtime->internal_link_input = link.in;
114 }
115 }
116}
117
119{
120 bNodeTreeRuntime &tree_runtime = *ntree.runtime;
121 for (bNode *node : tree_runtime.nodes_by_id) {
122 for (bNodeSocket *socket : node->runtime->inputs) {
123 socket->runtime->directly_linked_links.clear();
124 socket->runtime->directly_linked_sockets.clear();
125 }
126 for (bNodeSocket *socket : node->runtime->outputs) {
127 socket->runtime->directly_linked_links.clear();
128 socket->runtime->directly_linked_sockets.clear();
129 }
130 node->runtime->has_available_linked_inputs = false;
131 node->runtime->has_available_linked_outputs = false;
132 }
133 for (bNodeLink *link : tree_runtime.links) {
134 link->fromsock->runtime->directly_linked_links.append(link);
135 link->fromsock->runtime->directly_linked_sockets.append(link->tosock);
136 link->tosock->runtime->directly_linked_links.append(link);
137 if (link->is_available()) {
140 }
142 BLI_assert(link->tosock->runtime->owner_node == link->tonode);
143 }
144 for (bNodeSocket *socket : tree_runtime.input_sockets) {
145 if (socket->flag & SOCK_MULTI_INPUT) {
146 std::ranges::sort(socket->runtime->directly_linked_links,
147 [&](const bNodeLink *a, const bNodeLink *b) {
148 return a->multi_input_sort_id > b->multi_input_sort_id;
149 });
150 }
151 }
152 for (bNodeSocket *socket : tree_runtime.input_sockets) {
153 for (bNodeLink *link : socket->runtime->directly_linked_links) {
154 /* Do this after sorting the input links. */
155 socket->runtime->directly_linked_sockets.append(link->fromsock);
156 }
157 }
158}
159
161 bNodeSocket &input_socket,
162 bool only_follow_first_input_link,
163 Vector<bNodeSocket *, 16> &sockets_in_current_chain,
164 Vector<bNodeSocket *> &r_logical_origins,
165 Vector<bNodeSocket *> &r_skipped_origins)
166{
167 if (sockets_in_current_chain.contains(&input_socket)) {
168 /* Protect against reroute recursions. */
169 return;
170 }
171 sockets_in_current_chain.append(&input_socket);
172
173 Span<bNodeLink *> links_to_check = input_socket.runtime->directly_linked_links;
174 if (only_follow_first_input_link) {
175 links_to_check = links_to_check.take_front(1);
176 }
177 for (bNodeLink *link : links_to_check) {
178 if (link->is_muted()) {
179 continue;
180 }
181 if (!link->is_available()) {
182 continue;
183 }
184 bNodeSocket &origin_socket = *link->fromsock;
185 bNode &origin_node = *link->fromnode;
186 if (!origin_socket.is_available()) {
187 /* Non available sockets are ignored. */
188 continue;
189 }
190 if (origin_node.is_reroute()) {
191 bNodeSocket &reroute_input = *origin_node.runtime->inputs[0];
192 bNodeSocket &reroute_output = *origin_node.runtime->outputs[0];
193 r_skipped_origins.append(&reroute_input);
194 r_skipped_origins.append(&reroute_output);
196 reroute_input, false, sockets_in_current_chain, r_logical_origins, r_skipped_origins);
197 continue;
198 }
199 if (origin_node.is_muted()) {
200 if (bNodeSocket *mute_input = origin_socket.runtime->internal_link_input) {
201 r_skipped_origins.append(&origin_socket);
202 r_skipped_origins.append(mute_input);
204 *mute_input, true, sockets_in_current_chain, r_logical_origins, r_skipped_origins);
205 }
206 continue;
207 }
208 r_logical_origins.append(&origin_socket);
209 }
210
211 sockets_in_current_chain.pop_last();
212}
213
215{
216 /* Compute logically linked sockets to inputs. */
217 bNodeTreeRuntime &tree_runtime = *ntree.runtime;
218 Span<bNode *> nodes = tree_runtime.nodes_by_id;
219 threading::parallel_for(nodes.index_range(), 128, [&](const IndexRange range) {
220 for (const int i : range) {
221 bNode &node = *nodes[i];
222 for (bNodeSocket *socket : node.runtime->inputs) {
223 Vector<bNodeSocket *, 16> sockets_in_current_chain;
224 socket->runtime->logically_linked_sockets.clear();
225 socket->runtime->logically_linked_skipped_sockets.clear();
226 find_logical_origins_for_socket_recursive(
227 *socket,
228 false,
229 sockets_in_current_chain,
230 socket->runtime->logically_linked_sockets,
231 socket->runtime->logically_linked_skipped_sockets);
232 }
233 }
234 });
235
236 /* Clear logically linked sockets to outputs. */
237 threading::parallel_for(nodes.index_range(), 128, [&](const IndexRange range) {
238 for (const int i : range) {
239 bNode &node = *nodes[i];
240 for (bNodeSocket *socket : node.runtime->outputs) {
241 socket->runtime->logically_linked_sockets.clear();
242 }
243 }
244 });
245
246 /* Compute logically linked sockets to outputs using the previously computed logically linked
247 * sockets to inputs. */
248 for (const bNode *node : nodes) {
249 for (bNodeSocket *input_socket : node->runtime->inputs) {
250 for (bNodeSocket *output_socket : input_socket->runtime->logically_linked_sockets) {
251 output_socket->runtime->logically_linked_sockets.append(input_socket);
252 }
253 }
254 }
255}
256
257static void update_nodes_by_type(const bNodeTree &ntree)
258{
259 bNodeTreeRuntime &tree_runtime = *ntree.runtime;
260 tree_runtime.nodes_by_type.clear();
261 for (bNode *node : tree_runtime.nodes_by_id) {
262 tree_runtime.nodes_by_type.add(node->typeinfo, node);
263 }
264}
265
267{
268 bNodeTreeRuntime &tree_runtime = *ntree.runtime;
269 Span<bNode *> nodes = tree_runtime.nodes_by_id;
270 threading::parallel_for(nodes.index_range(), 128, [&](const IndexRange range) {
271 for (bNode *node : nodes.slice(range)) {
272 node->runtime->inputs_by_identifier.clear();
273 node->runtime->outputs_by_identifier.clear();
274 for (bNodeSocket *socket : node->runtime->inputs) {
275 BLI_assert(socket->identifier == socket->identifier_ustr());
276 node->runtime->inputs_by_identifier.add_new(socket->identifier_ustr(), socket);
277 }
278 for (bNodeSocket *socket : node->runtime->outputs) {
279 BLI_assert(socket->identifier == socket->identifier_ustr());
280 node->runtime->outputs_by_identifier.add_new(socket->identifier_ustr(), socket);
281 }
282 }
283 });
284}
285
290
292 bool is_done = false;
293 bool is_in_stack = false;
294};
295
297{
298 Vector<const bNode *> origin_nodes;
299 if (all_zone_output_node_types().contains(node.type_legacy)) {
300 const bNodeZoneType &zone_type = *zone_type_by_node_type(node.type_legacy);
301 /* Can't use #zone_type.get_corresponding_input because that expects the topology cache to be
302 * build already, but we are still building it here. */
303 for (const bNode *input_node :
304 ntree.runtime->nodes_by_type.lookup(bke::node_type_find(zone_type.input_idname)))
305 {
306 if (zone_type.get_corresponding_output_id(*input_node) == node.identifier) {
307 origin_nodes.append(input_node);
308 }
309 }
310 }
311 return origin_nodes;
312}
313
315{
316 Vector<const bNode *> target_nodes;
317 if (all_zone_input_node_types().contains(node.type_legacy)) {
318 const bNodeZoneType &zone_type = *zone_type_by_node_type(node.type_legacy);
319 if (const bNode *output_node = zone_type.get_corresponding_output(ntree, node)) {
320 target_nodes.append(output_node);
321 }
322 }
323 return target_nodes;
324}
325
326static void toposort_from_start_node(const bNodeTree &ntree,
327 const ToposortDirection direction,
328 bNode &start_node,
330 Vector<bNode *> &r_sorted_nodes,
331 bool &r_cycle_detected)
332{
333 struct Item {
334 bNode *node;
335 int socket_index = 0;
336 int link_index = 0;
337 int implicit_link_index = 0;
338 };
339
340 Stack<Item, 64> nodes_to_check;
341 nodes_to_check.push({&start_node});
342 node_states[start_node.index()].is_in_stack = true;
343 while (!nodes_to_check.is_empty()) {
344 Item &item = nodes_to_check.peek();
345 bNode &node = *item.node;
346 bool pushed_node = false;
347
348 auto handle_linked_node = [&](bNode &linked_node) {
349 ToposortNodeState &linked_node_state = node_states[linked_node.index()];
350 if (linked_node_state.is_done) {
351 /* The linked node has already been visited. */
352 return true;
353 }
354 if (linked_node_state.is_in_stack) {
355 r_cycle_detected = true;
356 }
357 else {
358 nodes_to_check.push({&linked_node});
359 linked_node_state.is_in_stack = true;
360 pushed_node = true;
361 }
362 return false;
363 };
364
365 const Span<bNodeSocket *> sockets = (direction == ToposortDirection::LeftToRight) ?
366 node.runtime->inputs :
367 node.runtime->outputs;
368 while (true) {
369 if (item.socket_index == sockets.size()) {
370 /* All sockets have already been visited. */
371 break;
372 }
373 bNodeSocket &socket = *sockets[item.socket_index];
374 const Span<bNodeLink *> linked_links = socket.runtime->directly_linked_links;
375 if (item.link_index == linked_links.size()) {
376 /* All links connected to this socket have already been visited. */
377 item.socket_index++;
378 item.link_index = 0;
379 continue;
380 }
381 bNodeLink &link = *linked_links[item.link_index];
382 if (!link.is_available()) {
383 /* Ignore unavailable links. */
384 item.link_index++;
385 continue;
386 }
387 bNodeSocket &linked_socket = *socket.runtime->directly_linked_sockets[item.link_index];
388 bNode &linked_node = *linked_socket.runtime->owner_node;
389 if (handle_linked_node(linked_node)) {
390 /* The linked node has already been visited. */
391 item.link_index++;
392 continue;
393 }
394 break;
395 }
396
397 if (!pushed_node) {
398 /* Some nodes are internally linked without an explicit `bNodeLink`. The toposort should
399 * still order them correctly and find cycles. */
400 const Vector<const bNode *> implicitly_linked_nodes =
403 while (true) {
404 if (item.implicit_link_index == implicitly_linked_nodes.size()) {
405 /* All implicitly linked nodes have already been visited. */
406 break;
407 }
408 const bNode &linked_node = *implicitly_linked_nodes[item.implicit_link_index];
409 if (handle_linked_node(const_cast<bNode &>(linked_node))) {
410 /* The implicitly linked node has already been visited. */
411 item.implicit_link_index++;
412 continue;
413 }
414 break;
415 }
416 }
417
418 /* If no other element has been pushed, the current node can be pushed to the sorted list.
419 */
420 if (!pushed_node) {
421 ToposortNodeState &node_state = node_states[node.index()];
422 node_state.is_done = true;
423 node_state.is_in_stack = false;
424 r_sorted_nodes.append(&node);
425 nodes_to_check.pop();
426 }
427 }
428}
429
430static void update_toposort(const bNodeTree &ntree,
431 const ToposortDirection direction,
432 Vector<bNode *> &r_sorted_nodes,
433 bool &r_cycle_detected)
434{
435 bNodeTreeRuntime &tree_runtime = *ntree.runtime;
436 r_sorted_nodes.clear();
437 r_sorted_nodes.reserve(tree_runtime.nodes_by_id.size());
438 r_cycle_detected = false;
439
440 Array<ToposortNodeState> node_states(tree_runtime.nodes_by_id.size());
441 for (bNode *node : tree_runtime.nodes_by_id) {
442 if (node_states[node->index()].is_done) {
443 /* Ignore nodes that are done already. */
444 continue;
445 }
446 if ((direction == ToposortDirection::LeftToRight) ?
447 node->runtime->has_available_linked_outputs :
448 node->runtime->has_available_linked_inputs)
449 {
450 /* Ignore non-start nodes. */
451 continue;
452 }
454 ntree, direction, *node, node_states, r_sorted_nodes, r_cycle_detected);
455 }
456
457 if (r_sorted_nodes.size() < tree_runtime.nodes_by_id.size()) {
458 r_cycle_detected = true;
459 for (bNode *node : tree_runtime.nodes_by_id) {
460 if (node_states[node->index()].is_done) {
461 /* Ignore nodes that are done already. */
462 continue;
463 }
464 /* Start toposort at this node which is somewhere in the middle of a loop. */
466 ntree, direction, *node, node_states, r_sorted_nodes, r_cycle_detected);
467 }
468 }
469
470 BLI_assert(tree_runtime.nodes_by_id.size() == r_sorted_nodes.size());
471}
472
473static void update_root_frames(const bNodeTree &ntree)
474{
475 bNodeTreeRuntime &tree_runtime = *ntree.runtime;
476 Span<bNode *> nodes = tree_runtime.nodes_by_id;
477
478 tree_runtime.root_frames.clear();
479
480 for (bNode *node : nodes) {
481 if (!node->parent && node->is_frame()) {
482 tree_runtime.root_frames.append(node);
483 }
484 }
485}
486
488{
489 bNodeTreeRuntime &tree_runtime = *ntree.runtime;
490 Span<bNode *> nodes = tree_runtime.nodes_by_id;
491
492 for (bNode *node : nodes) {
493 node->runtime->direct_children_in_frame.clear();
494 }
495
496 for (bNode *node : nodes) {
497 if (const bNode *frame = node->parent) {
498 frame->runtime->direct_children_in_frame.append(node);
499 }
500 }
501}
502
503static void update_group_output_node(const bNodeTree &ntree)
504{
505 bNodeTreeRuntime &tree_runtime = *ntree.runtime;
506 const bke::bNodeType *node_type = bke::node_type_find("NodeGroupOutput"_ustr);
507 const Span<bNode *> group_output_nodes = tree_runtime.nodes_by_type.lookup(node_type);
508 if (group_output_nodes.is_empty()) {
509 tree_runtime.group_output_node = nullptr;
510 }
511 else if (group_output_nodes.size() == 1) {
512 tree_runtime.group_output_node = group_output_nodes[0];
513 }
514 else {
515 tree_runtime.group_output_node = nullptr;
516 for (bNode *group_output : group_output_nodes) {
517 if (group_output->flag & NODE_DO_OUTPUT) {
518 tree_runtime.group_output_node = group_output;
519 break;
520 }
521 }
522 }
523}
524
526{
527 for (const bNode *node : ntree.runtime->toposort_left_to_right) {
528 bNodeRuntime &node_runtime = *node->runtime;
529 if (!node->is_reroute()) {
530 node_runtime.is_dangling_reroute = false;
531 continue;
532 }
533 const Span<const bNodeLink *> links = node_runtime.inputs[0]->runtime->directly_linked_links;
534 if (links.is_empty()) {
535 node_runtime.is_dangling_reroute = true;
536 continue;
537 }
538 BLI_assert(links.size() == 1);
539 const bNode &source_node = *links.first()->fromnode;
540 node_runtime.is_dangling_reroute = source_node.runtime->is_dangling_reroute;
541 }
542}
543
544static void ensure_topology_cache(const bNodeTree &ntree)
545{
546 bNodeTreeRuntime &tree_runtime = *ntree.runtime;
547 tree_runtime.topology_cache_mutex.ensure([&]() {
548 update_node_vector(ntree);
549 update_link_vector(ntree);
551 update_panels(ntree);
556 tree_runtime.nodes_by_id.size() > 32,
557 [&]() { update_logically_linked_sockets(ntree); },
558 [&]() { update_sockets_by_identifier(ntree); },
559 [&]() {
560 update_toposort(ntree,
561 ToposortDirection::LeftToRight,
562 tree_runtime.toposort_left_to_right,
563 tree_runtime.has_available_link_cycle);
564 for (const int i : tree_runtime.toposort_left_to_right.index_range()) {
565 const bNode &node = *tree_runtime.toposort_left_to_right[i];
566 node.runtime->toposort_left_to_right_index = i;
567 }
568 },
569 [&]() {
570 bool dummy;
572 ntree, ToposortDirection::RightToLeft, tree_runtime.toposort_right_to_left, dummy);
573 for (const int i : tree_runtime.toposort_right_to_left.index_range()) {
574 const bNode &node = *tree_runtime.toposort_right_to_left[i];
575 node.runtime->toposort_right_to_left_index = i;
576 }
577 },
578 [&]() { update_root_frames(ntree); },
579 [&]() { update_direct_frames_childrens(ntree); });
582 tree_runtime.topology_cache_exists = true;
583 });
584}
585
586} // namespace bke::node_tree_runtime
587
588namespace bke {
589
591{
592 to_node_id_ = link.tonode->identifier;
593 input_socket_index_ = link.tosock->index();
594 input_link_index_ =
595 const_cast<const bNodeSocket *>(link.tosock)->directly_linked_links().first_index(&link);
596}
597
599{
600 return const_cast<bNodeLink *>(this->try_find(const_cast<const bNodeTree &>(ntree)));
601}
602
603const bNodeLink *NodeLinkKey::try_find(const bNodeTree &ntree) const
604{
605 const bNode *to_node = ntree.node_by_id(to_node_id_);
606 if (!to_node) {
607 return nullptr;
608 }
609 if (input_socket_index_ >= to_node->input_sockets().size()) {
610 return nullptr;
611 }
612 const bNodeSocket &input_socket = to_node->input_socket(input_socket_index_);
613 if (input_link_index_ >= input_socket.directly_linked_links().size()) {
614 return nullptr;
615 }
616 return input_socket.directly_linked_links()[input_link_index_];
617}
618
619} // namespace bke
620
621void bNodeTree::ensure_topology_cache() const
622{
624}
625
626const bNestedNodeRef *bNodeTree::find_nested_node_ref(const int32_t nested_node_id) const
627{
628 for (const bNestedNodeRef &ref : this->nested_node_refs_span()) {
629 if (ref.id == nested_node_id) {
630 return &ref;
631 }
632 }
633 return nullptr;
634}
635
636const bNestedNodeRef *bNodeTree::nested_node_ref_from_node_id_path(
637 const Span<int32_t> node_ids) const
638{
639 if (node_ids.is_empty()) {
640 return nullptr;
641 }
642 for (const bNestedNodeRef &ref : this->nested_node_refs_span()) {
643 Vector<int> current_node_ids;
644 if (this->node_id_path_from_nested_node_ref(ref.id, current_node_ids)) {
645 if (current_node_ids.as_span() == node_ids) {
646 return &ref;
647 }
648 }
649 }
650 return nullptr;
651}
652
653bool bNodeTree::node_id_path_from_nested_node_ref(const int32_t nested_node_id,
654 Vector<int> &r_node_ids) const
655{
656 const bNestedNodeRef *ref = this->find_nested_node_ref(nested_node_id);
657 if (ref == nullptr) {
658 return false;
659 }
660 const int32_t node_id = ref->path.node_id;
661 const bNode *node = this->node_by_id(node_id);
662 if (node == nullptr) {
663 return false;
664 }
665 r_node_ids.append(node_id);
666 if (!node->is_group()) {
667 return true;
668 }
669 const bNodeTree *group = reinterpret_cast<const bNodeTree *>(node->id);
670 if (group == nullptr) {
671 return false;
672 }
673 return group->node_id_path_from_nested_node_ref(ref->path.id_in_node, r_node_ids);
674}
675
676const bNode *bNodeTree::find_nested_node(const int32_t nested_node_id,
677 const bNodeTree **r_tree) const
678{
679 const bNestedNodeRef *ref = this->find_nested_node_ref(nested_node_id);
680 if (ref == nullptr) {
681 return nullptr;
682 }
683 const int32_t node_id = ref->path.node_id;
684 const bNode *node = this->node_by_id(node_id);
685 if (node == nullptr) {
686 return nullptr;
687 }
688 if (!node->is_group()) {
689 if (r_tree) {
690 *r_tree = this;
691 }
692 return node;
693 }
694 const bNodeTree *group = reinterpret_cast<const bNodeTree *>(node->id);
695 if (group == nullptr) {
696 return nullptr;
697 }
698 return group->find_nested_node(ref->path.id_in_node, r_tree);
699}
700
701const bNodeSocket &bNode::socket_by_decl(const nodes::SocketDeclaration &decl) const
702{
703 return decl.in_out == SOCK_IN ? this->input_socket(decl.index) : this->output_socket(decl.index);
704}
705
706bNodeSocket &bNode::socket_by_decl(const nodes::SocketDeclaration &decl)
707{
708 return decl.in_out == SOCK_IN ? this->input_socket(decl.index) : this->output_socket(decl.index);
709}
710
718
719bool bNodeSocket::affects_node_output() const
720{
721 BLI_assert(this->is_input());
722 BLI_assert(bke::node_tree_runtime::topology_cache_is_available(*this));
723 const bNodeTree &tree = this->owner_tree();
724 ensure_inference_usage_cache(tree);
725 return tree.runtime->inferenced_socket_usage[this->index_in_tree()].is_used;
726}
727
728bool bNodeSocket::inferred_socket_visibility() const
729{
730 BLI_assert(bke::node_tree_runtime::topology_cache_is_available(*this));
731 const bNode &node = this->owner_node();
732 if (node.typeinfo->ignore_inferred_input_socket_visibility) {
733 return true;
734 }
735 const bNodeTree &tree = this->owner_tree();
736
738 return tree.runtime->inferenced_socket_usage[this->index_in_tree()].is_visible;
739}
740
741} // namespace blender
#define BLI_assert(a)
constexpr bool is_empty() const
Definition BLI_span.hh:264
void ensure(const FunctionRef< void()> compute_cache)
constexpr const T & first() const
Definition BLI_span.hh:319
constexpr int64_t size() const
Definition BLI_span.hh:256
constexpr Span take_front(int64_t n) const
Definition BLI_span.hh:197
constexpr bool is_empty() const
Definition BLI_span.hh:264
bool is_empty() const
Definition BLI_stack.hh:310
void push(const T &value)
Definition BLI_stack.hh:215
int64_t size() const
bool contains(const Key &key) const
int64_t size() const
bool contains(const T &value) const
void append(const T &value)
void reserve(const int64_t min_capacity)
Array< bNodePanelRuntime > panels
Vector< bNodeSocket * > outputs
Vector< bNodeSocket * > inputs
Vector< bNodeSocket * > directly_linked_sockets
Vector< bNodeSocket * > logically_linked_sockets
Vector< bNodeLink * > directly_linked_links
Vector< bNodeSocket * > output_sockets
Array< nodes::socket_usage_inference::SocketUsage > inferenced_socket_usage
Vector< bNodeSocket * > sockets
CacheMutex geometry_nodes_lazy_function_graph_info_mutex
std::atomic< bool > topology_cache_exists
MultiValueMap< const bNodeType *, bNode * > nodes_by_type
Vector< bNodeSocket * > input_sockets
virtual const int & get_corresponding_output_id(const bNode &input_bnode) const =0
const bNode * get_corresponding_output(const bNodeTree &tree, const bNode &input_bnode) const
#define index(i)
static void toposort_from_start_node(const bNodeTree &ntree, const ToposortDirection direction, bNode &start_node, MutableSpan< ToposortNodeState > node_states, Vector< bNode * > &r_sorted_nodes, bool &r_cycle_detected)
static void update_dangling_reroute_nodes(const bNodeTree &ntree)
static void update_nodes_by_type(const bNodeTree &ntree)
static void update_direct_frames_childrens(const bNodeTree &ntree)
static Vector< const bNode * > get_implicit_origin_nodes(const bNodeTree &ntree, bNode &node)
static void update_group_output_node(const bNodeTree &ntree)
static void update_link_vector(const bNodeTree &ntree)
static void update_sockets_by_identifier(const bNodeTree &ntree)
static void update_logically_linked_sockets(const bNodeTree &ntree)
static void ensure_topology_cache(const bNodeTree &ntree)
static void find_logical_origins_for_socket_recursive(bNodeSocket &input_socket, bool only_follow_first_input_link, Vector< bNodeSocket *, 16 > &sockets_in_current_chain, Vector< bNodeSocket * > &r_logical_origins, Vector< bNodeSocket * > &r_skipped_origins)
static void update_internal_link_inputs(const bNodeTree &ntree)
static void update_panels(const bNodeTree &ntree)
static void update_node_vector(const bNodeTree &ntree)
static void update_directly_linked_links_and_sockets(const bNodeTree &ntree)
static void update_root_frames(const bNodeTree &ntree)
static void update_toposort(const bNodeTree &ntree, const ToposortDirection direction, Vector< bNode * > &r_sorted_nodes, bool &r_cycle_detected)
void preprocess_geometry_node_tree_for_evaluation(bNodeTree &tree_cow)
static Vector< const bNode * > get_implicit_target_nodes(const bNodeTree &ntree, bNode &node)
static void update_socket_vectors_and_owner_node(const bNodeTree &ntree)
const bNodeZoneType * zone_type_by_node_type(const int node_type)
bNodeSocketType NodeSocketTypeUndefined
Definition node.cc:135
Span< int > all_zone_output_node_types()
bNodeType * node_type_find(UString idname)
Definition node.cc:2883
Span< int > all_zone_input_node_types()
Array< SocketUsage > infer_all_sockets_usage(const bNodeTree &tree)
const std::shared_ptr< const GeometryNodesLazyFunctionGraphInfo > & ensure_geometry_nodes_lazy_function_graph(const bNodeTree &btree)
void parallel_invoke(Functions &&...functions)
Definition BLI_task.hh:197
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
Definition BLI_task.hh:69
BMesh Iterators.
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
static void ensure_inference_usage_cache(const bNodeTree &tree)
bke::bNodeSocketType * typeinfo
bke::bNodeSocketRuntime * runtime
ListBaseT< bNodeLink > links
eNodeTree_Type type
bke::bNodeTreeRuntime * runtime
bke::bNodeRuntime * runtime
bNodeLink * try_find(bNodeTree &ntree) const
NodeLinkKey(const bNodeLink &link)
Defines a node type.
Definition BKE_node.hh:265