[Bf-blender-cvs] [4141c905f3d] functions: cleanup

[Jacques Lucke]

Commit: 4141c905f3d081f4885f4fe1e9b9f3ffd31d2eef
Author: Jacques Lucke
Date:   Sun Jan 26 20:50:02 2020 +0100
Branches: functions
https://developer.blender.org/rB4141c905f3d081f4885f4fe1e9b9f3ffd31d2eef

cleanup

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

M	source/blender/functions/FN_multi_function_network.h
M	source/blender/functions/intern/multi_functions/network.cc

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

diff --git a/source/blender/functions/FN_multi_function_network.h b/source/blender/functions/FN_multi_function_network.h
index c7ef567ed31..56a9016b8af 100644
--- a/source/blender/functions/FN_multi_function_network.h
+++ b/source/blender/functions/FN_multi_function_network.h
@@ -288,6 +288,7 @@ class MFNode : BLI::NonCopyable, BLI::NonMovable {
   const MFDummyNode &as_dummy() const;
 
   template<typename FuncT> void foreach_origin_node(const FuncT &func) const;
+  template<typename FuncT> void foreach_origin_socket(const FuncT &func) const;
 };
 
 class MFFunctionNode final : public MFNode {
@@ -661,7 +662,7 @@ inline const MFDummyNode &MFNode::as_dummy() const
   return *(const MFDummyNode *)this;
 }
 
-template<typename FuncT> void MFNode::foreach_origin_node(const FuncT &func) const
+template<typename FuncT> inline void MFNode::foreach_origin_node(const FuncT &func) const
 {
   for (const MFInputSocket *socket : m_inputs) {
     const MFOutputSocket &origin_socket = socket->origin();
@@ -670,6 +671,14 @@ template<typename FuncT> void MFNode::foreach_origin_node(const FuncT &func) con
   }
 }
 
+template<typename FuncT> inline void MFNode::foreach_origin_socket(const FuncT &func) const
+{
+  for (const MFInputSocket *socket : m_inputs) {
+    const MFOutputSocket &origin_socket = socket->origin();
+    func(origin_socket);
+  }
+}
+
 inline const MultiFunction &MFFunctionNode::function() const
 {
   return *m_function;
diff --git a/source/blender/functions/intern/multi_functions/network.cc b/source/blender/functions/intern/multi_functions/network.cc
index 3bde778cdda..11ab9d67348 100644
--- a/source/blender/functions/intern/multi_functions/network.cc
+++ b/source/blender/functions/intern/multi_functions/network.cc
@@ -308,10 +308,9 @@ class NetworkEvaluationStorage {
     return GenericVirtualListListRef::FromSingleArray(CPP_TYPE<float>(), nullptr, 0, 0);
   }
 
-  bool input_is_computed(const MFInputSocket &socket)
+  bool socket_is_computed(const MFOutputSocket &socket)
   {
-    const MFOutputSocket &origin = socket.origin();
-    OutputValue *any_value = m_value_per_output_id[origin.id()];
+    OutputValue *any_value = m_value_per_output_id[socket.id()];
     return any_value != nullptr;
   }
 };
@@ -401,48 +400,42 @@ BLI_NOINLINE void MF_EvaluateNetwork::evaluate_network_to_compute_outputs(
   const MFNetwork &network = m_outputs[0]->node().network();
   ArrayRef<uint> max_dependency_depths = network.max_dependency_depth_per_node();
 
-  Stack<const MFSocket *> sockets_to_compute;
-  sockets_to_compute.push_multiple(m_outputs.as_ref());
+  Stack<const MFOutputSocket *> sockets_to_compute;
+  for (const MFInputSocket *socket : m_outputs) {
+    sockets_to_compute.push(&socket->origin());
+  }
 
   while (!sockets_to_compute.is_empty()) {
-    const MFSocket &socket = *sockets_to_compute.peek();
+    const MFOutputSocket &socket = *sockets_to_compute.peek();
+    const MFNode &node = socket.node();
 
-    if (socket.is_input()) {
-      const MFInputSocket &input_socket = socket.as_input();
-      if (storage.input_is_computed(input_socket)) {
-        sockets_to_compute.pop();
-      }
-      else {
-        const MFOutputSocket &origin = input_socket.origin();
-        sockets_to_compute.push(&origin);
-      }
+    if (node.is_dummy()) {
+      BLI_assert(m_inputs.contains(&socket));
+      continue;
     }
-    else {
-      const MFOutputSocket &output_socket = socket.as_output();
-      const MFFunctionNode &function_node = output_socket.node().as_function();
-
-      ScopedVector<const MFInputSocket *> missing_inputs;
-      for (const MFInputSocket *input_socket : function_node.inputs()) {
-        if (!storage.input_is_computed(*input_socket)) {
-          missing_inputs.append(input_socket);
-          sockets_to_compute.push(input_socket);
-        }
+
+    const MFFunctionNode &function_node = node.as_function();
+
+    ScopedVector<const MFOutputSocket *> missing_sockets;
+    function_node.foreach_origin_socket([&](const MFOutputSocket &origin) {
+      if (!storage.socket_is_computed(origin)) {
+        missing_sockets.append(&origin);
       }
+    });
 
-      std::sort(missing_inputs.begin(),
-                missing_inputs.end(),
-                [&](const MFInputSocket *a, const MFInputSocket *b) {
-                  return max_dependency_depths[a->origin().node().id()] <
-                         max_dependency_depths[b->origin().node().id()];
-                });
+    std::sort(missing_sockets.begin(),
+              missing_sockets.end(),
+              [&](const MFOutputSocket *a, const MFOutputSocket *b) {
+                return max_dependency_depths[a->node().id()] <
+                       max_dependency_depths[b->node().id()];
+              });
 
-      sockets_to_compute.push_multiple(missing_inputs.as_ref());
+    sockets_to_compute.push_multiple(missing_sockets.as_ref());
 
-      bool all_inputs_are_computed = missing_inputs.size() == 0;
-      if (all_inputs_are_computed) {
-        this->evaluate_function(global_context, function_node, storage);
-        sockets_to_compute.pop();
-      }
+    bool all_inputs_are_computed = missing_sockets.size() == 0;
+    if (all_inputs_are_computed) {
+      this->evaluate_function(global_context, function_node, storage);
+      sockets_to_compute.pop();
     }
   }
 }