[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