1 files changed, 20 insertions, 21 deletions

diff --git a/source/blender/functions/intern/multi_function_network_evaluation.cc b/source/blender/functions/intern/multi_function_network_evaluation.cc
index 08a254dc300..b59cbc6a1a2 100644
--- a/source/blender/functions/intern/multi_function_network_evaluation.cc
+++ b/source/blender/functions/intern/multi_function_network_evaluation.cc
@@ -58,7 +58,7 @@ class MFNetworkEvaluationStorage {
   uint min_array_size_;
 
  public:
-  MFNetworkEvaluationStorage(IndexMask mask, uint max_socket_id);
+  MFNetworkEvaluationStorage(IndexMask mask, uint socket_id_amount);
   ~MFNetworkEvaluationStorage();
 
   /* Add the values that have been provided by the caller of the multi-function network. */
@@ -106,30 +106,30 @@ MFNetworkEvaluator::MFNetworkEvaluator(Vector<const MFOutputSocket *> inputs,
   BLI_assert(outputs_.size() > 0);
   MFSignatureBuilder signature = this->get_builder("Function Tree");
 
-  for (auto socket : inputs_) {
+  for (const MFOutputSocket *socket : inputs_) {
     BLI_assert(socket->node().is_dummy());
 
     MFDataType type = socket->data_type();
     switch (type.category()) {
       case MFDataType::Single:
-        signature.single_input("Input", type.single_type());
+        signature.single_input(socket->name(), type.single_type());
         break;
       case MFDataType::Vector:
-        signature.vector_input("Input", type.vector_base_type());
+        signature.vector_input(socket->name(), type.vector_base_type());
         break;
     }
   }
 
-  for (auto socket : outputs_) {
+  for (const MFInputSocket *socket : outputs_) {
     BLI_assert(socket->node().is_dummy());
 
     MFDataType type = socket->data_type();
     switch (type.category()) {
       case MFDataType::Single:
-        signature.single_output("Output", type.single_type());
+        signature.single_output(socket->name(), type.single_type());
         break;
       case MFDataType::Vector:
-        signature.vector_output("Output", type.vector_base_type());
+        signature.vector_output(socket->name(), type.vector_base_type());
         break;
     }
   }
@@ -142,7 +142,7 @@ void MFNetworkEvaluator::call(IndexMask mask, MFParams params, MFContext context
   }
 
   const MFNetwork &network = outputs_[0]->node().network();
-  Storage storage(mask, network.max_socket_id());
+  Storage storage(mask, network.socket_id_amount());
 
   Vector<const MFInputSocket *> outputs_to_initialize_in_the_end;
 
@@ -219,8 +219,6 @@ BLI_NOINLINE void MFNetworkEvaluator::evaluate_network_to_compute_outputs(
     sockets_to_compute.push(socket->origin());
   }
 
-  Vector<const MFOutputSocket *, 32> missing_sockets;
-
   /* This is the main loop that traverses the MFNetwork. */
   while (!sockets_to_compute.is_empty()) {
     const MFOutputSocket &socket = *sockets_to_compute.peek();
@@ -235,17 +233,18 @@ BLI_NOINLINE void MFNetworkEvaluator::evaluate_network_to_compute_outputs(
     BLI_assert(node.all_inputs_have_origin());
     const MFFunctionNode &function_node = node.as_function();
 
-    missing_sockets.clear();
-    function_node.foreach_origin_socket([&](const MFOutputSocket &origin) {
-      if (!storage.socket_is_computed(origin)) {
-        missing_sockets.append(&origin);
+    bool all_origins_are_computed = true;
+    for (const MFInputSocket *input_socket : function_node.inputs()) {
+      const MFOutputSocket *origin = input_socket->origin();
+      if (origin != nullptr) {
+        if (!storage.socket_is_computed(*origin)) {
+          sockets_to_compute.push(origin);
+          all_origins_are_computed = false;
+        }
       }
-    });
-
-    sockets_to_compute.push_multiple(missing_sockets);
+    }
 
-    bool all_inputs_are_computed = missing_sockets.size() == 0;
-    if (all_inputs_are_computed) {
+    if (all_origins_are_computed) {
       this->evaluate_function(global_context, function_node, storage);
       sockets_to_compute.pop();
     }
@@ -507,9 +506,9 @@ struct OwnVectorValue : public Value {
 /** \name Storage methods
  * \{ */
 
-MFNetworkEvaluationStorage::MFNetworkEvaluationStorage(IndexMask mask, uint max_socket_id)
+MFNetworkEvaluationStorage::MFNetworkEvaluationStorage(IndexMask mask, uint socket_id_amount)
     : mask_(mask),
-      value_per_output_id_(max_socket_id + 1, nullptr),
+      value_per_output_id_(socket_id_amount, nullptr),
       min_array_size_(mask.min_array_size())
 {
 }