[Bf-blender-cvs] [d3bc6dc] object_nodes: Added the RGB mix node (unfinished).

Lukas Tönne noreply at git.blender.org
Tue Nov 24 09:44:05 CET 2015


Commit: d3bc6dcb678171c10e49788ad50f85b7b3770409
Author: Lukas Tönne
Date:   Thu Nov 5 17:56:55 2015 +0100
Branches: object_nodes
https://developer.blender.org/rBd3bc6dcb678171c10e49788ad50f85b7b3770409

Added the RGB mix node (unfinished).

===================================================================

M	source/blender/blenvm/compile/bvm_nodegraph.h
M	source/blender/blenvm/intern/bvm_api.cc

===================================================================

diff --git a/source/blender/blenvm/compile/bvm_nodegraph.h b/source/blender/blenvm/compile/bvm_nodegraph.h
index 238c585..73f39a9 100644
--- a/source/blender/blenvm/compile/bvm_nodegraph.h
+++ b/source/blender/blenvm/compile/bvm_nodegraph.h
@@ -55,6 +55,7 @@ namespace bvm {
 struct NodeGraph;
 struct NodeGraphInput;
 struct NodeType;
+struct NodeInstance;
 
 struct NodeSocket {
 	NodeSocket(const string &name, BVMType type, Value *default_value, bool constant);
@@ -108,6 +109,31 @@ struct NodeType {
 	SocketList outputs;
 };
 
+struct SocketPair {
+	SocketPair() :
+	    node(NULL), socket("")
+	{}
+	SocketPair(NodeInstance *node, const string &socket) :
+	    node(node), socket(socket)
+	{}
+	
+	bool operator < (const SocketPair &other) const
+	{
+		if (node < other.node)
+			return true;
+		else
+			return socket < other.socket;
+	}
+	
+	operator bool() const
+	{
+		return node != NULL && !socket.empty();
+	}
+	
+	NodeInstance *node;
+	string socket;
+};
+
 struct NodeInstance {
 	struct InputInstance {
 		const NodeGraphInput *graph_input;
@@ -128,6 +154,17 @@ struct NodeInstance {
 	NodeInstance(const NodeType *type, const string &name);
 	~NodeInstance();
 	
+	SocketPair input(const string &name)
+	{
+		assert(type->find_input(name) != NULL);
+		return SocketPair(this, name);
+	}
+	SocketPair output(const string &name)
+	{
+		assert(type->find_output(name) != NULL);
+		return SocketPair(this, name);
+	}
+	
 	NodeInstance *find_input_link_node(const string &name) const;
 	NodeInstance *find_input_link_node(int index) const;
 	const NodeSocket *find_input_link_socket(const string &name) const;
@@ -204,7 +241,6 @@ struct NodeGraph {
 	typedef std::pair<string, NodeType> NodeTypeMapPair;
 	typedef std::map<string, NodeInstance> NodeInstanceMap;
 	typedef std::pair<string, NodeInstance> NodeInstanceMapPair;
-	typedef std::pair<NodeInstance*, string> SocketPair;
 	
 	static NodeTypeMap node_types;
 	
@@ -234,11 +270,11 @@ struct NodeGraph {
 		SocketPair converted = (autoconvert) ?
 		                           add_type_converter(SocketPair(from_node, from), to_socket->type) :
 		                           SocketPair(from_node, from);
-		if (!converted.first)
+		if (!converted.node)
 			return false;
 		
-		const NodeSocket *conv_socket = converted.first->type->find_output(converted.second);
-		to_node->set_input_link(to_socket->name, converted.first, conv_socket);
+		const NodeSocket *conv_socket = converted.node->type->find_output(converted.socket);
+		to_node->set_input_link(to_socket->name, converted.node, conv_socket);
 		
 		return true;
 	}
@@ -276,24 +312,24 @@ protected:
 		switch (to_type) {
 			case BVM_FLOAT3: {
 				NodeInstance *node = add_node("SET_FLOAT3");
-				add_link(from.first, from.second, node, "value_x");
-				add_link(from.first, from.second, node, "value_y");
-				add_link(from.first, from.second, node, "value_z");
+				add_link(from.node, from.socket, node, "value_x");
+				add_link(from.node, from.socket, node, "value_y");
+				add_link(from.node, from.socket, node, "value_z");
 				result = SocketPair(node, "value");
 				break;
 			}
 			case BVM_FLOAT4: {
 				NodeInstance *node = add_node("SET_FLOAT4");
-				add_link(from.first, from.second, node, "value_x");
-				add_link(from.first, from.second, node, "value_y");
-				add_link(from.first, from.second, node, "value_z");
-				add_link(from.first, from.second, node, "value_w");
+				add_link(from.node, from.socket, node, "value_x");
+				add_link(from.node, from.socket, node, "value_y");
+				add_link(from.node, from.socket, node, "value_z");
+				add_link(from.node, from.socket, node, "value_w");
 				result = SocketPair(node, "value");
 				break;
 			}
 			case BVM_INT: {
 				NodeInstance *node = add_node("FLOAT_TO_INT");
-				add_link(from.first, from.second, node, "value");
+				add_link(from.node, from.socket, node, "value");
 				result = SocketPair(node, "value");
 				break;
 			}
@@ -310,13 +346,13 @@ protected:
 			case BVM_FLOAT4: {
 				NodeInstance *node_x = add_node("GET_ELEM_FLOAT3");
 				node_x->set_input_value("index", 0);
-				add_link(from.first, from.second, node_x, "value");
+				add_link(from.node, from.socket, node_x, "value");
 				NodeInstance *node_y = add_node("GET_ELEM_FLOAT3");
 				node_y->set_input_value("index", 1);
-				add_link(from.first, from.second, node_y, "value");
+				add_link(from.node, from.socket, node_y, "value");
 				NodeInstance *node_z = add_node("GET_ELEM_FLOAT3");
 				node_z->set_input_value("index", 2);
-				add_link(from.first, from.second, node_z, "value");
+				add_link(from.node, from.socket, node_z, "value");
 				
 				NodeInstance *node = add_node("SET_FLOAT4");
 				add_link(node_x, "value", node, "value_x");
@@ -339,13 +375,13 @@ protected:
 			case BVM_FLOAT3: {
 				NodeInstance *node_x = add_node("GET_ELEM_FLOAT4");
 				node_x->set_input_value("index", 0);
-				add_link(from.first, from.second, node_x, "value");
+				add_link(from.node, from.socket, node_x, "value");
 				NodeInstance *node_y = add_node("GET_ELEM_FLOAT4");
 				node_y->set_input_value("index", 1);
-				add_link(from.first, from.second, node_y, "value");
+				add_link(from.node, from.socket, node_y, "value");
 				NodeInstance *node_z = add_node("GET_ELEM_FLOAT4");
 				node_z->set_input_value("index", 2);
-				add_link(from.first, from.second, node_z, "value");
+				add_link(from.node, from.socket, node_z, "value");
 				
 				NodeInstance *node = add_node("SET_FLOAT3");
 				add_link(node_x, "value", node, "value_x");
@@ -375,7 +411,7 @@ protected:
 	SocketPair add_type_converter(const SocketPair &from, BVMType to_type)
 	{
 		SocketPair result(NULL, "");
-		const NodeSocket *from_socket = from.first->type->find_output(from.second);
+		const NodeSocket *from_socket = from.node->type->find_output(from.socket);
 		BVMType from_type = from_socket->type;
 		
 		if (from_type == to_type) {
diff --git a/source/blender/blenvm/intern/bvm_api.cc b/source/blender/blenvm/intern/bvm_api.cc
index ae14673..5daa193 100644
--- a/source/blender/blenvm/intern/bvm_api.cc
+++ b/source/blender/blenvm/intern/bvm_api.cc
@@ -261,12 +261,11 @@ namespace bvm {
 
 struct bNodeCompiler {
 	typedef std::pair<bNode*, bNodeSocket*> bSocketPair;
-	typedef std::pair<bvm::NodeInstance*, bvm::string> SocketPair;
 	typedef std::set<SocketPair> SocketSet;
 	typedef std::map<bSocketPair, SocketSet> InputMap;
 	typedef std::map<bSocketPair, SocketPair> OutputMap;
 	
-	bNodeCompiler(bvm::NodeGraph *graph) :
+	bNodeCompiler(NodeGraph *graph) :
 	    m_graph(graph),
 	    m_current_bnode(NULL)
 	{
@@ -282,16 +281,34 @@ struct bNodeCompiler {
 	const InputMap &input_map() const { return m_input_map; }
 	const OutputMap &output_map() const { return m_output_map; }
 	
-	bvm::NodeInstance *add_node(const bvm::string &type,  const bvm::string &name = "")
+	NodeInstance *add_node(const string &type,  const string &name = "")
 	{
 		return m_graph->add_node(type, name);
 	}
 	
-	void map_input_socket(int bindex, bvm::NodeInstance *node, const bvm::string &name)
+	SocketPair add_input_proxy(int index)
+	{
+		bNodeSocket *bsock = (bNodeSocket *)BLI_findlink(&m_current_bnode->inputs, index);
+		assert(bsock != NULL);
+		
+		NodeInstance *node = NULL;
+		switch (bsock->type) {
+			case SOCK_FLOAT: node = add_node("PASS_FLOAT"); break;
+			case SOCK_INT: node = add_node("PASS_INT"); break;
+			case SOCK_VECTOR: node = add_node("PASS_FLOAT3"); break;
+			case SOCK_RGBA: node = add_node("PASS_FLOAT4"); break;
+		}
+		map_input_socket(index, node->input("value"));
+		return node->output("value");
+	}
+	
+	void map_input_socket(int bindex, const SocketPair &socket)
 	{
 		bNodeSocket *binput = (bNodeSocket *)BLI_findlink(&m_current_bnode->inputs, bindex);
+		NodeInstance *node = socket.node;
+		const string &name = socket.socket;
 		
-		m_input_map[bSocketPair(m_current_bnode, binput)].insert(SocketPair(node, name));
+		m_input_map[bSocketPair(m_current_bnode, binput)].insert(socket);
 		
 		switch (binput->type) {
 			case SOCK_FLOAT: {
@@ -301,7 +318,7 @@ struct bNodeCompiler {
 			}
 			case SOCK_VECTOR: {
 				bNodeSocketValueVector *bvalue = (bNodeSocketValueVector *)binput->default_value;
-				node->set_input_value(name, bvm::float3(bvalue->value[0], bvalue->value[1], bvalue->value[2]));
+				node->set_input_value(name, float3(bvalue->value[0], bvalue->value[1], bvalue->value[2]));
 				break;
 			}
 			case SOCK_INT: {
@@ -311,35 +328,35 @@ struct bNodeCompiler {
 			}
 			case SOCK_RGBA: {
 				bNodeSocketValueRGBA *bvalue = (bNodeSocketValueRGBA *)binput->default_value;
-				node->set_input_value(name, bvm::float4(bvalue->value[0], bvalue->value[1], bvalue->value[2], bvalue->value[3]));
+				node->set_input_value(name, float4(bvalue->value[0], bvalue->value[1], bvalue->value[2], bvalue->value[3]));
 				break;
 			}
 		}
 	}
 	
-	void map_output_socket(int bindex, bvm::NodeInstance *node, const bvm::string &name)
+	void map_output_socket(int bindex, const SocketPair &socket)
 	{
 		bNodeSocket *boutput = (bNodeSocket *)BLI_findlink(&m_current_bnode->outputs, bindex);
 		
-		m_output_map[bSocketPair(m_current_bnode, boutput)] = SocketPair(node, name);
+		m_output_map[bSocketPair(m_current_bnode, boutput)] = socket;
 	}
 	
-	void set_graph_output(const bvm::string &graph_output_name, bvm::NodeInstance *node, const bvm::string &name)
+	void set_graph_output(const string &graph_output_name, const SocketPair &socket)
 	{
-		m_graph->set_output_link(graph_output_name, node, name);
+		m_graph->set_output_link(graph_output_name, socket.node, socket.socket);
 	}
 	
-	void map_all_sockets(bvm::NodeInstance *node)
+	void map_all_sockets(NodeInstance *node)
 	{
 		bNodeSocket *bsock;
 		int i;
 		for (bsock = (bNodeSocket *)m_current_bnode->inputs.first, i = 0; bsock; bsock = bsock->next, ++i) {
-			const bvm::NodeSocket *input = node->type->find_input(i);
-			map_input_socket(i, node, input->name);
+			const NodeSocket *input = node->type->find_input(i);
+			map_input_socket(i, SocketPair(node, input->name));
 		}
 		for (bsock = (bNodeSocket *)m_current_bnode->outputs.first, i = 0; bsock; bsock = bsock->next, ++i) {
-			const bvm::NodeSocket *output = node->type->find_output(i);
-			map_o

@@ Diff output truncated at 10240 characters. @@




More information about the Bf-blender-cvs mailing list