[Bf-blender-cvs] [617d8ab8dc1] functions-experimental-refactor: move multi function network to functions2
Jacques Lucke
noreply at git.blender.org
Fri Nov 1 20:31:30 CET 2019
Commit: 617d8ab8dc115396a74ff82fc1ac9e6d3637b3d6
Author: Jacques Lucke
Date: Fri Nov 1 19:32:52 2019 +0100
Branches: functions-experimental-refactor
https://developer.blender.org/rB617d8ab8dc115396a74ff82fc1ac9e6d3637b3d6
move multi function network to functions2
===================================================================
M source/blender/functions2/CMakeLists.txt
A source/blender/functions2/FN_multi_function_network.h
A source/blender/functions2/intern/multi_function_network.cc
===================================================================
diff --git a/source/blender/functions2/CMakeLists.txt b/source/blender/functions2/CMakeLists.txt
index b99b3051e22..aea15cfaf7c 100644
--- a/source/blender/functions2/CMakeLists.txt
+++ b/source/blender/functions2/CMakeLists.txt
@@ -27,6 +27,7 @@ set(SRC
intern/cpp_type.cc
intern/cpp_types.cc
intern/initialize.cc
+ intern/multi_function_network.cc
FN_cpp_type.h
FN_generic_array_ref.h
@@ -34,6 +35,7 @@ set(SRC
FN_generic_virtual_list_list_ref.h
FN_generic_virtual_list_ref.h
FN_initialize.h
+ FN_multi_function_network.h
FN_multi_function.h
FN_multi_functions.h
diff --git a/source/blender/functions2/FN_multi_function_network.h b/source/blender/functions2/FN_multi_function_network.h
new file mode 100644
index 00000000000..f546557b964
--- /dev/null
+++ b/source/blender/functions2/FN_multi_function_network.h
@@ -0,0 +1,574 @@
+#ifndef __FN_MULTI_FUNCTION_NETWORK_H__
+#define __FN_MULTI_FUNCTION_NETWORK_H__
+
+#include "FN_multi_function.h"
+
+#include "BLI_optional.h"
+#include "BLI_array_cxx.h"
+
+namespace FN {
+
+using BLI::Array;
+using BLI::Optional;
+
+/* MFNetwork Builder
+ ****************************************/
+
+class MFBuilderNode;
+class MFBuilderFunctionNode;
+class MFBuilderDummyNode;
+
+class MFBuilderSocket;
+class MFBuilderInputSocket;
+class MFBuilderOutputSocket;
+
+class MFNetworkBuilder;
+
+class MFBuilderNode : BLI::NonCopyable, BLI::NonMovable {
+ protected:
+ MFNetworkBuilder *m_network;
+ Vector<MFBuilderInputSocket *> m_inputs;
+ Vector<MFBuilderOutputSocket *> m_outputs;
+ uint m_id;
+ bool m_is_dummy;
+
+ friend MFNetworkBuilder;
+
+ public:
+ MFNetworkBuilder &network();
+
+ ArrayRef<MFBuilderInputSocket *> inputs();
+ ArrayRef<MFBuilderOutputSocket *> outputs();
+
+ StringRefNull name();
+
+ uint id();
+
+ bool is_function();
+ bool is_dummy();
+
+ MFBuilderFunctionNode &as_function();
+ MFBuilderDummyNode &as_dummy();
+};
+
+class MFBuilderFunctionNode : public MFBuilderNode {
+ private:
+ const MultiFunction *m_function;
+ Vector<uint> m_input_param_indices;
+ Vector<uint> m_output_param_indices;
+
+ friend MFNetworkBuilder;
+
+ public:
+ const MultiFunction &function();
+
+ ArrayRef<uint> input_param_indices();
+ ArrayRef<uint> output_param_indices();
+};
+
+class MFBuilderDummyNode : public MFBuilderNode {
+};
+
+class MFBuilderSocket : BLI::NonCopyable, BLI::NonMovable {
+ private:
+ MFBuilderNode *m_node;
+ bool m_is_output;
+ uint m_index;
+ MFDataType m_type;
+ uint m_id;
+
+ friend MFNetworkBuilder;
+
+ public:
+ MFBuilderNode &node();
+ MFDataType type();
+
+ uint index();
+ uint id();
+ StringRefNull name();
+
+ bool is_input();
+ bool is_output();
+
+ MFBuilderInputSocket &as_input();
+ MFBuilderOutputSocket &as_output();
+};
+
+class MFBuilderInputSocket : public MFBuilderSocket {
+ private:
+ MFBuilderOutputSocket *m_origin;
+
+ friend MFNetworkBuilder;
+
+ public:
+ MFBuilderOutputSocket *origin();
+};
+
+class MFBuilderOutputSocket : public MFBuilderSocket {
+ private:
+ Vector<MFBuilderInputSocket *> m_targets;
+
+ friend MFNetworkBuilder;
+
+ public:
+ ArrayRef<MFBuilderInputSocket *> targets();
+};
+
+class MFNetworkBuilder : BLI::NonCopyable, BLI::NonMovable {
+ private:
+ Vector<MFBuilderNode *> m_node_by_id;
+ Vector<MFBuilderSocket *> m_socket_by_id;
+
+ Vector<MFBuilderFunctionNode *> m_function_nodes;
+ Vector<MFBuilderDummyNode *> m_dummy_nodes;
+ Vector<MFBuilderInputSocket *> m_input_sockets;
+ Vector<MFBuilderOutputSocket *> m_output_sockets;
+
+ public:
+ ~MFNetworkBuilder();
+
+ std::string to_dot();
+ void to_dot__clipboard();
+
+ MFBuilderFunctionNode &add_function(const MultiFunction &function,
+ ArrayRef<uint> input_param_indices,
+ ArrayRef<uint> output_param_indices);
+ MFBuilderDummyNode &add_dummy(ArrayRef<MFDataType> input_types,
+ ArrayRef<MFDataType> output_types);
+ void add_link(MFBuilderOutputSocket &from, MFBuilderInputSocket &to);
+
+ ArrayRef<MFBuilderNode *> nodes_by_id() const
+ {
+ return m_node_by_id;
+ }
+
+ ArrayRef<MFBuilderSocket *> sockets_by_id() const
+ {
+ return m_socket_by_id;
+ }
+
+ ArrayRef<MFBuilderFunctionNode *> function_nodes() const
+ {
+ return m_function_nodes;
+ }
+
+ ArrayRef<MFBuilderDummyNode *> dummy_nodes() const
+ {
+ return m_dummy_nodes;
+ }
+
+ ArrayRef<MFBuilderInputSocket *> input_sockets() const
+ {
+ return m_input_sockets;
+ }
+
+ ArrayRef<MFBuilderOutputSocket *> output_sockets() const
+ {
+ return m_output_sockets;
+ }
+};
+
+/* Network
+ ******************************************/
+
+class MFNode;
+class MFFunctionNode;
+class MFDummyNode;
+
+class MFSocket;
+class MFInputSocket;
+class MFOutputSocket;
+
+class MFNetwork;
+
+class MFNode : BLI::NonCopyable, BLI::NonMovable {
+ private:
+ const MFNetwork *m_network;
+ Vector<const MFInputSocket *> m_inputs;
+ Vector<const MFOutputSocket *> m_outputs;
+ bool m_is_dummy;
+ uint m_id;
+
+ friend MFNetwork;
+
+ public:
+ const MFNetwork &network() const;
+
+ StringRefNull name() const;
+
+ ArrayRef<const MFInputSocket *> inputs() const;
+ ArrayRef<const MFOutputSocket *> outputs() const;
+
+ uint id() const;
+
+ bool is_function() const;
+ bool is_dummy() const;
+
+ const MFFunctionNode &as_function() const;
+ const MFDummyNode &as_dummy() const;
+};
+
+class MFFunctionNode : public MFNode {
+ private:
+ const MultiFunction *m_function;
+ Vector<uint> m_input_param_indices;
+ Vector<uint> m_output_param_indices;
+
+ friend MFNetwork;
+
+ public:
+ const MultiFunction &function() const;
+
+ ArrayRef<uint> input_param_indices() const;
+ ArrayRef<uint> output_param_indices() const;
+};
+
+class MFDummyNode : public MFNode {
+};
+
+class MFSocket : BLI::NonCopyable, BLI::NonMovable {
+ private:
+ MFNode *m_node;
+ bool m_is_output;
+ uint m_index;
+ MFDataType m_type;
+ uint m_id;
+
+ friend MFNetwork;
+
+ public:
+ const MFNode &node() const;
+ MFDataType type() const;
+
+ uint index() const;
+ uint id() const;
+
+ bool is_input() const;
+ bool is_output() const;
+
+ MFInputSocket &as_input();
+ MFOutputSocket &as_output();
+
+ const MFInputSocket &as_input() const;
+ const MFOutputSocket &as_output() const;
+};
+
+class MFInputSocket : public MFSocket {
+ private:
+ MFOutputSocket *m_origin;
+
+ friend MFNetwork;
+
+ public:
+ const MFOutputSocket &origin() const;
+};
+
+class MFOutputSocket : public MFSocket {
+ private:
+ Vector<const MFInputSocket *> m_targets;
+
+ friend MFNetwork;
+
+ public:
+ ArrayRef<const MFInputSocket *> targets() const;
+};
+
+class MFNetwork : BLI::NonCopyable, BLI::NonMovable {
+ private:
+ Array<MFNode *> m_node_by_id;
+ Array<MFSocket *> m_socket_by_id;
+
+ Vector<MFFunctionNode *> m_function_nodes;
+ Vector<MFDummyNode *> m_dummy_nodes;
+ Vector<MFInputSocket *> m_input_sockets;
+ Vector<MFOutputSocket *> m_output_sockets;
+
+ public:
+ MFNetwork(std::unique_ptr<MFNetworkBuilder> builder);
+ ~MFNetwork();
+
+ const MFNode &node_by_id(uint id) const;
+ const MFSocket &socket_by_id(uint id) const;
+};
+
+/* Builder Implementations
+ *******************************************/
+
+inline MFNetworkBuilder &MFBuilderNode::network()
+{
+ return *m_network;
+}
+
+inline ArrayRef<MFBuilderInputSocket *> MFBuilderNode::inputs()
+{
+ return m_inputs;
+}
+inline ArrayRef<MFBuilderOutputSocket *> MFBuilderNode::outputs()
+{
+ return m_outputs;
+}
+
+inline uint MFBuilderNode::id()
+{
+ return m_id;
+}
+
+inline StringRefNull MFBuilderNode::name()
+{
+ if (this->is_function()) {
+ return this->as_function().function().name();
+ }
+ else {
+ return "Dummy";
+ }
+}
+
+inline bool MFBuilderNode::is_function()
+{
+ return !m_is_dummy;
+}
+inline bool MFBuilderNode::is_dummy()
+{
+ return m_is_dummy;
+}
+
+inline MFBuilderFunctionNode &MFBuilderNode::as_function()
+{
+ BLI_assert(this->is_function());
+ return *(MFBuilderFunctionNode *)this;
+}
+
+inline MFBuilderDummyNode &MFBuilderNode::as_dummy()
+{
+ BLI_assert(this->is_dummy());
+ return *(MFBuilderDummyNode *)this;
+}
+
+inline const MultiFunction &MFBuilderFunctionNode::function()
+{
+ return *m_function;
+}
+
+inline ArrayRef<uint> MFBuilderFunctionNode::input_param_indices()
+{
+ return m_input_param_indices;
+}
+
+inline ArrayRef<uint> MFBuilderFunctionNode::output_param_indices()
+{
+ return m_output_param_indices;
+}
+
+inline MFBuilderNode &MFBuilderSocket::node()
+{
+ return *m_node;
+}
+
+inline MFDataType MFBuilderSocket::type()
+{
+ return m_type;
+}
+
+inline uint MFBuilderSocket::index()
+{
+ return m_index;
+}
+
+inline uint MFBuilderSocket::id()
+{
+ return m_id;
+}
+
+inline StringRefNull MFBuilderSocket::name()
+{
+ if (m_node->is_function()) {
+ MFBuilderFunctionNode &node = m_node->as_function();
+ if (m_is_output) {
+ return node.function().param_name(node.output_param_indices()[m_index]);
+ }
+ else {
+ return node.function().param_name(node.input_param_indices()[m_index]);
+ }
+ }
+ else {
+ return "Dummy";
+ }
+}
+
+inline bool MFBuilderSocket::is_input()
+{
+ return !m_is_output;
+}
+inline bool MFBuilderSocket::is_output()
+{
+ return m_is_output;
+}
+
+inline MFBuilderInputSocket &MFBuilderSocket::as_input()
+{
+ BLI_assert(this->is_input());
+ return *(MFBuilderInputSocket *)this;
+}
+inline MFBuilderOutputSocket &MFBuilderSocket::as_output()
+{
+ BLI_assert(this->is_output());
+ return *(MFBuilderOutputSocket *)this;
+}
+
+inline MFBuilderOutputSocket *MFBuilderInputSocket::origin()
+{
+ return m_origin;
+}
+
+inline ArrayRef<MFBuilderInputSocket *> MFBuilderOutputSocket::targets()
+{
+ return m_targets;
+}
+
+/* MFNetwork Implementations
+ **************************************/
+
+inline const MFNetwork &MFNode::network() const
+{
+ return *m_network;
+}
+
+inline ArrayRef<const MFInputSocket *> MFNode::inputs() const
+{
+ return m_inputs;
+}
+
+inline ArrayRef<const MFOutputSocket *> MFNode::outputs() const
+{
+ return m_outputs;
+}
+
+inline uint MFNode::id() const
+{
+ return m_id;
+}
+
+inline StringRefNull MFNode::name() const
+{
+
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list