[Bf-blender-cvs] [e778aba5848] functions-experimental-refactor: move VTreeMFNetworkBuilder to functions2

Jacques Lucke noreply at git.blender.org
Fri Nov 1 20:31:42 CET 2019


Commit: e778aba5848e12763eecc6cd720fe7074bf91909
Author: Jacques Lucke
Date:   Fri Nov 1 20:02:51 2019 +0100
Branches: functions-experimental-refactor
https://developer.blender.org/rBe778aba5848e12763eecc6cd720fe7074bf91909

move VTreeMFNetworkBuilder to functions2

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

M	source/blender/functions2/CMakeLists.txt
A	source/blender/functions2/FN_vtree_multi_function_network_builder.h
M	source/blender/modifiers/intern/MOD_functiondeform_cxx.cc

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

diff --git a/source/blender/functions2/CMakeLists.txt b/source/blender/functions2/CMakeLists.txt
index c1ccda411b2..05604ca75ac 100644
--- a/source/blender/functions2/CMakeLists.txt
+++ b/source/blender/functions2/CMakeLists.txt
@@ -40,6 +40,7 @@ set(SRC
   FN_multi_function_network.h
   FN_multi_function.h
   FN_multi_functions.h
+  FN_vtree_multi_function_network_builder.h
   FN_vtree_multi_function_network.h
 
   intern/multi_functions/lists.h
diff --git a/source/blender/functions2/FN_vtree_multi_function_network_builder.h b/source/blender/functions2/FN_vtree_multi_function_network_builder.h
new file mode 100644
index 00000000000..817d00f1cd8
--- /dev/null
+++ b/source/blender/functions2/FN_vtree_multi_function_network_builder.h
@@ -0,0 +1,224 @@
+#ifndef __FN_VTREE_MULTI_FUNCTION_NETWORK_BUILDER_H__
+#define __FN_VTREE_MULTI_FUNCTION_NETWORK_BUILDER_H__
+
+#include "BKE_virtual_node_tree_cxx.h"
+
+#include "FN_vtree_multi_function_network.h"
+
+namespace FN {
+
+class VTreeMFNetworkBuilder {
+ private:
+  const VirtualNodeTree &m_vtree;
+  Vector<MFBuilderSocket *> m_socket_map;
+  Vector<MFDataType> m_type_by_vsocket;
+  std::unique_ptr<MFNetworkBuilder> m_builder;
+
+ public:
+  VTreeMFNetworkBuilder(const VirtualNodeTree &vtree, Vector<MFDataType> type_by_vsocket)
+      : m_vtree(vtree),
+        m_socket_map(vtree.socket_count(), nullptr),
+        m_type_by_vsocket(std::move(type_by_vsocket)),
+        m_builder(BLI::make_unique<MFNetworkBuilder>())
+  {
+  }
+
+  const VirtualNodeTree &vtree() const
+  {
+    return m_vtree;
+  }
+
+  MFBuilderFunctionNode &add_function(const MultiFunction &function,
+                                      ArrayRef<uint> input_param_indices,
+                                      ArrayRef<uint> output_param_indices)
+  {
+    return m_builder->add_function(function, input_param_indices, output_param_indices);
+  }
+
+  MFBuilderFunctionNode &add_function(const MultiFunction &function,
+                                      ArrayRef<uint> input_param_indices,
+                                      ArrayRef<uint> output_param_indices,
+                                      const VirtualNode &vnode)
+  {
+    MFBuilderFunctionNode &node = m_builder->add_function(
+        function, input_param_indices, output_param_indices);
+    this->map_sockets_exactly(vnode, node);
+    return node;
+  }
+
+  MFBuilderDummyNode &add_dummy(const VirtualNode &vnode)
+  {
+    Vector<MFDataType> input_types;
+    for (const VirtualSocket *vsocket : vnode.inputs()) {
+      MFDataType data_type = this->try_get_data_type(*vsocket);
+      if (!data_type.is_none()) {
+        input_types.append(data_type);
+      }
+    }
+
+    Vector<MFDataType> output_types;
+    for (const VirtualSocket *vsocket : vnode.outputs()) {
+      MFDataType data_type = this->try_get_data_type(*vsocket);
+      if (!data_type.is_none()) {
+        output_types.append(data_type);
+      }
+    }
+
+    MFBuilderDummyNode &node = m_builder->add_dummy(input_types, output_types);
+    this->map_data_sockets(vnode, node);
+    return node;
+  }
+
+  MFBuilderDummyNode &add_dummy(ArrayRef<MFDataType> input_types,
+                                ArrayRef<MFDataType> output_types)
+  {
+    return m_builder->add_dummy(input_types, output_types);
+  }
+
+  void add_link(MFBuilderOutputSocket &from, MFBuilderInputSocket &to)
+  {
+    m_builder->add_link(from, to);
+  }
+
+  MFDataType try_get_data_type(const VirtualSocket &vsocket) const
+  {
+    return m_type_by_vsocket[vsocket.id()];
+  }
+
+  bool is_data_socket(const VirtualSocket &vsocket) const
+  {
+    return !m_type_by_vsocket[vsocket.id()].is_none();
+  }
+
+  void map_sockets_exactly(const VirtualNode &vnode, MFBuilderNode &node)
+  {
+    BLI_assert(vnode.inputs().size() == node.inputs().size());
+    BLI_assert(vnode.outputs().size() == node.outputs().size());
+
+    for (uint i = 0; i < vnode.inputs().size(); i++) {
+      m_socket_map[vnode.inputs()[i]->id()] = node.inputs()[i];
+    }
+    for (uint i = 0; i < vnode.outputs().size(); i++) {
+      m_socket_map[vnode.outputs()[i]->id()] = node.outputs()[i];
+    }
+  }
+
+  void map_data_sockets(const VirtualNode &vnode, MFBuilderNode &node)
+  {
+    uint data_inputs = 0;
+    for (const VirtualSocket *vsocket : vnode.inputs()) {
+      if (this->is_data_socket(*vsocket)) {
+        this->map_sockets(*vsocket, *node.inputs()[data_inputs]);
+        data_inputs++;
+      }
+    }
+
+    uint data_outputs = 0;
+    for (const VirtualSocket *vsocket : vnode.outputs()) {
+      if (this->is_data_socket(*vsocket)) {
+        this->map_sockets(*vsocket, *node.outputs()[data_outputs]);
+        data_outputs++;
+      }
+    }
+  }
+
+  void map_sockets(const VirtualSocket &vsocket, MFBuilderSocket &socket)
+  {
+    BLI_assert(m_socket_map[vsocket.id()] == nullptr);
+    m_socket_map[vsocket.id()] = &socket;
+  }
+
+  bool vsocket_is_mapped(const VirtualSocket &vsocket) const
+  {
+    return m_socket_map[vsocket.id()] != nullptr;
+  }
+
+  bool data_sockets_are_mapped(ArrayRef<const VirtualSocket *> vsockets) const
+  {
+    for (const VirtualSocket *vsocket : vsockets) {
+      if (this->is_data_socket(*vsocket)) {
+        if (!this->vsocket_is_mapped(*vsocket)) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  bool data_sockets_of_vnode_are_mapped(const VirtualNode &vnode) const
+  {
+    if (!this->data_sockets_are_mapped(vnode.inputs())) {
+      return false;
+    }
+    if (!this->data_sockets_are_mapped(vnode.outputs())) {
+      return false;
+    }
+    return true;
+  }
+
+  bool has_data_sockets(const VirtualNode &vnode) const
+  {
+    for (const VirtualSocket *vsocket : vnode.inputs()) {
+      if (this->is_data_socket(*vsocket)) {
+        return true;
+      }
+    }
+    for (const VirtualSocket *vsocket : vnode.outputs()) {
+      if (this->is_data_socket(*vsocket)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool is_input_linked(const VirtualSocket &vsocket) const
+  {
+    auto &socket = this->lookup_input_socket(vsocket);
+    return socket.as_input().origin() != nullptr;
+  }
+
+  MFBuilderOutputSocket &lookup_output_socket(const VirtualSocket &vsocket) const
+  {
+    BLI_assert(vsocket.is_output());
+    MFBuilderSocket *socket = m_socket_map[vsocket.id()];
+    BLI_assert(socket != nullptr);
+    return socket->as_output();
+  }
+
+  MFBuilderInputSocket &lookup_input_socket(const VirtualSocket &vsocket) const
+  {
+    BLI_assert(vsocket.is_input());
+    MFBuilderSocket *socket = m_socket_map[vsocket.id()];
+    BLI_assert(socket != nullptr);
+    return socket->as_input();
+  }
+
+  std::unique_ptr<VTreeMFNetwork> build()
+  {
+    // m_builder->to_dot__clipboard();
+
+    Array<int> socket_ids(m_vtree.socket_count(), -1);
+    for (uint vsocket_id = 0; vsocket_id < m_vtree.socket_count(); vsocket_id++) {
+      MFBuilderSocket *builder_socket = m_socket_map[vsocket_id];
+      if (builder_socket != nullptr) {
+        socket_ids[vsocket_id] = builder_socket->id();
+      }
+    }
+
+    auto network = BLI::make_unique<MFNetwork>(std::move(m_builder));
+
+    Array<const MFSocket *> socket_map(m_vtree.socket_count(), nullptr);
+    for (uint vsocket_id = 0; vsocket_id < m_vtree.socket_count(); vsocket_id++) {
+      int id = socket_ids[vsocket_id];
+      if (id != -1) {
+        socket_map[vsocket_id] = &network->socket_by_id(socket_ids[vsocket_id]);
+      }
+    }
+
+    return BLI::make_unique<VTreeMFNetwork>(m_vtree, std::move(network), std::move(socket_map));
+  }
+};
+
+}  // namespace FN
+
+#endif /* __FN_VTREE_MULTI_FUNCTION_NETWORK_BUILDER_H__ */
diff --git a/source/blender/modifiers/intern/MOD_functiondeform_cxx.cc b/source/blender/modifiers/intern/MOD_functiondeform_cxx.cc
index b6bbd0c4247..2de4250884b 100644
--- a/source/blender/modifiers/intern/MOD_functiondeform_cxx.cc
+++ b/source/blender/modifiers/intern/MOD_functiondeform_cxx.cc
@@ -5,6 +5,7 @@
 #include "FN_multi_functions.h"
 #include "FN_multi_function_network.h"
 #include "FN_vtree_multi_function_network.h"
+#include "FN_vtree_multi_function_network_builder.h"
 
 #include "BLI_math_cxx.h"
 #include "BLI_string_map.h"
@@ -59,6 +60,7 @@ using FN::MFSignatureBuilder;
 using FN::MFSocket;
 using FN::MultiFunction;
 using FN::VTreeMFNetwork;
+using FN::VTreeMFNetworkBuilder;
 
 extern "C" {
 void MOD_functiondeform_do(FunctionDeformModifierData *fdmd, float (*vertexCos)[3], int numVerts);
@@ -133,228 +135,6 @@ static const CPPType &get_cpp_type_by_name(StringRef name)
   return FN::GET_TYPE<float>();
 }
 
-class VTreeMFNetworkBuilder {
- private:
-  const VirtualNodeTree &m_vtree;
-  Vector<MFBuilderSocket *> m_socket_map;
-  Vector<MFDataType> m_type_by_vsocket;
-  std::unique_ptr<MFNetworkBuilder> m_builder;
-
- public:
-  VTreeMFNetworkBuilder(const VirtualNodeTree &vtree)
-      : m_vtree(vtree),
-        m_socket_map(vtree.socket_count(), nullptr),
-        m_builder(BLI::make_unique<MFNetworkBuilder>())
-  {
-    m_type_by_vsocket = Vector<MFDataType>(m_vtree.socket_count());
-    for (const VirtualNode *vnode : m_vtree.nodes()) {
-      for (const VirtualSocket *vsocket : vnode->inputs()) {
-        MFDataType data_type = get_type_by_socket(*vsocket);
-        m_type_by_vsocket[vsocket->id()] = data_type;
-      }
-      for (const VirtualSocket *vsocket : vnode->outputs()) {
-        MFDataType data_type = get_type_by_socket(*vsocket);
-        m_type_by_vsocket[vsocket->id()] = data_type;
-      }
-    }
-  }
-
-  const VirtualNodeTree &vtree() const
-  {
-    return m_vtree;
-  }
-
-  MFBuilderFunctionNode &add_function(const MultiFunction &function,
-                                      ArrayRef<uint> input_param_indices,
-                                      ArrayRef<uint> output_param_indices)
-  {
-    return m_builder->add_function(function, input_param_indices, output_param_indices);
-  }
-
-  MFBuilderFunctionNode &add_function(const MultiFunction &function,
-                                      ArrayRef<uint> input_param_indices,
-                                      ArrayRef<uint> output_param_indices,
-                                      const VirtualNode &vnode)


@@ Diff output truncated at 10240 characters. @@



More information about the Bf-blender-cvs mailing list