Simulation: cleanup deduplicating attribute input nodes

3 files changed, 46 insertions, 19 deletions

diff --git a/source/blender/functions/FN_multi_function_network.hh b/source/blender/functions/FN_multi_function_network.hh
index e47c8260057..91eb5bb65dc 100644
--- a/source/blender/functions/FN_multi_function_network.hh
+++ b/source/blender/functions/FN_multi_function_network.hh
@@ -233,6 +233,8 @@ class MFNetwork : NonCopyable, NonMovable {
                          VectorSet<const MFOutputSocket *> &r_dummy_sockets,
                          VectorSet<const MFInputSocket *> &r_unlinked_inputs) const;
 
+  bool have_dummy_or_unlinked_dependencies(Span<const MFInputSocket *> sockets) const;
+
   std::string to_dot(Span<const MFNode *> marked_nodes = {}) const;
 };
 
diff --git a/source/blender/functions/intern/multi_function_network.cc b/source/blender/functions/intern/multi_function_network.cc
index 11c9c065f51..1d3d3a8b5f2 100644
--- a/source/blender/functions/intern/multi_function_network.cc
+++ b/source/blender/functions/intern/multi_function_network.cc
@@ -269,6 +269,14 @@ void MFNetwork::find_dependencies(Span<const MFInputSocket *> sockets,
   }
 }
 
+bool MFNetwork::have_dummy_or_unlinked_dependencies(Span<const MFInputSocket *> sockets) const
+{
+  VectorSet<const MFOutputSocket *> dummy_sockets;
+  VectorSet<const MFInputSocket *> unlinked_inputs;
+  this->find_dependencies(sockets, dummy_sockets, unlinked_inputs);
+  return dummy_sockets.size() + unlinked_inputs.size() > 0;
+}
+
 std::string MFNetwork::to_dot(Span<const MFNode *> marked_nodes) const
 {
   dot::DirectedGraph digraph;
diff --git a/source/blender/simulation/intern/simulation_collect_influences.cc b/source/blender/simulation/intern/simulation_collect_influences.cc
index 84188096081..3e35b040dbe 100644
--- a/source/blender/simulation/intern/simulation_collect_influences.cc
+++ b/source/blender/simulation/intern/simulation_collect_influences.cc
@@ -43,44 +43,61 @@ static std::string dnode_to_path(const nodes::DNode &dnode)
   return path;
 }
 
-static Map<const fn::MFOutputSocket *, std::string> find_and_deduplicate_particle_attribute_nodes(
-    nodes::MFNetworkTreeMap &network_map, DummyDataSources &r_data_sources)
+static std::optional<Array<std::string>> compute_global_string_inputs(
+    nodes::MFNetworkTreeMap &network_map, Span<const fn::MFInputSocket *> sockets)
 {
-  fn::MFNetwork &network = network_map.network();
-  const nodes::DerivedNodeTree &tree = network_map.tree();
-
-  Span<const nodes::DNode *> attribute_dnodes = tree.nodes_by_type(
-      "SimulationNodeParticleAttribute");
-  uint amount = attribute_dnodes.size();
+  uint amount = sockets.size();
   if (amount == 0) {
-    return {};
+    return Array<std::string>();
   }
 
-  Vector<fn::MFInputSocket *> name_sockets;
-  for (const nodes::DNode *dnode : attribute_dnodes) {
-    fn::MFInputSocket &name_socket = network_map.lookup_dummy(dnode->input(0));
-    name_sockets.append(&name_socket);
+  if (network_map.network().have_dummy_or_unlinked_dependencies(sockets)) {
+    return {};
   }
 
-  fn::MFNetworkEvaluator network_fn{{}, name_sockets.as_span()};
+  fn::MFNetworkEvaluator network_fn{{}, sockets};
 
   fn::MFParamsBuilder params{network_fn, 1};
 
-  Array<std::string> attribute_names{amount, NoInitialization()};
+  Array<std::string> strings(amount, NoInitialization());
   for (uint i : IndexRange(amount)) {
     params.add_uninitialized_single_output(
-        fn::GMutableSpan(fn::CPPType::get<std::string>(), attribute_names.data() + i, 1));
+        fn::GMutableSpan(fn::CPPType::get<std::string>(), strings.data() + i, 1));
   }
 
   fn::MFContextBuilder context;
-  /* Todo: Check that the names don't depend on dummy nodes. */
   network_fn.call({0}, params, context);
 
+  return strings;
+}
+
+static void find_and_deduplicate_particle_attribute_nodes(nodes::MFNetworkTreeMap &network_map,
+                                                          DummyDataSources &r_data_sources)
+{
+  fn::MFNetwork &network = network_map.network();
+  const nodes::DerivedNodeTree &tree = network_map.tree();
+
+  Span<const nodes::DNode *> attribute_dnodes = tree.nodes_by_type(
+      "SimulationNodeParticleAttribute");
+
+  Vector<fn::MFInputSocket *> name_sockets;
+  for (const nodes::DNode *dnode : attribute_dnodes) {
+    fn::MFInputSocket &name_socket = network_map.lookup_dummy(dnode->input(0));
+    name_sockets.append(&name_socket);
+  }
+
+  std::optional<Array<std::string>> attribute_names = compute_global_string_inputs(network_map,
+                                                                                   name_sockets);
+  if (!attribute_names.has_value()) {
+    return;
+  }
+
   Map<std::pair<std::string, fn::MFDataType>, Vector<fn::MFNode *>>
       attribute_nodes_by_name_and_type;
-  for (uint i : IndexRange(amount)) {
+  for (uint i : attribute_names->index_range()) {
     attribute_nodes_by_name_and_type
-        .lookup_or_add_default({attribute_names[i], name_sockets[i]->node().output(0).data_type()})
+        .lookup_or_add_default(
+            {(*attribute_names)[i], name_sockets[i]->node().output(0).data_type()})
         .append(&name_sockets[i]->node());
   }