[Bf-blender-cvs] [82ae82488e8] functions: cleanup data flow graph generation

[Jacques Lucke]

Commit: 82ae82488e8e79d3a23a7db3b78f430d0449c757
Author: Jacques Lucke
Date:   Thu Jul 4 15:31:09 2019 +0200
Branches: functions
https://developer.blender.org/rB82ae82488e8e79d3a23a7db3b78f430d0449c757

cleanup data flow graph generation

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

M	source/blender/functions/frontends/data_flow_nodes/function_generation.cpp
M	source/blender/functions/frontends/data_flow_nodes/graph_generation.cpp
M	source/blender/functions/frontends/data_flow_nodes/graph_generation.hpp

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

diff --git a/source/blender/functions/frontends/data_flow_nodes/function_generation.cpp b/source/blender/functions/frontends/data_flow_nodes/function_generation.cpp
index 94e3a3cad1c..0d92f18ef85 100644
--- a/source/blender/functions/frontends/data_flow_nodes/function_generation.cpp
+++ b/source/blender/functions/frontends/data_flow_nodes/function_generation.cpp
@@ -11,7 +11,9 @@ namespace DataFlowNodes {
 
 Optional<SharedFunction> generate_function(bNodeTree *btree)
 {
-  Optional<FunctionGraph> fgraph_ = generate_function_graph(btree);
+  IndexedNodeTree indexed_btree(btree);
+
+  Optional<FunctionGraph> fgraph_ = generate_function_graph(indexed_btree);
   if (!fgraph_.has_value()) {
     return {};
   }
diff --git a/source/blender/functions/frontends/data_flow_nodes/graph_generation.cpp b/source/blender/functions/frontends/data_flow_nodes/graph_generation.cpp
index e03b58d42fe..f57b25416f3 100644
--- a/source/blender/functions/frontends/data_flow_nodes/graph_generation.cpp
+++ b/source/blender/functions/frontends/data_flow_nodes/graph_generation.cpp
@@ -84,57 +84,48 @@ static void insert_unlinked_inputs(BTreeGraphBuilder &builder, GraphInserters &i
   }
 }
 
-static FunctionGraph finalize_function_graph(DataFlowGraphBuilder &builder,
-                                             DFGB_SocketVector input_sockets,
-                                             DFGB_SocketVector output_sockets)
+static void find_interface_sockets(IndexedNodeTree &indexed_btree,
+                                   GeneratedGraph &graph,
+                                   DFGraphSocketSetVector &r_inputs,
+                                   DFGraphSocketSetVector &r_outputs)
 {
-  auto build_result = DataFlowGraph::FromBuilder(builder);
-  auto &builder_mapping = build_result.mapping;
-
-  DFGraphSocketSetVector inputs, outputs;
-
-  for (DFGB_Socket socket : input_sockets) {
-    inputs.add(builder_mapping.map_socket(socket));
-  }
-  for (DFGB_Socket socket : output_sockets) {
-    outputs.add(builder_mapping.map_socket(socket));
-  }
-
-  return FunctionGraph(build_result.graph, inputs, outputs);
-}
-
-static void find_interface_sockets(BTreeGraphBuilder &builder,
-                                   DFGB_SocketVector &r_inputs,
-                                   DFGB_SocketVector &r_outputs)
-{
-  bNode *input_node =
-      builder.indexed_btree().nodes_with_idname("fn_FunctionInputNode").get(0, nullptr);
-  bNode *output_node =
-      builder.indexed_btree().nodes_with_idname("fn_FunctionOutputNode").get(0, nullptr);
+  bNode *input_node = indexed_btree.nodes_with_idname("fn_FunctionInputNode").get(0, nullptr);
+  bNode *output_node = indexed_btree.nodes_with_idname("fn_FunctionOutputNode").get(0, nullptr);
 
   if (input_node != nullptr) {
     for (bNodeSocket *bsocket : bSocketList(input_node->outputs)) {
-      if (builder.is_data_socket(bsocket)) {
-        r_inputs.append(builder.lookup_socket(bsocket));
+      if (bsocket != (bNodeSocket *)input_node->outputs.last) {
+        r_inputs.add_new(graph.lookup_socket(bsocket));
       }
     }
   }
 
   if (output_node != nullptr) {
     for (bNodeSocket *bsocket : bSocketList(output_node->inputs)) {
-      if (builder.is_data_socket(bsocket)) {
-        r_outputs.append(builder.lookup_socket(bsocket));
+      if (bsocket != (bNodeSocket *)output_node->inputs.last) {
+        r_outputs.add_new(graph.lookup_socket(bsocket));
       }
     }
   }
 }
 
-Optional<FunctionGraph> generate_function_graph(bNodeTree *btree)
+static SmallMap<bNodeSocket *, DFGraphSocket> build_mapping_for_original_sockets(
+    SmallMap<bNodeSocket *, DFGB_Socket> &socket_map,
+    DataFlowGraph::ToBuilderMapping &builder_mapping)
 {
-  IndexedNodeTree indexed_btree(btree);
+  SmallMap<bNodeSocket *, DFGraphSocket> original_socket_mapping;
+  for (auto item : socket_map.items()) {
+    bNodeSocket *bsocket = item.key;
+    DFGraphSocket socket = builder_mapping.map_socket(item.value);
+    original_socket_mapping.add_new(bsocket, socket);
+  }
+  return original_socket_mapping;
+}
 
+Optional<GeneratedGraph> generate_graph(IndexedNodeTree &indexed_btree)
+{
   DataFlowGraphBuilder graph_builder;
-  SmallMap<struct bNodeSocket *, DFGB_Socket> socket_map;
+  SmallMap<bNodeSocket *, DFGB_Socket> socket_map;
 
   BTreeGraphBuilder builder(indexed_btree, graph_builder, socket_map);
   GraphInserters &inserters = get_standard_inserters();
@@ -149,11 +140,25 @@ Optional<FunctionGraph> generate_function_graph(bNodeTree *btree)
 
   insert_unlinked_inputs(builder, inserters);
 
-  DFGB_SocketVector input_sockets;
-  DFGB_SocketVector output_sockets;
-  find_interface_sockets(builder, input_sockets, output_sockets);
+  auto build_result = DataFlowGraph::FromBuilder(graph_builder);
+  return GeneratedGraph(std::move(build_result.graph),
+                        build_mapping_for_original_sockets(socket_map, build_result.mapping));
+}
+
+Optional<FunctionGraph> generate_function_graph(IndexedNodeTree &indexed_btree)
+{
+  Optional<GeneratedGraph> generated_graph_ = generate_graph(indexed_btree);
+  if (!generated_graph_.has_value()) {
+    return {};
+  }
+
+  GeneratedGraph &generated_graph = generated_graph_.value();
+
+  DFGraphSocketSetVector input_sockets;
+  DFGraphSocketSetVector output_sockets;
+  find_interface_sockets(indexed_btree, generated_graph, input_sockets, output_sockets);
 
-  return finalize_function_graph(graph_builder, input_sockets, output_sockets);
+  return FunctionGraph(generated_graph.graph(), input_sockets, output_sockets);
 }
 
 }  // namespace DataFlowNodes
diff --git a/source/blender/functions/frontends/data_flow_nodes/graph_generation.hpp b/source/blender/functions/frontends/data_flow_nodes/graph_generation.hpp
index 2fef403d5ff..7905cd3291c 100644
--- a/source/blender/functions/frontends/data_flow_nodes/graph_generation.hpp
+++ b/source/blender/functions/frontends/data_flow_nodes/graph_generation.hpp
@@ -2,12 +2,38 @@
 
 #include "FN_core.hpp"
 #include "BLI_optional.hpp"
-
-struct bNodeTree;
+#include "BKE_node_tree.hpp"
 
 namespace FN {
 namespace DataFlowNodes {
 
-Optional<FunctionGraph> generate_function_graph(struct bNodeTree *btree);
-}
+using BKE::IndexedNodeTree;
+
+class GeneratedGraph {
+ private:
+  SharedDataFlowGraph m_graph;
+  SmallMap<bNodeSocket *, DFGraphSocket> m_mapping;
+
+ public:
+  GeneratedGraph(SharedDataFlowGraph graph, SmallMap<bNodeSocket *, DFGraphSocket> mapping)
+      : m_graph(std::move(graph)), m_mapping(std::move(mapping))
+  {
+  }
+
+  SharedDataFlowGraph &graph()
+  {
+    return m_graph;
+  }
+
+  DFGraphSocket lookup_socket(bNodeSocket *bsocket)
+  {
+    return m_mapping.lookup(bsocket);
+  }
+};
+
+Optional<GeneratedGraph> generate_graph(IndexedNodeTree &indexed_btree);
+
+Optional<FunctionGraph> generate_function_graph(IndexedNodeTree &indexed_btree);
+
+}  // namespace DataFlowNodes
 }  // namespace FN