[Bf-blender-cvs] [d6fcecc4715] spreadsheet-active-node: cleanup

[Jacques Lucke]

Commit: d6fcecc4715894d332026f3e25b22d8a5a45eb13
Author: Jacques Lucke
Date:   Thu Apr 1 12:12:18 2021 +0200
Branches: spreadsheet-active-node
https://developer.blender.org/rBd6fcecc4715894d332026f3e25b22d8a5a45eb13

cleanup

===================================================================

M	source/blender/nodes/NOD_node_tree_ref.hh
M	source/blender/nodes/intern/node_tree_ref.cc

===================================================================

diff --git a/source/blender/nodes/NOD_node_tree_ref.hh b/source/blender/nodes/NOD_node_tree_ref.hh
index 6dc0457a812..1558efdd245 100644
--- a/source/blender/nodes/NOD_node_tree_ref.hh
+++ b/source/blender/nodes/NOD_node_tree_ref.hh
@@ -85,6 +85,8 @@ class SocketRef : NonCopyable, NonMovable {
   /* These sockets are linked when reroutes, muted links and muted nodes have been taken into
    * account. */
   MutableSpan<const SocketRef *> logically_linked_sockets_;
+  /* These are the sockets that have been skipped when searching for logicaly linked sockets. That
+   * includes for example the input and output socket of an intermediate reroute node. */
   MutableSpan<const SocketRef *> logically_linked_skipped_sockets_;
 
   friend NodeTreeRef;
@@ -136,6 +138,7 @@ class InputSocketRef final : public SocketRef {
   bool is_multi_input_socket() const;
 
   void foreach_logical_origin(FunctionRef<void(const OutputSocketRef &)> callback,
+                              FunctionRef<void(const SocketRef &)> skipped_callback,
                               bool only_follow_first_input_link = false) const;
 };
 
diff --git a/source/blender/nodes/intern/node_tree_ref.cc b/source/blender/nodes/intern/node_tree_ref.cc
index 5ddccba6ad6..19d1f37e01c 100644
--- a/source/blender/nodes/intern/node_tree_ref.cc
+++ b/source/blender/nodes/intern/node_tree_ref.cc
@@ -172,8 +172,10 @@ void NodeTreeRef::create_linked_socket_caches()
 
     /* Find logically linked sockets. */
     Vector<const SocketRef *> logically_linked_sockets;
+    Vector<const SocketRef *> logically_linked_skipped_sockets;
     socket->foreach_logical_origin(
-        [&](const OutputSocketRef &origin) { logically_linked_sockets.append(&origin); }, {});
+        [&](const OutputSocketRef &origin) { logically_linked_sockets.append(&origin); },
+        [&](const SocketRef &socket) { logically_linked_skipped_sockets.append(&socket); });
     if (logically_linked_sockets == directly_linked_sockets) {
       socket->logically_linked_sockets_ = socket->directly_linked_sockets_;
     }
@@ -181,6 +183,8 @@ void NodeTreeRef::create_linked_socket_caches()
       socket->logically_linked_sockets_ = allocator_.construct_array_copy(
           logically_linked_sockets.as_span());
     }
+    socket->logically_linked_skipped_sockets_ = allocator_.construct_array_copy(
+        logically_linked_skipped_sockets.as_span());
   }
 
   for (OutputSocketRef *socket : output_sockets_) {
@@ -211,6 +215,7 @@ void NodeTreeRef::create_linked_socket_caches()
 }
 
 void InputSocketRef::foreach_logical_origin(FunctionRef<void(const OutputSocketRef &)> callback,
+                                            FunctionRef<void(const SocketRef &)> skipped_callback,
                                             bool only_follow_first_input_link) const
 {
   Span<const LinkRef *> links_to_check = this->directly_linked_links();
@@ -224,12 +229,19 @@ void InputSocketRef::foreach_logical_origin(FunctionRef<void(const OutputSocketR
     const OutputSocketRef &origin = link->from();
     const NodeRef &origin_node = origin.node();
     if (origin_node.is_reroute_node()) {
-      origin_node.input(0).foreach_logical_origin(callback, false);
+      const InputSocketRef &reroute_input = origin_node.input(0);
+      const OutputSocketRef &reroute_output = origin_node.output(0);
+      skipped_callback.call_if_available(reroute_input);
+      skipped_callback.call_if_available(reroute_output);
+      reroute_input.foreach_logical_origin(callback, skipped_callback, false);
     }
     else if (origin_node.is_muted()) {
       for (const InternalLinkRef *internal_link : origin_node.internal_links()) {
         if (&internal_link->to() == &origin) {
-          internal_link->from().foreach_logical_origin(callback, true);
+          const InputSocketRef &mute_input = internal_link->from();
+          skipped_callback.call_if_available(origin);
+          skipped_callback.call_if_available(mute_input);
+          mute_input.foreach_logical_origin(callback, skipped_callback, true);
           break;
         }
       }