[Bf-blender-cvs] [62cfea48a31] functions: initial node tree to function conversion
Jacques Lucke
noreply at git.blender.org
Mon Feb 11 18:30:23 CET 2019
Commit: 62cfea48a3116028b1f41f2f2aa54881d50e3d3c
Author: Jacques Lucke
Date: Mon Feb 11 16:10:17 2019 +0100
Branches: functions
https://developer.blender.org/rB62cfea48a3116028b1f41f2f2aa54881d50e3d3c
initial node tree to function conversion
===================================================================
M source/blender/functions/FN_functions.h
M source/blender/functions/c_wrapper.cpp
M source/blender/functions/core/data_flow_graph.hpp
M source/blender/functions/function_nodes/function_nodes.cpp
M source/blender/functions/function_nodes/function_nodes.hpp
M source/blender/modifiers/intern/MOD_functiondeform.c
===================================================================
diff --git a/source/blender/functions/FN_functions.h b/source/blender/functions/FN_functions.h
index 593f7f644e1..0ea3d0defa5 100644
--- a/source/blender/functions/FN_functions.h
+++ b/source/blender/functions/FN_functions.h
@@ -40,7 +40,7 @@ FnFunction FN_get_deform_function(int type);
FnFunction FN_get_generated_function(void);
-void FN_testing(bNodeTree *bnodetree);
+FnFunction FN_testing(bNodeTree *bnodetree);
#ifdef __cplusplus
}
diff --git a/source/blender/functions/c_wrapper.cpp b/source/blender/functions/c_wrapper.cpp
index 940f82cb62c..ab363bdfad0 100644
--- a/source/blender/functions/c_wrapper.cpp
+++ b/source/blender/functions/c_wrapper.cpp
@@ -204,9 +204,16 @@ FnFunction FN_get_generated_function()
return wrap(fn_ref);
}
-void FN_testing(bNodeTree *bnodetree)
+FnFunction FN_testing(bNodeTree *bnodetree)
{
FN::FunctionNodes::FunctionNodeTree tree(bnodetree);
- auto graph = tree.to_data_flow_graph();
- std::cout << graph->to_dot() << std::endl;
+ auto fgraph = tree.to_function_graph();
+ std::cout << fgraph.graph()->to_dot() << std::endl;
+
+ auto fn = FN::SharedFunction::New("Function from Node Tree", fgraph.signature());
+ fn->add_body(FN::function_graph_to_callable(fgraph));
+
+ BLI::RefCounted<FN::Function> *fn_ref = fn.refcounter();
+ fn_ref->incref();
+ return wrap(fn_ref);
}
\ No newline at end of file
diff --git a/source/blender/functions/core/data_flow_graph.hpp b/source/blender/functions/core/data_flow_graph.hpp
index 44087421b1d..a65410b8506 100644
--- a/source/blender/functions/core/data_flow_graph.hpp
+++ b/source/blender/functions/core/data_flow_graph.hpp
@@ -227,6 +227,53 @@ namespace FN {
using SharedDataFlowGraph = Shared<DataFlowGraph>;
+ class FunctionGraph {
+ public:
+ FunctionGraph(
+ const SharedDataFlowGraph &graph,
+ const SmallSocketVector &inputs,
+ const SmallSocketVector &outputs)
+ : m_graph(graph), m_inputs(inputs), m_outputs(outputs)
+ {
+ BLI_assert(graph->frozen());
+ }
+
+ const SharedDataFlowGraph &graph() const
+ {
+ return m_graph;
+ }
+
+ const SmallSocketVector &inputs() const
+ {
+ return m_inputs;
+ }
+
+ const SmallSocketVector &outputs() const
+ {
+ return m_outputs;
+ }
+
+ Signature signature() const
+ {
+ InputParameters inputs;
+ OutputParameters outputs;
+
+ for (const Socket &socket : m_inputs) {
+ inputs.append(InputParameter(socket.name(), socket.type()));
+ }
+ for (const Socket &socket : m_outputs) {
+ outputs.append(OutputParameter(socket.name(), socket.type()));
+ }
+
+ return Signature(inputs, outputs);
+ }
+
+ private:
+ SharedDataFlowGraph m_graph;
+ SmallSocketVector m_inputs;
+ SmallSocketVector m_outputs;
+ };
+
/* Socket Inline Functions
********************************************** */
@@ -286,51 +333,4 @@ namespace FN {
return this->graph()->m_links.get_linked(*this).size() > 0;
}
- class FunctionGraph {
- public:
- FunctionGraph(
- const SharedDataFlowGraph &graph,
- const SmallSocketVector &inputs,
- const SmallSocketVector &outputs)
- : m_graph(graph), m_inputs(inputs), m_outputs(outputs)
- {
- BLI_assert(graph->frozen());
- }
-
- const SharedDataFlowGraph &graph() const
- {
- return m_graph;
- }
-
- const SmallSocketVector &inputs() const
- {
- return m_inputs;
- }
-
- const SmallSocketVector &outputs() const
- {
- return m_outputs;
- }
-
- Signature signature() const
- {
- InputParameters inputs;
- OutputParameters outputs;
-
- for (const Socket &socket : m_inputs) {
- inputs.append(InputParameter(socket.name(), socket.type()));
- }
- for (const Socket &socket : m_outputs) {
- outputs.append(OutputParameter(socket.name(), socket.type()));
- }
-
- return Signature(inputs, outputs);
- }
-
- private:
- SharedDataFlowGraph m_graph;
- SmallSocketVector m_inputs;
- SmallSocketVector m_outputs;
- };
-
} /* namespace FN */
\ No newline at end of file
diff --git a/source/blender/functions/function_nodes/function_nodes.cpp b/source/blender/functions/function_nodes/function_nodes.cpp
index 420775b1221..48aced7010e 100644
--- a/source/blender/functions/function_nodes/function_nodes.cpp
+++ b/source/blender/functions/function_nodes/function_nodes.cpp
@@ -85,33 +85,133 @@ namespace FN::FunctionNodes {
class FloatSocketInput : public FN::TupleCallBody {
private:
- bNodeSocket *m_socket;
+ bNodeSocket *m_bsocket;
public:
- FloatSocketInput(bNodeSocket *socket)
- : m_socket(socket) {}
+ FloatSocketInput(bNodeSocket *bsocket)
+ : m_bsocket(bsocket) {}
virtual void call(const Tuple &UNUSED(fn_in), Tuple &fn_out) const
{
- float value = IDP_Float(m_socket->prop);
- fn_out.set<float>(0, value);
+ // PointerRNA ptr;
+ // RNA_pointer_create(m_btree, &RNA_NodeSocket, m_bsocket, &ptr);
+ // float value = RNA_float_get(&ptr, "value");
+ fn_out.set<float>(0, 0.0f);
}
};
- static void insert_input_node(
+ class VectorSocketInput : public FN::TupleCallBody {
+ private:
+ bNodeSocket *m_bsocket;
+
+ public:
+ VectorSocketInput(bNodeSocket *socket)
+ : m_bsocket(socket) {}
+
+ virtual void call(const Tuple &UNUSED(fn_in), Tuple &fn_out) const
+ {
+ fn_out.set<Vector>(0, Vector());
+ }
+ };
+
+ static SharedType &get_type_of_socket(bNodeSocket *bsocket)
+ {
+ if (STREQ(bsocket->idname, "fn_FloatSocket")) {
+ return Types::get_float_type();
+ }
+ else if (STREQ(bsocket->idname, "fn_VectorSocket")) {
+ return Types::get_fvec3_type();
+ }
+ else {
+ BLI_assert(false);
+ return *(SharedType *)nullptr;
+ }
+ }
+
+ static const Node *get_input_node_for_socket(
SharedDataFlowGraph &graph,
- Socket socket,
bNodeSocket *bsocket)
{
- if (socket.type() == Types::get_float_type()) {
+ SharedType &type = get_type_of_socket(bsocket);
+
+ if (type == Types::get_float_type()) {
auto fn = SharedFunction::New("Float Input", Signature(
{}, {OutputParameter("Value", Types::get_float_type())}));
fn->add_body(new FloatSocketInput(bsocket));
- const Node *node = graph->insert(fn);
- graph->link(node->output(0), socket);
+ return graph->insert(fn);
+ }
+ else if (type == Types::get_fvec3_type()) {
+ auto fn = SharedFunction::New("Vector Input", Signature(
+ {}, {OutputParameter("Value", Types::get_fvec3_type())}));
+ fn->add_body(new VectorSocketInput(bsocket));
+ return graph->insert(fn);
+ }
+ else {
+ BLI_assert(false);
+ return nullptr;
+ }
+ }
+
+ static void insert_input_socket_node(
+ SharedDataFlowGraph &graph,
+ Socket socket,
+ bNodeSocket *bsocket)
+ {
+ const Node *node = get_input_node_for_socket(graph, bsocket);
+ graph->link(node->output(0), socket);
+ }
+
+ static SharedFunction get_output_function(const SmallTypeVector &types)
+ {
+ InputParameters inputs;
+ for (SharedType &type : types) {
+ inputs.append(InputParameter("Input", type));
}
+ return SharedFunction::New("Output Node", Signature(inputs, {}));
}
+ static void insert_output_node(
+ SharedDataFlowGraph &graph,
+ SocketMap &socket_map,
+ bNode *bnode)
+ {
+ SmallTypeVector types;
+ for (bNodeSocket *bsocket = (bNodeSocket *)bnode->inputs.first; bsocket; bsocket = bsocket->next) {
+ if (STREQ(bsocket->idname, "fn_VectorSocket")) {
+ types.append(Types::get_fvec3_type());
+ }
+ else if (STREQ(bsocket->idname, "fn_FloatSocket")) {
+ types.append(Types::get_float_type());
+ }
+ else {
+ BLI_assert(false);
+ }
+ }
+ SharedFunction fn = get_output_function(types);
+ const Node *node = graph->insert(fn);
+
+ bNodeSocket *bsocket;
+ uint i;
+ for (i = 0, bsocket = (bNodeSocket *)bnode->inputs.first;
+ bsocket;
+ i++, bsocket = bsocket->next)
+ {
+ socket_map.add(bsocket, node->input(i));
+ }
+ }
+
+ static void insert_input_node(
+ SharedDataFlowGraph &graph,
+ SocketMap &socket_map,
+ bNode *bnode)
+ {
+ for (bNodeSocket *bsocket = (bNodeSocket *)bnode->outputs.first; bsocket; bsocket = bsocket->next) {
+ const Node *node = get_input_node_for_socket(graph, bsocket);
+ socket_map.add(bsocket, node->output(0));
+ }
+ }
+
+
static bool is_input_node(const bNode *bnode)
{
return STREQ(bnode->idname, "fn_FunctionInputNode");
@@ -127,20 +227,36 @@ namespace FN::FunctionNodes {
return !(is_input_node(bnode) || is_output_node(bnode));
}
- SharedDataFlowGraph FunctionNodeTree::to_data_flow_graph() const
+ FunctionGraph FunctionNodeTree::to_function_graph() const
{
SocketMap socket_map;
SmallMap<std::string, InsertInGraphFunction> inserters;
inserters.add("fn_AddFloatsNode", insert_add_floats_node);
inserters.add("fn_CombineVectorNode", insert_combine_vector_node);
+ inserters.add("fn_FunctionOutputNode", insert_output_node);
+ inserters.add("fn_FunctionInputNode", insert_input_node);
SharedDataFlowGraph graph = SharedDataFlowGraph::New();
+ SmallSocketVector input_sockets;
+ SmallSocketVector output_sockets;
+
for (bNode *bnode = (bNode *)m_tree->nodes.first; bnode; bnode = bnode->next) {
- if (is_function_node(bnode)) {
- auto insert = inserters.lookup(bnode->idname);
- insert(graph, socket_map, bnode);
+ auto insert = inserters.lookup(bnode->idname);
+ insert(graph, socket_map, bnode);
+
+ if (is_input_node(bnode)) {
+ for (bNodeSocket *bsocket = (bNodeSocket *)bnode->outputs.first; bsocket; bsocket = bsocket->next) {
+ Socket socket = socket_map.lookup(bsocket);
+ input_sockets.append(socket);
+ }
+ }
+ if (is_output_node(bnode)) {
+ for (bNodeSocket *bsocket = (bNodeSocket *)bnode->inputs.first; bsocket; bsocket = bsocket->next) {
+ Socket socket = socket_map.lookup(bsocket);
+ output_sockets.append(socket);
+ }
}
}
@@ -151,16 +267,18 @@ namespace FN::FunctionNodes {
}
for (bNode *bnode = (bNode *)m_tree->nodes.first; bnode; bnode = bnode->next) {
- if (!is_function_node(bnode)) continue;
for (bNodeSocket *bsocket = (bNodeSocket *)bnode->inputs.first; bsocket; bsocket = bsocket->next) {
Socket socket = socket_map.lookup(bsocket);
if (!socket.is_linked()) {
- insert_input_node(graph, socket, bsocket);
+ insert_input_socket_node(graph, socket, bsocket);
}
}
}
- return graph;
+ graph->freeze
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list