40 friend SocketUsageParams;
77 bool ignore_top_level_node_muting_ =
false;
85 const bool ignore_top_level_node_muting)
86 : compute_context_cache_(compute_context_cache),
87 value_inferencer_(value_inferencer),
89 ignore_top_level_node_muting_(ignore_top_level_node_muting)
91 root_tree_.ensure_topology_cache();
92 root_tree_.ensure_interface_cache();
97 for (
const bNode *
node : root_tree_.all_nodes()) {
98 if (
node->is_group_input()) {
104 all_socket_usages_.add_new({
nullptr, socket},
true);
111 for (
const bNode *
node : root_tree_.group_input_nodes()) {
113 if (!socket.is_directly_linked()) {
126 const std::optional<bool> is_used = all_socket_usages_.lookup_try(socket);
127 if (is_used.has_value()) {
130 if (socket->is_output() && !socket->is_directly_linked()) {
134 if (socket->owner_tree().has_available_link_cycle()) {
139 usage_tasks_.push(socket);
141 while (!usage_tasks_.is_empty()) {
143 this->usage_task(socket);
144 if (&socket == &usage_tasks_.peek()) {
150 return all_socket_usages_.lookup(socket);
155 return value_inferencer_.get_socket_value(socket);
160 const bNode *group_output_node = root_tree_.group_output_node();
161 if (!group_output_node) {
164 const SocketInContext socket{
nullptr, &group_output_node->input_socket(output_i)};
170 const std::optional<bool> is_disabled = all_socket_disable_states_.lookup_try(socket);
171 if (is_disabled.has_value()) {
174 if (socket->owner_tree().has_available_link_cycle()) {
177 BLI_assert(disabled_output_tasks_.is_empty());
178 disabled_output_tasks_.push(socket);
180 while (!disabled_output_tasks_.is_empty()) {
182 this->disabled_output_task(socket);
183 if (&socket == &disabled_output_tasks_.peek()) {
185 disabled_output_tasks_.pop();
188 return all_socket_disable_states_.lookup(socket);
194 if (all_socket_usages_.
contains(socket)) {
197 const bNode &
node = socket->owner_node();
198 if (!socket->is_available()) {
199 all_socket_usages_.
add_new(socket,
false);
202 if (
node.is_undefined() && !
node.is_custom_group()) {
203 all_socket_usages_.
add_new(socket,
false);
206 if (socket->is_input()) {
207 this->usage_task__input(socket);
210 this->usage_task__output(socket);
214 void usage_task__input(
const SocketInContext &socket)
216 const NodeInContext
node = socket.owner_node();
218 if (
node->is_muted()) {
219 const bool is_top_level = socket.context ==
nullptr;
220 if (!this->ignore_top_level_node_muting_ || !is_top_level) {
221 this->usage_task__input__muted_node(socket);
226 switch (
node->type_legacy) {
229 this->usage_task__input__group_node(socket);
233 this->usage_task__input__group_output_node(socket);
237 this->usage_task__input__generic_switch(
242 this->usage_task__input__generic_switch(
247 if (socket->index() == 0) {
248 this->usage_task__input__fallback(socket);
251 this->usage_task__input__generic_switch(
257 this->usage_task__input__generic_switch(
262 this->usage_task__input__generic_switch(
267 this->usage_task__input__simulation_input_node(socket);
271 this->usage_task__input__repeat_input_node(socket);
275 this->usage_task__input__foreach_element_input_node(socket);
279 this->usage_task__input__foreach_element_output_node(socket);
283 this->usage_task__input__capture_attribute_node(socket);
287 this->usage_task__input__warning_node(socket);
297 this->usage_task__input__output_node(socket);
301 if (
node->is_type(
"NodeEnableOutput"_ustr)) {
302 this->usage_task__input__enable_output(socket);
305 this->usage_task__input__fallback(socket);
311 void usage_task__input__output_node(
const SocketInContext &socket)
313 all_socket_usages_.add_new(socket,
true);
320 void usage_task__input__generic_switch(
321 const SocketInContext &socket,
322 const FunctionRef<
bool(
const SocketInContext &socket,
const InferenceValue &
condition)>
325 const NodeInContext
node = socket.owner_node();
329 if (socket->type ==
SOCK_CUSTOM &&
STREQ(socket->idname,
"NodeSocketVirtual")) {
330 all_socket_usages_.add_new(socket,
false);
333 const SocketInContext output_socket{socket.context,
334 get_first_available_bsocket(
node->output_sockets())};
335 const std::optional<bool> output_is_used = all_socket_usages_.lookup_try(output_socket);
336 if (!output_is_used.has_value()) {
337 this->push_usage_task(output_socket);
340 if (!*output_is_used) {
341 all_socket_usages_.add_new(socket,
false);
344 const SocketInContext condition_socket{socket.context,
345 get_first_available_bsocket(
node->input_sockets())};
346 if (socket == condition_socket) {
347 all_socket_usages_.add_new(socket,
true);
350 const InferenceValue condition_value = this->
get_socket_value(condition_socket);
351 if (condition_value.is_unknown()) {
353 all_socket_usages_.add_new(socket,
true);
356 const bool is_used = is_selected_socket(socket, condition_value);
357 all_socket_usages_.add_new(socket, is_used);
360 void usage_task__input__group_node(
const SocketInContext &socket)
362 const NodeInContext
node = socket.owner_node();
363 const bNodeTree *group =
reinterpret_cast<const bNodeTree *
>(
node->id);
365 all_socket_usages_.add_new(socket,
false);
368 group->ensure_topology_cache();
369 if (group->has_available_link_cycle()) {
370 all_socket_usages_.add_new(socket,
false);
376 const ComputeContext &group_context = compute_context_cache_.for_group_node(
377 socket.context,
node->identifier, &
node->owner_tree());
378 Vector<const bNodeSocket *> dependent_sockets;
379 for (
const bNode *group_input_node : group->group_input_nodes()) {
380 const bNodeSocket &group_input_socket = group_input_node->output_socket(socket->index());
381 if (group_input_socket.is_directly_linked()) {
384 dependent_sockets.append(&group_input_socket);
387 this->usage_task__with_dependent_sockets(socket, dependent_sockets, {}, &group_context);
390 void usage_task__input__group_output_node(
const SocketInContext &socket)
392 const int output_i = socket->index();
393 if (socket.context ==
nullptr) {
395 all_socket_usages_.add_new(socket,
true);
399 const bke::GroupNodeComputeContext &group_context =
400 *
static_cast<const bke::GroupNodeComputeContext *
>(socket.context);
401 const bNodeSocket &group_node_output = group_context.node()->output_socket(output_i);
402 this->usage_task__with_dependent_sockets(
403 socket, {&group_node_output}, {}, group_context.parent());
406 void usage_task__output(
const SocketInContext &socket)
409 Vector<const bNodeSocket *> dependent_sockets;
410 for (
const bNodeLink *link : socket->directly_linked_links()) {
411 if (link->is_used()) {
412 dependent_sockets.append(link->tosock);
415 this->usage_task__with_dependent_sockets(socket, dependent_sockets, {}, socket.context);
418 void usage_task__input__simulation_input_node(
const SocketInContext &socket)
420 const NodeInContext
node = socket.owner_node();
421 const bNodeTree &tree = socket->owner_tree();
423 const NodeGeometrySimulationInput &
storage = *
static_cast<const NodeGeometrySimulationInput *
>(
425 const bNode *sim_output_node = tree.node_by_id(
storage.output_node_id);
426 if (!sim_output_node) {
427 all_socket_usages_.add_new(socket,
false);
431 Vector<const bNodeSocket *, 16> dependent_sockets;
432 dependent_sockets.extend(
node->output_sockets());
433 dependent_sockets.extend(sim_output_node->output_sockets());
434 this->usage_task__with_dependent_sockets(socket, dependent_sockets, {}, socket.context);
437 void usage_task__input__repeat_input_node(
const SocketInContext &socket)
439 const NodeInContext
node = socket.owner_node();
440 const bNodeTree &tree = socket->owner_tree();
442 const NodeGeometryRepeatInput &
storage = *
static_cast<const NodeGeometryRepeatInput *
>(
444 const bNode *repeat_output_node = tree.node_by_id(
storage.output_node_id);
445 if (!repeat_output_node) {
446 all_socket_usages_.add_new(socket,
false);
451 Vector<const bNodeSocket *, 16> dependent_sockets;
452 dependent_sockets.extend(
node->output_sockets());
453 dependent_sockets.extend(repeat_output_node->output_sockets());
454 this->usage_task__with_dependent_sockets(socket, dependent_sockets, {}, socket.context);
457 void usage_task__input__foreach_element_output_node(
const SocketInContext &socket)
459 const NodeInContext
node = socket.owner_node();
460 this->usage_task__with_dependent_sockets(
461 socket, {
node->output_by_identifier(socket->identifier_ustr())}, {}, socket.context);
464 void usage_task__input__capture_attribute_node(
const SocketInContext &socket)
466 const NodeInContext
node = socket.owner_node();
467 this->usage_task__with_dependent_sockets(
468 socket, {&
node->output_socket(socket->index())}, {}, socket.context);
471 void usage_task__input__warning_node(
const SocketInContext &socket)
473 const NodeInContext
node = socket.owner_node();
474 const SocketInContext show_input_socket =
node.input_socket(0);
475 const SocketInContext message_input_socket =
node.input_socket(1);
476 const SocketInContext show_output_socket =
node.output_socket(0);
477 if (show_output_socket->is_directly_linked()) {
478 if (socket == show_input_socket) {
479 this->usage_task__with_dependent_sockets(
480 show_input_socket, {&*show_output_socket}, {}, socket.context);
482 if (socket == message_input_socket) {
483 this->usage_task__with_dependent_sockets(
484 message_input_socket, {&*show_output_socket}, {&*show_input_socket}, socket.context);
489 const bool is_top_level =
context ==
nullptr;
491 if (socket == show_input_socket) {
493 all_socket_usages_.add_new(socket,
true);
495 if (socket == message_input_socket) {
497 const InferenceValue show_inference_value = this->
get_socket_value(show_input_socket);
498 const bool show_value = show_inference_value.get_if_primitive<
bool>().value_or(
true);
499 all_socket_usages_.add_new(socket, show_value);
503 const bool is_in_zone = !
dynamic_cast<const bke::GroupNodeComputeContext *
>(
context);
506 all_socket_usages_.add_new(socket,
false);
509 const bNode *output_node =
node->owner_tree().group_output_node();
511 all_socket_usages_.add_new(socket,
false);
514 const Span<const bNodeSocket *> group_output_sockets = output_node->input_sockets().drop_back(
517 if (socket == show_input_socket) {
518 this->usage_task__with_dependent_sockets(
519 show_input_socket, group_output_sockets, {},
context);
521 if (socket == message_input_socket) {
522 this->usage_task__with_dependent_sockets(
523 message_input_socket, group_output_sockets, {&*show_input_socket},
context);
527 void usage_task__input__enable_output(
const SocketInContext &socket)
529 const NodeInContext
node = socket.owner_node();
530 const SocketInContext enable_socket =
node.input_socket(0);
531 const SocketInContext output_socket =
node.output_socket(0);
532 if (socket == enable_socket) {
533 this->usage_task__with_dependent_sockets(socket, {&*output_socket}, {}, socket.context);
536 this->usage_task__with_dependent_sockets(
537 socket, {&*output_socket}, {&*enable_socket}, socket.context);
541 void usage_task__input__fallback(
const SocketInContext &socket)
543 const SocketDeclaration *socket_decl = socket->runtime->declaration;
545 all_socket_usages_.add_new(socket,
true);
548 if (!socket_decl->usage_inference_fn) {
549 this->usage_task__with_dependent_sockets(
550 socket, socket->owner_node().output_sockets(), {}, socket.context);
553 SocketUsageParams params{
554 *
owner_, socket.context, socket->owner_tree(), socket->owner_node(), *socket};
555 const std::optional<bool> is_used = (*socket_decl->usage_inference_fn)(params);
556 if (!is_used.has_value()) {
560 all_socket_usages_.add_new(socket, *is_used);
563 void usage_task__input__foreach_element_input_node(
const SocketInContext &socket)
565 const NodeInContext
node = socket.owner_node();
566 const bNodeTree &tree = socket->owner_tree();
568 const NodeGeometryForeachGeometryElementInput &
storage =
569 *
static_cast<const NodeGeometryForeachGeometryElementInput *
>(
node->storage);
570 const bNode *foreach_output_node = tree.node_by_id(
storage.output_node_id);
571 if (!foreach_output_node) {
572 all_socket_usages_.add_new(socket,
false);
575 Vector<const bNodeSocket *, 16> dependent_sockets;
576 if (
StringRef(socket->identifier).startswith(
"Input_")) {
577 dependent_sockets.append(
node->output_by_identifier(socket->identifier_ustr()));
581 dependent_sockets.extend(
node->output_sockets());
582 dependent_sockets.extend(foreach_output_node->output_sockets());
584 this->usage_task__with_dependent_sockets(socket, dependent_sockets, {}, socket.context);
587 void usage_task__input__muted_node(
const SocketInContext &socket)
589 const NodeInContext
node = socket.owner_node();
590 Vector<const bNodeSocket *> dependent_sockets;
591 for (
const bNodeInternalLink &internal_link :
node->internal_links()) {
592 if (internal_link.in != socket.socket) {
595 dependent_sockets.append(internal_link.out);
597 this->usage_task__with_dependent_sockets(socket, dependent_sockets, {}, socket.context);
604 void usage_task__with_dependent_sockets(
const SocketInContext &socket,
605 const Span<const bNodeSocket *> dependent_sockets,
606 const Span<const bNodeSocket *> condition_inputs,
607 const ComputeContext *dependent_socket_context)
610 SocketInContext next_unknown_socket;
611 bool any_output_used =
false;
612 for (
const bNodeSocket *dependent_socket_ptr : dependent_sockets) {
613 const SocketInContext dependent_socket{dependent_socket_context, dependent_socket_ptr};
614 const std::optional<bool> is_used = all_socket_usages_.lookup_try(dependent_socket);
615 if (!is_used.has_value()) {
616 if (dependent_socket_ptr->is_output() && !dependent_socket_ptr->is_directly_linked()) {
619 if (!next_unknown_socket) {
620 next_unknown_socket = dependent_socket;
624 if (is_used.value_or(
false)) {
625 any_output_used =
true;
629 if (next_unknown_socket) {
633 this->push_usage_task(next_unknown_socket);
636 if (!any_output_used) {
637 all_socket_usages_.add_new(socket,
false);
640 bool all_condition_inputs_true =
true;
641 for (
const bNodeSocket *condition_input_ptr : condition_inputs) {
642 const SocketInContext condition_input{dependent_socket_context, condition_input_ptr};
643 const InferenceValue condition_value = this->
get_socket_value(condition_input);
644 if (!condition_value.is_primitive_value()) {
649 if (!condition_value.get_primitive<
bool>()) {
650 all_condition_inputs_true =
false;
654 all_socket_usages_.add_new(socket, all_condition_inputs_true);
657 void push_usage_task(
const SocketInContext &socket)
659 usage_tasks_.push(socket);
662 void disabled_output_task(
const SocketInContext &socket)
664 if (all_socket_disable_states_.contains(socket)) {
667 const bNode &
node = socket->owner_node();
668 if (!socket->is_available()) {
669 all_socket_disable_states_.add_new(socket,
true);
672 if (
node.is_undefined() && !
node.is_custom_group()) {
673 all_socket_disable_states_.add_new(socket,
true);
676 if (socket->is_input()) {
677 this->disabled_output_task__input(socket);
680 this->disabled_output_task__output(socket);
684 void disabled_output_task__input(
const SocketInContext &socket)
686 const Span<const bNodeLink *> links = socket->directly_linked_links();
687 const bNodeLink *single_link = links.
size() == 1 && links[0]->is_used() ? links[0] :
nullptr;
688 if (links.
size() != 1 || !links[0]->is_used()) {
690 all_socket_disable_states_.add_new(socket,
false);
693 const SocketInContext origin_socket{socket.context, single_link->fromsock};
694 this->disabled_output_task__with_origin_socket(socket, origin_socket);
697 void disabled_output_task__output(
const SocketInContext &socket)
699 const NodeInContext
node = socket.owner_node();
700 if (
node->is_muted()) {
701 const bool is_top_level = socket.context ==
nullptr;
702 if (!this->ignore_top_level_node_muting_ || !is_top_level) {
703 this->disabled_output_task__output__muted_node(socket);
708 switch (
node->type_legacy) {
711 this->disabled_output_task__output__group_node(socket);
715 this->disabled_output_task__with_origin_socket(socket,
node.input_socket(0));
719 this->disabled_output_task__output__generic_switch(
724 this->disabled_output_task__output__generic_switch(
729 this->disabled_output_task__output__generic_switch(
734 if (
node->is_type(
"NodeEnableOutput"_ustr)) {
735 this->disabled_output_task__output__enable_output_node(socket);
739 const SocketDeclaration *socket_declaration = socket->runtime->declaration;
740 if (socket_declaration && socket_declaration->usage_inference_fn) {
741 SocketUsageParams params{
742 *
owner_, socket.context, socket->owner_tree(), socket->owner_node(), *socket};
743 const std::optional<bool> is_used = (*socket_declaration->usage_inference_fn)(params);
744 if (!is_used.has_value()) {
749 all_socket_disable_states_.add_new(socket,
true);
756 all_socket_disable_states_.add_new(socket,
false);
762 void disabled_output_task__output__muted_node(
const SocketInContext &socket)
764 const NodeInContext
node = socket.owner_node();
765 for (
const bNodeInternalLink &internal_link :
node->internal_links()) {
766 if (internal_link.out != socket.socket) {
769 this->disabled_output_task__with_origin_socket(socket, {socket.context, internal_link.in});
772 all_socket_disable_states_.add_new(socket,
false);
775 void disabled_output_task__output__group_node(
const SocketInContext &socket)
777 const NodeInContext
node = socket.owner_node();
778 const bNodeTree *group =
reinterpret_cast<const bNodeTree *
>(
node->id);
780 all_socket_disable_states_.add_new(socket,
false);
783 group->ensure_topology_cache();
784 if (group->has_available_link_cycle()) {
785 all_socket_disable_states_.add_new(socket,
false);
788 const bNode *group_output_node = group->group_output_node();
789 if (!group_output_node) {
790 all_socket_disable_states_.add_new(socket,
false);
793 const ComputeContext &group_context = compute_context_cache_.for_group_node(
794 socket.context,
node->identifier, &
node->owner_tree());
795 const SocketInContext origin_socket{&group_context,
796 &group_output_node->input_socket(socket->index())};
797 this->disabled_output_task__with_origin_socket(socket, origin_socket);
800 void disabled_output_task__output__generic_switch(
801 const SocketInContext &socket,
802 const FunctionRef<
bool(
const SocketInContext &socket,
const InferenceValue &
condition)>
805 const NodeInContext
node = socket.owner_node();
809 if (socket->type ==
SOCK_CUSTOM &&
STREQ(socket->idname,
"NodeSocketVirtual")) {
810 all_socket_disable_states_.add_new(socket,
false);
813 const SocketInContext condition_socket{socket.context,
814 get_first_available_bsocket(
node->input_sockets())};
815 const InferenceValue condition_value = this->
get_socket_value(condition_socket);
816 if (condition_value.is_unknown()) {
817 all_socket_disable_states_.add_new(socket,
false);
820 for (
const bNodeSocket *input_socket :
node->input_sockets()) {
821 if (!input_socket->is_available()) {
824 if (input_socket->type ==
SOCK_CUSTOM &&
STREQ(input_socket->idname,
"NodeSocketVirtual")) {
827 if (input_socket == condition_socket.socket) {
830 const SocketInContext origin_socket{socket.context, input_socket};
831 const bool is_selected = is_selected_socket(origin_socket, condition_value);
833 this->disabled_output_task__with_origin_socket(socket, origin_socket);
837 all_socket_disable_states_.add_new(socket,
false);
840 void disabled_output_task__output__enable_output_node(
const SocketInContext &socket)
842 const NodeInContext
node = socket.owner_node();
843 const SocketInContext enable_socket =
node.input_socket(0);
845 const std::optional<bool> is_enabled_opt = enable_value.get_if_primitive<
bool>();
846 const bool is_enabled = is_enabled_opt.value_or(
true);
847 all_socket_disable_states_.add_new(socket, !is_enabled);
850 void disabled_output_task__with_origin_socket(
const SocketInContext &socket,
851 const SocketInContext &origin_socket)
853 const std::optional<bool> is_disabled = all_socket_disable_states_.lookup_try(origin_socket);
854 if (is_disabled.has_value()) {
855 all_socket_disable_states_.add_new(socket, *is_disabled);
858 this->push_disabled_output_task(origin_socket);
861 void push_disabled_output_task(
const SocketInContext &socket)
863 disabled_output_tasks_.push(socket);
866 static const bNodeSocket *get_first_available_bsocket(
const Span<const bNodeSocket *> sockets)
868 for (
const bNodeSocket *socket : sockets) {
869 if (socket->is_available()) {