[Bf-blender-cvs] [e3c61a30e17] functions: refactor data flow graph generation
Jacques Lucke
noreply at git.blender.org
Wed Feb 20 17:21:13 CET 2019
Commit: e3c61a30e17f299bd413131be624cdea1ab4fc40
Author: Jacques Lucke
Date: Wed Feb 20 12:50:58 2019 +0100
Branches: functions
https://developer.blender.org/rBe3c61a30e17f299bd413131be624cdea1ab4fc40
refactor data flow graph generation
===================================================================
M source/blender/functions/CMakeLists.txt
M source/blender/functions/c_wrapper.cpp
M source/blender/functions/function_nodes/function_nodes.cpp
M source/blender/functions/function_nodes/function_nodes.hpp
A source/blender/functions/nodes/nodes.cpp
A source/blender/functions/nodes/nodes.hpp
A source/blender/functions/nodes/socket_inputs.cpp
A source/blender/functions/nodes/test_nodes.cpp
===================================================================
diff --git a/source/blender/functions/CMakeLists.txt b/source/blender/functions/CMakeLists.txt
index 193678a00ef..c8e57696137 100644
--- a/source/blender/functions/CMakeLists.txt
+++ b/source/blender/functions/CMakeLists.txt
@@ -38,6 +38,11 @@ set(SRC
function_nodes/function_nodes.hpp
function_nodes/function_nodes.cpp
+
+ nodes/nodes.hpp
+ nodes/nodes.cpp
+ nodes/socket_inputs.cpp
+ nodes/test_nodes.cpp
)
blender_add_lib(bf_functions "${SRC}" "${INC}" "${INC_SYS}")
diff --git a/source/blender/functions/c_wrapper.cpp b/source/blender/functions/c_wrapper.cpp
index 4ecf404571c..813f1cd2862 100644
--- a/source/blender/functions/c_wrapper.cpp
+++ b/source/blender/functions/c_wrapper.cpp
@@ -2,6 +2,7 @@
#include "FN_functions.hpp"
#include "function_nodes/function_nodes.hpp"
+#include "nodes/nodes.hpp"
#include "BLI_lazy_init.hpp"
#include <iostream>
@@ -20,7 +21,8 @@ void FN_test_inferencer(void);
void FN_initialize()
{
- FN_test_inferencer();
+ FN::Nodes::initialize();
+ //FN_test_inferencer();
}
void FN_function_call(FnCallable fn_call, FnTuple fn_in, FnTuple fn_out)
@@ -209,9 +211,9 @@ FnFunction FN_get_generated_function()
FnFunction FN_testing(bNodeTree *bnodetree)
{
- FN::FunctionNodes::FunctionNodeTree tree(bnodetree);
+ FN::Nodes::FunctionNodeTree tree(bnodetree);
auto fgraph = tree.to_function_graph();
- //std::cout << fgraph.graph()->to_dot() << std::endl;
+ 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));
diff --git a/source/blender/functions/function_nodes/function_nodes.cpp b/source/blender/functions/function_nodes/function_nodes.cpp
index bbe503191bb..5ae684f0f4d 100644
--- a/source/blender/functions/function_nodes/function_nodes.cpp
+++ b/source/blender/functions/function_nodes/function_nodes.cpp
@@ -1,4 +1,5 @@
#include "function_nodes.hpp"
+#include "nodes/nodes.hpp"
#include "BLI_listbase.h"
@@ -9,23 +10,16 @@
#include "DNA_object_types.h"
-namespace FN { namespace FunctionNodes {
+namespace FN { namespace Nodes {
+ using namespace Types;
- using SocketMap = SmallMap<bNodeSocket *, Socket>;
- typedef void (*InsertInGraphFunction)(
- const FunctionNodeTree &tree,
- SharedDataFlowGraph &graph,
- SocketMap &map,
- bNode *bnode);
-
-
- static SharedType &get_type_of_socket(bNodeSocket *bsocket)
+ static SharedType &get_type_of_socket(bNodeTree *UNUSED(btree), bNodeSocket *bsocket)
{
if (STREQ(bsocket->idname, "fn_FloatSocket")) {
- return Types::get_float_type();
+ return get_float_type();
}
else if (STREQ(bsocket->idname, "fn_VectorSocket")) {
- return Types::get_fvec3_type();
+ return get_fvec3_type();
}
else {
BLI_assert(false);
@@ -33,254 +27,63 @@ namespace FN { namespace FunctionNodes {
}
}
- static Signature signature_from_node(bNode *bnode)
+ static SharedFunction get_function_with_inputs(const SmallTypeVector &types)
{
InputParameters inputs;
- for (bNodeSocket *bsocket : bSocketList(&bnode->inputs)) {
- inputs.append(InputParameter(bsocket->name, get_type_of_socket(bsocket)));
- }
- OutputParameters outputs;
- for (bNodeSocket *bsocket : bSocketList(&bnode->outputs)) {
- outputs.append(OutputParameter(bsocket->name, get_type_of_socket(bsocket)));
- }
- return Signature(inputs, outputs);
- }
-
- static void map_node_sockets(SocketMap &socket_map, bNode *bnode, const Node *node)
- {
- uint input_index = 0;
- for (bNodeSocket *bsocket : bSocketList(&bnode->inputs)) {
- socket_map.add(bsocket, node->input(input_index));
- input_index++;
- }
-
- uint output_index = 0;
- for (bNodeSocket *bsocket : bSocketList(&bnode->outputs)) {
- socket_map.add(bsocket, node->output(output_index));
- output_index++;
- }
- }
-
- using Types::Vector;
-
- class CombineVector : public FN::TupleCallBody {
- void call(const FN::Tuple &fn_in, FN::Tuple &fn_out) const override
- {
- Vector v;
- v.x = fn_in.get<float>(0);
- v.y = fn_in.get<float>(1);
- v.z = fn_in.get<float>(2);
- fn_out.set<Vector>(0, v);
- }
- };
-
- class SeparateVector : public FN::TupleCallBody {
- void call(const FN::Tuple &fn_in, FN::Tuple &fn_out) const override
- {
- Vector v = fn_in.get<Vector>(0);
- fn_out.set<float>(0, v.x);
- fn_out.set<float>(1, v.y);
- fn_out.set<float>(2, v.z);
- }
- };
-
- class AddFloats : public FN::TupleCallBody {
- void call(const FN::Tuple &fn_in, FN::Tuple &fn_out) const override
- {
- float a = fn_in.get<float>(0);
- float b = fn_in.get<float>(1);
- fn_out.set<float>(0, a + b);
- }
- };
-
- class ObjectTransforms : public FN::TupleCallBody {
- private:
- Object *m_object;
-
- public:
- ObjectTransforms(Object *object)
- : m_object(object) {}
-
- void call(const FN::Tuple &UNUSED(fn_in), FN::Tuple &fn_out) const override
- {
- if (m_object) {
- Vector position = *(Vector *)m_object->loc;
- fn_out.set<Vector>(0, position);
- }
- else {
- fn_out.set<Vector>(0, Vector());
- }
- }
-
- void dependencies(Dependencies &deps) const override
- {
- deps.add_object_transform_dependency(m_object);
- }
- };
-
-
- static void insert_add_floats_node(
- const FunctionNodeTree &UNUSED(tree),
- SharedDataFlowGraph &graph,
- SocketMap &socket_map,
- bNode *bnode)
- {
- auto fn = SharedFunction::New("Add Floats", signature_from_node(bnode));
- fn->add_body(new AddFloats());
- const Node *node = graph->insert(fn);
- map_node_sockets(socket_map, bnode, node);
- }
-
- static void insert_combine_vector_node(
- const FunctionNodeTree &UNUSED(tree),
- SharedDataFlowGraph &graph,
- SocketMap &socket_map,
- bNode *bnode)
- {
- auto fn = SharedFunction::New("Combine Vector", signature_from_node(bnode));
- fn->add_body(new CombineVector());
- const Node *node = graph->insert(fn);
- map_node_sockets(socket_map, bnode, node);
- }
-
- static void insert_separate_vector_node(
- const FunctionNodeTree &UNUSED(tree),
- SharedDataFlowGraph &graph,
- SocketMap &socket_map,
- bNode *bnode)
- {
- auto fn = SharedFunction::New("Separate Vector", signature_from_node(bnode));
- fn->add_body(new SeparateVector());
- const Node *node = graph->insert(fn);
- map_node_sockets(socket_map, bnode, node);
- }
-
- static void insert_object_transforms_node(
- const FunctionNodeTree &tree,
- SharedDataFlowGraph &graph,
- SocketMap &socket_map,
- bNode *bnode)
- {
- PointerRNA ptr;
- RNA_pointer_create(&tree.orig_tree()->id, &RNA_Node, bnode, &ptr);
- Object *object = (Object *)RNA_pointer_get(&ptr, "object").id.data;
-
- auto fn = SharedFunction::New("Object Transforms", signature_from_node(bnode));
- fn->add_body(new ObjectTransforms(object));
- const Node *node = graph->insert(fn);
- map_node_sockets(socket_map, bnode, node);
- }
-
-
- class FloatSocketInput : public FN::TupleCallBody {
- private:
- bNodeTree *m_btree;
- bNodeSocket *m_bsocket;
-
- public:
- FloatSocketInput(bNodeTree *btree, bNodeSocket *bsocket)
- : m_btree(btree), m_bsocket(bsocket) {}
-
- virtual void call(const Tuple &UNUSED(fn_in), Tuple &fn_out) const
- {
- PointerRNA ptr;
- RNA_pointer_create(&m_btree->id, &RNA_NodeSocket, m_bsocket, &ptr);
- float value = RNA_float_get(&ptr, "value");
- fn_out.set<float>(0, value);
- }
- };
-
- 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 const Node *get_input_node_for_socket(
- const FunctionNodeTree &tree,
- SharedDataFlowGraph &graph,
- bNodeSocket *bsocket)
- {
- 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(tree.orig_tree(), bsocket));
- 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;
+ for (SharedType &type : types) {
+ inputs.append(InputParameter("Input", type));
}
+ return SharedFunction::New("Inputs", Signature(inputs, {}));
}
- static void insert_input_socket_node(
- const FunctionNodeTree &tree,
- SharedDataFlowGraph &graph,
- Socket socket,
- bNodeSocket *bsocket)
- {
- const Node *node = get_input_node_for_socket(tree, graph, bsocket);
- graph->link(node->output(0), socket);
- }
-
- static SharedFunction get_output_function(const SmallTypeVector &types)
+ static SharedFunction get_function_with_outputs(const SmallTypeVector &types)
{
- InputParameters inputs;
+ OutputParameters outputs;
for (SharedType &type : types) {
- inputs.append(InputParameter("Input", type));
+ outputs.append(OutputParameter("Output", type));
}
- return SharedFunction::New("Output Node", Signature(inputs, {}));
+ return SharedFunction::New("Outputs", Signature({}, outputs));
}
static void insert_output_node(
- const FunctionNodeTree &UNUSED(tree),
+ bNodeTree *btree,
+ bNode *bnode,
SharedDataFlowGraph &graph,
- SocketMap &socket_map,
- bNode *bnode)
+ SocketMap &socket_map)
{
SmallTypeVector types;
for (bNodeSocket *bsocket : bSocketList(&bnode->inputs)) {
- types.append(get_type_of_socket(bsocket));
+ types.append(get_type_of_socket(btree, bsocket));
}
- SharedFunction fn = get_output_function(types);
+ SharedFunction fn = get_function_with_inputs(types);
const Node *node = graph->insert(fn);
- bNodeSocket *bsocket;
- uint i;
- for (i = 0, bsocket = (bNodeSocket *)bnode->inputs.first;
- bsocket;
- i++, bsocket = bsocket->next)
- {
+ uint i = 0;
+ for (bNodeSocket *bsocket : bSocketList(&bnode->inputs)) {
socket_map.add(bsocket, node->input(i));
+ i++;
}
}
static void insert_input_node(
-
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list