[Bf-blender-cvs] [5bbc1b2e167] functions: refactor: initial removal of FunctionTreeMFNetworkBuilder

Jacques Lucke noreply at git.blender.org
Sat Jan 4 16:38:50 CET 2020


Commit: 5bbc1b2e167c6c2940aafce9edae11e79ab48d3e
Author: Jacques Lucke
Date:   Sat Jan 4 13:17:33 2020 +0100
Branches: functions
https://developer.blender.org/rB5bbc1b2e167c6c2940aafce9edae11e79ab48d3e

refactor: initial removal of FunctionTreeMFNetworkBuilder

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

M	source/blender/functions/intern/node_tree_multi_function_network/builder.cc
M	source/blender/functions/intern/node_tree_multi_function_network/builder.h
M	source/blender/functions/intern/node_tree_multi_function_network/generate.cc
M	source/blender/functions/intern/node_tree_multi_function_network/mappings.h
M	source/blender/functions/intern/node_tree_multi_function_network/mappings_nodes.cc
M	source/blender/functions/intern/node_tree_multi_function_network/mappings_sockets.cc

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

diff --git a/source/blender/functions/intern/node_tree_multi_function_network/builder.cc b/source/blender/functions/intern/node_tree_multi_function_network/builder.cc
index 91cd998eedb..9fdee6aae4a 100644
--- a/source/blender/functions/intern/node_tree_multi_function_network/builder.cc
+++ b/source/blender/functions/intern/node_tree_multi_function_network/builder.cc
@@ -4,41 +4,25 @@ namespace FN {
 
 using BLI::ScopedVector;
 
-FunctionTreeMFNetworkBuilder::FunctionTreeMFNetworkBuilder(
-    const FunctionNodeTree &function_tree,
-    const FSocketDataTypes &preprocessed_function_tree_data,
-    const VTreeMultiFunctionMappings &function_tree_mappings,
-    ResourceCollector &resources,
-    MFSocketByFSocketMapping &socket_map,
-    MFNetworkBuilder &builder)
-    : m_function_tree(function_tree),
-      m_fsocket_data_types(preprocessed_function_tree_data),
-      m_function_tree_mappings(function_tree_mappings),
-      m_resources(resources),
-      m_socket_map(socket_map),
-      m_builder(builder)
+MFBuilderFunctionNode &FunctionTreeMFBuilderBase::add_function(const MultiFunction &function)
 {
+  return m_common.network_builder.add_function(function);
 }
 
-MFBuilderFunctionNode &FunctionTreeMFNetworkBuilder::add_function(const MultiFunction &function)
+MFBuilderFunctionNode &FunctionTreeMFBuilderBase::add_function(const MultiFunction &function,
+                                                               const FNode &fnode)
 {
-  return m_builder.add_function(function);
-}
-
-MFBuilderFunctionNode &FunctionTreeMFNetworkBuilder::add_function(const MultiFunction &function,
-                                                                  const FNode &fnode)
-{
-  MFBuilderFunctionNode &node = m_builder.add_function(function);
-  this->map_data_sockets(fnode, node);
+  MFBuilderFunctionNode &node = m_common.network_builder.add_function(function);
+  m_common.socket_map.add(fnode, node, m_common.fsocket_data_types);
   return node;
 }
 
-MFBuilderDummyNode &FunctionTreeMFNetworkBuilder::add_dummy(const FNode &fnode)
+MFBuilderDummyNode &FunctionTreeMFBuilderBase::add_dummy(const FNode &fnode)
 {
   ScopedVector<MFDataType> input_types;
   ScopedVector<StringRef> input_names;
   for (const FInputSocket *fsocket : fnode.inputs()) {
-    Optional<MFDataType> data_type = this->try_get_data_type(*fsocket);
+    Optional<MFDataType> data_type = m_common.fsocket_data_types.try_lookup_data_type(*fsocket);
     if (data_type.has_value()) {
       input_types.append(data_type.value());
       input_names.append(fsocket->name());
@@ -48,111 +32,19 @@ MFBuilderDummyNode &FunctionTreeMFNetworkBuilder::add_dummy(const FNode &fnode)
   ScopedVector<MFDataType> output_types;
   ScopedVector<StringRef> output_names;
   for (const FOutputSocket *fsocket : fnode.outputs()) {
-    Optional<MFDataType> data_type = this->try_get_data_type(*fsocket);
+    Optional<MFDataType> data_type = m_common.fsocket_data_types.try_lookup_data_type(*fsocket);
     if (data_type.has_value()) {
       output_types.append(data_type.value());
       output_names.append(fsocket->name());
     }
   }
 
-  MFBuilderDummyNode &node = m_builder.add_dummy(
+  MFBuilderDummyNode &node = m_common.network_builder.add_dummy(
       fnode.name(), input_types, output_types, input_names, output_names);
-  this->map_data_sockets(fnode, node);
+  m_common.socket_map.add(fnode, node, m_common.fsocket_data_types);
   return node;
 }
 
-void FunctionTreeMFNetworkBuilder::map_data_sockets(const FNode &fnode, MFBuilderNode &node)
-{
-  uint data_inputs = 0;
-  for (const FInputSocket *fsocket : fnode.inputs()) {
-    if (this->is_data_socket(*fsocket)) {
-      this->map_sockets(*fsocket, *node.inputs()[data_inputs]);
-      data_inputs++;
-    }
-  }
-
-  uint data_outputs = 0;
-  for (const FOutputSocket *fsocket : fnode.outputs()) {
-    if (this->is_data_socket(*fsocket)) {
-      this->map_sockets(*fsocket, *node.outputs()[data_outputs]);
-      data_outputs++;
-    }
-  }
-}
-
-void FunctionTreeMFNetworkBuilder::assert_fnode_is_mapped_correctly(const FNode &fnode)
-{
-  UNUSED_VARS_NDEBUG(fnode);
-#ifdef DEBUG
-  this->assert_data_sockets_are_mapped_correctly(fnode.inputs().cast<const FSocket *>());
-  this->assert_data_sockets_are_mapped_correctly(fnode.outputs().cast<const FSocket *>());
-#endif
-}
-
-void FunctionTreeMFNetworkBuilder::assert_data_sockets_are_mapped_correctly(
-    ArrayRef<const FSocket *> fsockets)
-{
-  for (const FSocket *fsocket : fsockets) {
-    if (this->is_data_socket(*fsocket)) {
-      this->assert_fsocket_is_mapped_correctly(*fsocket);
-    }
-  }
-}
-
-void FunctionTreeMFNetworkBuilder::assert_fsocket_is_mapped_correctly(const FSocket &fsocket)
-{
-  BLI_assert(this->fsocket_is_mapped(fsocket));
-  MFDataType fsocket_type = this->try_get_data_type(fsocket).value();
-  UNUSED_VARS_NDEBUG(fsocket_type);
-
-  if (fsocket.is_input()) {
-    for (MFBuilderInputSocket *socket : this->lookup_socket(fsocket.as_input())) {
-      MFDataType socket_type = socket->data_type();
-      BLI_assert(socket_type == fsocket_type);
-      UNUSED_VARS_NDEBUG(socket_type);
-    }
-  }
-  else {
-    MFBuilderSocket &socket = this->lookup_socket(fsocket.as_output());
-    MFDataType socket_type = socket.data_type();
-    BLI_assert(socket_type == fsocket_type);
-    UNUSED_VARS_NDEBUG(socket_type);
-  }
-}
-
-bool FunctionTreeMFNetworkBuilder::has_data_sockets(const FNode &fnode) const
-{
-  for (const FInputSocket *fsocket : fnode.inputs()) {
-    if (this->is_data_socket(*fsocket)) {
-      return true;
-    }
-  }
-  for (const FOutputSocket *fsocket : fnode.outputs()) {
-    if (this->is_data_socket(*fsocket)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-const CPPType &FunctionTreeMFNetworkBuilder::cpp_type_from_property(const FNode &fnode,
-                                                                    StringRefNull prop_name) const
-{
-  char *type_name = RNA_string_get_alloc(fnode.rna(), prop_name.data(), nullptr, 0);
-  const CPPType &type = this->cpp_type_by_name(type_name);
-  MEM_freeN(type_name);
-  return type;
-}
-
-MFDataType FunctionTreeMFNetworkBuilder::data_type_from_property(const FNode &fnode,
-                                                                 StringRefNull prop_name) const
-{
-  char *type_name = RNA_string_get_alloc(fnode.rna(), prop_name.data(), nullptr, 0);
-  MFDataType type = m_function_tree_mappings.data_type_by_type_name.lookup(type_name);
-  MEM_freeN(type_name);
-  return type;
-}
-
 Vector<bool> FNodeMFNetworkBuilder::get_list_base_variadic_states(StringRefNull prop_name)
 {
   Vector<bool> states;
@@ -176,8 +68,8 @@ Vector<bool> FNodeMFNetworkBuilder::get_list_base_variadic_states(StringRefNull
 
 void FNodeMFNetworkBuilder::set_matching_fn(const MultiFunction &fn)
 {
-  MFBuilderFunctionNode &node = m_network_builder.add_function(fn);
-  m_network_builder.map_data_sockets(m_fnode, node);
+  MFBuilderFunctionNode &node = this->add_function(fn);
+  m_common.socket_map.add(m_fnode, node, m_common.fsocket_data_types);
 }
 
 const MultiFunction &FNodeMFNetworkBuilder::get_vectorized_function(
diff --git a/source/blender/functions/intern/node_tree_multi_function_network/builder.h b/source/blender/functions/intern/node_tree_multi_function_network/builder.h
index 4502cc0e7ab..4bed3d6b809 100644
--- a/source/blender/functions/intern/node_tree_multi_function_network/builder.h
+++ b/source/blender/functions/intern/node_tree_multi_function_network/builder.h
@@ -56,6 +56,21 @@ class FSocketDataTypes {
   {
     return m_data_type_by_group_input_id[group_input.id()].has_value();
   }
+
+  bool has_data_sockets(const FNode &fnode) const
+  {
+    for (const FInputSocket *fsocket : fnode.inputs()) {
+      if (this->is_data_socket(*fsocket)) {
+        return true;
+      }
+    }
+    for (const FOutputSocket *fsocket : fnode.outputs()) {
+      if (this->is_data_socket(*fsocket)) {
+        return true;
+      }
+    }
+    return false;
+  }
 };
 
 class MFSocketByFSocketMapping {
@@ -106,6 +121,25 @@ class MFSocketByFSocketMapping {
     m_socket_by_group_input_id.add_new(group_input.id(), socket);
   }
 
+  void add(const FNode &fnode, MFBuilderNode &node, const FSocketDataTypes &fsocket_data_types)
+  {
+    uint data_inputs = 0;
+    for (const FInputSocket *fsocket : fnode.inputs()) {
+      if (fsocket_data_types.is_data_socket(*fsocket)) {
+        this->add(*fsocket, *node.inputs()[data_inputs]);
+        data_inputs++;
+      }
+    }
+
+    uint data_outputs = 0;
+    for (const FOutputSocket *fsocket : fnode.outputs()) {
+      if (fsocket_data_types.is_data_socket(*fsocket)) {
+        this->add(*fsocket, *node.outputs()[data_outputs]);
+        data_outputs++;
+      }
+    }
+  }
+
   MFBuilderOutputSocket &lookup(const FGroupInput &group_input)
   {
     return m_socket_by_group_input_id.lookup(group_input.id());
@@ -142,164 +176,114 @@ class MFSocketByFSocketMapping {
   }
 };
 
-class FunctionTreeMFNetworkBuilder : BLI::NonCopyable, BLI::NonMovable {
- private:
-  const FunctionNodeTree &m_function_tree;
-  const FSocketDataTypes &m_fsocket_data_types;
-  const VTreeMultiFunctionMappings &m_function_tree_mappings;
-  ResourceCollector &m_resources;
+struct FunctionTreeMFBuilderCommonData {
+  ResourceCollector &resources;
+  const VTreeMultiFunctionMappings &mappings;
+  const FSocketDataTypes &fsocket_data_types;
+  MFSocketByFSocketMapping &socket_map;
+  MFNetworkBuilder &network_builder;
+  const FunctionNodeTree &function_tree;
+};
 
-  MFSocketByFSocketMapping &m_socket_map;
-  MFNetworkBuilder &m_builder;
+class FunctionTreeMFBuilderBase {
+ protected:
+  FunctionTreeMFBuilderCommonData &m_common;
 
  public:
-  FunctionTreeMFNetworkBuilder(const FunctionNodeTree &function_tree,
-                               const FSocketDataTypes &preprocessed_function_tree_data,
-                               const VTreeMultiFunctionMappings &function_tree_mappings,
-                               ResourceCollector &resources,
-                               MFSocketByFSocketMapping &socket_map,
-                               MFNetworkBuilder &builder);
-
-  const FunctionNodeTree &function_tree() const
+  FunctionT

@@ Diff output truncated at 10240 characters. @@



More information about the Bf-blender-cvs mailing list