[Bf-blender-cvs] [e1a6f41] object_nodes: Next compiler step: convert internal node graph to opcode instructions.
Lukas Tönne
noreply at git.blender.org
Tue Nov 24 09:43:03 CET 2015
Commit: e1a6f41fc97e3fb149d8910710eac7d9935d1608
Author: Lukas Tönne
Date: Mon Oct 19 11:17:49 2015 +0200
Branches: object_nodes
https://developer.blender.org/rBe1a6f41fc97e3fb149d8910710eac7d9935d1608
Next compiler step: convert internal node graph to opcode instructions.
===================================================================
M source/blender/blenvm/intern/bvm_api.cc
M source/blender/blenvm/intern/bvm_codegen.cc
M source/blender/blenvm/intern/bvm_codegen.h
M source/blender/blenvm/intern/bvm_eval.cc
M source/blender/blenvm/intern/bvm_nodegraph.cc
M source/blender/blenvm/intern/bvm_nodegraph.h
M source/blender/blenvm/intern/bvm_opcode.h
M source/blender/blenvm/intern/bvm_type_desc.h
===================================================================
diff --git a/source/blender/blenvm/intern/bvm_api.cc b/source/blender/blenvm/intern/bvm_api.cc
index 3793042..db657fc 100644
--- a/source/blender/blenvm/intern/bvm_api.cc
+++ b/source/blender/blenvm/intern/bvm_api.cc
@@ -50,6 +50,7 @@ extern "C" {
void BVM_init(void)
{
+ bvm::register_opcode_node_types();
}
void BVM_free(void)
@@ -112,6 +113,13 @@ void BVM_eval_forcefield(struct BVMEvalContext *ctx, struct BVMExpression *expr,
static void gen_forcefield_nodegraph(bNodeTree *btree, bvm::NodeGraph &graph)
{
+ {
+ float zero[3] = {0.0f, 0.0f, 0.0f};
+ graph.add_output("force", BVM_FLOAT3, zero);
+ graph.add_output("impulse", BVM_FLOAT3, zero);
+ }
+
+#if 0
for (bNode *bnode = (bNode*)btree->nodes.first; bnode; bnode = bnode->next) {
BLI_assert(bnode->typeinfo != NULL);
if (!nodeIsRegistered(bnode))
@@ -128,12 +136,15 @@ static void gen_forcefield_nodegraph(bNodeTree *btree, bvm::NodeGraph &graph)
graph.add_link(blink->fromnode->name, blink->fromsock->name,
blink->tonode->name, blink->tosock->name);
}
-
+#else
+ // XXX TESTING
{
- float zero[3] = {0.0f, 0.0f, 0.0f};
- graph.add_output("force", BVM_FLOAT3, zero);
- graph.add_output("impulse", BVM_FLOAT3, zero);
+ bvm::NodeInstance *node = graph.add_node("PASS_FLOAT3", "pass0");
+ node->set_input_value("value", bvm::float3(0.5, 1.5, -0.3));
+
+ graph.set_output_link("force", node, "value");
}
+#endif
}
struct BVMExpression *BVM_gen_forcefield_expression(bNodeTree *btree)
diff --git a/source/blender/blenvm/intern/bvm_codegen.cc b/source/blender/blenvm/intern/bvm_codegen.cc
index 7b8f0c7..a7eaa57 100644
--- a/source/blender/blenvm/intern/bvm_codegen.cc
+++ b/source/blender/blenvm/intern/bvm_codegen.cc
@@ -67,15 +67,17 @@ StackIndex BVMCompiler::find_stack_index(int size) const
return BVM_STACK_INVALID;
}
-void BVMCompiler::assign_stack_index(ReturnValue &rval)
+StackIndex BVMCompiler::assign_stack_index(const TypeDesc &typedesc)
{
- int size = rval.typedesc.stack_size();
+ int size = typedesc.stack_size();
- rval.stack_offset = find_stack_index(size);
+ StackIndex stack_offset = find_stack_index(size);
for (int i = 0; i < size; ++i) {
// TODO keep track of value users
- stack_users[rval.stack_offset + i] += 1;
+ stack_users[stack_offset + i] += 1;
}
+
+ return stack_offset;
}
void BVMCompiler::push_opcode(OpCode op)
@@ -101,35 +103,130 @@ void BVMCompiler::push_float3(float3 f)
expr->add_instruction(float_to_instruction(f.z));
}
+StackIndex BVMCompiler::codegen_value(const Value *value)
+{
+ StackIndex offset = assign_stack_index(value->typedesc());
+
+ switch (value->typedesc().base_type) {
+ case BVM_FLOAT: {
+ float f = 0.0f;
+ value->get(&f);
+
+ push_opcode(OP_VALUE_FLOAT);
+ push_float(f);
+ push_stack_index(offset);
+ break;
+ }
+ case BVM_FLOAT3: {
+ float3 f = float3(0.0f, 0.0f, 0.0f);
+ value->get(&f);
+
+ push_opcode(OP_VALUE_FLOAT3);
+ push_float3(f);
+ push_stack_index(offset);
+ break;
+ }
+ }
+
+ return offset;
+}
+
+#if 0
+StackIndex BVMCompiler::codegen_link(const TypeDesc &from, StackIndex stack_from,
+ const TypeDesc &to, StackIndex stack_to)
+{
+ if (to.assignable(from)) {
+ switch (to.base_type) {
+ case BVM_FLOAT:
+ push_opcode(OP_PASS_FLOAT);
+ break;
+ case BVM_FLOAT3:
+ push_opcode(OP_PASS_FLOAT3);
+ break;
+ }
+ push_stack_index(stack_from);
+ push_stack_index(stack_to);
+ }
+}
+#endif
+
Expression *BVMCompiler::codegen_expression(const NodeGraph &graph)
{
+ typedef std::pair<const NodeInstance *, const NodeSocket *> SocketPair;
+ typedef std::map<SocketPair, StackIndex> SocketIndexMap;
+
expr = new Expression();
- for (NodeGraph::OutputList::const_iterator it = graph.outputs.begin();
- it != graph.outputs.end();
+ SocketIndexMap socket_index;
+
+ for (NodeGraph::NodeInstanceMap::const_iterator it = graph.nodes.begin();
+ it != graph.nodes.end();
++it) {
- const NodeGraphOutput &output = *it;
+ const NodeInstance &node = it->second;
- ReturnValue &rval = expr->add_return_value(TypeDesc(output.type), output.name);
+ for (int i = 0; i < node.type->inputs.size(); ++i) {
+ const NodeSocket &input = node.type->inputs[i];
+ SocketPair key(&node, &input);
+
+ if (node.has_input_link(i)) {
+ const NodeInstance *link_node = node.find_input_link_node(i);
+ const NodeSocket *link_socket = node.find_input_link_socket(i);
+ SocketPair link_key(link_node, link_socket);
+ socket_index[key] = socket_index[link_key];
+ }
+ else if (node.has_input_value(i)) {
+ Value *value = node.find_input_value(i);
+ socket_index[key] = codegen_value(value);
+ }
+ else {
+ socket_index[key] = codegen_value(input.default_value);
+ }
+ }
- assign_stack_index(rval);
+ OpCode op = get_opcode_from_node_type(node.type->name);
+ push_opcode(op);
+
+ for (int i = 0; i < node.type->inputs.size(); ++i) {
+ const NodeSocket &input = node.type->inputs[i];
+ SocketPair key(&node, &input);
+
+ push_stack_index(socket_index[key]);
+ }
+ for (int i = 0; i < node.type->outputs.size(); ++i) {
+ const NodeSocket &output = node.type->outputs[i];
+ SocketPair key(&node, &output);
+
+ socket_index[key] = assign_stack_index(TypeDesc(output.type));
+
+ push_stack_index(socket_index[key]);
+ }
}
- for (NodeGraph::NodeInstanceMap::const_iterator it = graph.nodes.begin();
- it != graph.nodes.end();
+ for (NodeGraph::OutputList::const_iterator it = graph.outputs.begin();
+ it != graph.outputs.end();
++it) {
- const NodeInstance &node = it->second;
+ const NodeGraphOutput &output = *it;
+ ReturnValue &rval = expr->add_return_value(TypeDesc(output.type), output.name);
+
+ if (output.link_node && output.link_socket) {
+ SocketPair link_key(output.link_node, output.link_socket);
+
+ rval.stack_offset = socket_index[link_key];
+ }
+ else {
+ rval.stack_offset = assign_stack_index(rval.typedesc);
+ }
}
+#if 0
// XXX TESTING
{
push_opcode(OP_VALUE_FLOAT3);
push_float3(float3(0.3, -0.6, 0.0));
push_stack_index(expr->return_value(0).stack_offset);
-// push_stack_index(0x0F);
-// push_opcode(OP_ASSIGN_FLOAT3);
}
+#endif
push_opcode(OP_END);
diff --git a/source/blender/blenvm/intern/bvm_codegen.h b/source/blender/blenvm/intern/bvm_codegen.h
index 5eec0c5..dfa8374 100644
--- a/source/blender/blenvm/intern/bvm_codegen.h
+++ b/source/blender/blenvm/intern/bvm_codegen.h
@@ -42,6 +42,7 @@ namespace bvm {
struct Expression;
struct NodeGraph;
+struct NodeInstance;
struct TypeDesc;
struct ReturnValue;
@@ -52,13 +53,14 @@ struct BVMCompiler {
~BVMCompiler();
StackIndex find_stack_index(int size) const;
- void assign_stack_index(ReturnValue &rval);
+ StackIndex assign_stack_index(const TypeDesc &typedesc);
void push_opcode(OpCode op);
void push_stack_index(StackIndex arg);
void push_float(float f);
void push_float3(float3 f);
+ StackIndex codegen_value(const Value *value);
Expression *codegen_expression(const NodeGraph &graph);
private:
diff --git a/source/blender/blenvm/intern/bvm_eval.cc b/source/blender/blenvm/intern/bvm_eval.cc
index 2c1aef8..b5c7446 100644
--- a/source/blender/blenvm/intern/bvm_eval.cc
+++ b/source/blender/blenvm/intern/bvm_eval.cc
@@ -74,13 +74,13 @@ static void eval_op_value_float3(float *stack, float3 value, StackIndex offset)
stack_store_float3(stack, offset, value);
}
-static void eval_op_assign_float(float *stack, StackIndex offset_to, StackIndex offset_from)
+static void eval_op_pass_float(float *stack, StackIndex offset_from, StackIndex offset_to)
{
float f = stack_load_float(stack, offset_from);
stack_store_float(stack, offset_to, f);
}
-static void eval_op_assign_float3(float *stack, StackIndex offset_to, StackIndex offset_from)
+static void eval_op_pass_float3(float *stack, StackIndex offset_from, StackIndex offset_to)
{
float3 f = stack_load_float3(stack, offset_from);
stack_store_float3(stack, offset_to, f);
@@ -108,16 +108,16 @@ void EvalContext::eval_instructions(const Expression &expr, float *stack) const
eval_op_value_float3(stack, value, offset);
break;
}
- case OP_ASSIGN_FLOAT: {
- int offset_to = instr++;
- int offset_from = instr++;
- eval_op_assign_float(stack, offset_to, offset_from);
+ case OP_PASS_FLOAT: {
+ StackIndex offset_from = expr.read_stack_index(&instr);
+ StackIndex offset_to = expr.read_stack_index(&instr);
+ eval_op_pass_float(stack, offset_from, offset_to);
break;
}
- case OP_ASSIGN_FLOAT3: {
- int offset_to = instr++;
- int offset_from = instr++;
- eval_op_assign_float3(stack, offset_to, offset_from);
+ case OP_PASS_FLOAT3: {
+ StackIndex offset_from = expr.read_stack_index(&instr);
+ StackIndex offset_to = expr.read_stack_index(&instr);
+ eval_op_pass_float3(stack, offset_from, offset_to);
break;
}
case OP_END:
diff --git a/source/blender/blenvm/intern/bvm_nodegraph.cc b/source/blender/blenvm/intern/bvm_nodegraph.cc
index 8d8c5e1..06a44ca 100644
--- a/source/blender/blenvm/intern/bvm_nodegraph.cc
+++ b/source/blender/blenvm/intern/bvm_nodegraph.cc
@@ -30,14 +30,15 @@
*/
#include <map>
-#include <string>
#include <vector>
+#include <cassert>
#include "bvm_nodegraph.h"
+#include "bvm_opcode.h"
namespace bvm {
-NodeSocket::NodeSocket(const std::string &name, BVMType type, Value *default_value) :
+NodeSocket::NodeSocket(const string &name, BVMType type, Value *default_value) :
name(name),
type(type),
default_value(default_value)
@@ -50,7 +51,7 @@ NodeSocket::~NodeSocket()
/* ------------------------------------------------------------------------- */
-NodeType::NodeType(const std::string &name) :
+NodeType::NodeType(const string &name) :
name(name)
{
}
@@ -71,7 +72,7 @@ const NodeSocket *NodeType::find_output(int index) const
return &outputs[index];
}
-const NodeSocket *NodeType::find_input(const std::string &name) const
+const NodeSocket *NodeType::find_input(const string &name) const
{
for (SocketList::const_iterator it = inputs.begin(); it != inputs.end();
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list