Node Group Interface

source/blender/nodes/intern/node_common.c

Index: source/blender/nodes/intern/node_common.c
===================================================================
--- source/blender/nodes/intern/node_common.c	(revision 43995)
+++ source/blender/nodes/intern/node_common.c	(working copy)
@@ -32,16 +32,12 @@
 
 #include <string.h>
 
-#include "DNA_action_types.h"
-#include "DNA_anim_types.h"
 #include "DNA_node_types.h"
 
 #include "BLI_listbase.h"
 #include "BLI_string.h"
 #include "BLI_utildefines.h"
 
-#include "BKE_action.h"
-#include "BKE_animsys.h"
 #include "BKE_global.h"
 #include "BKE_library.h"
 #include "BKE_main.h"
@@ -60,25 +56,25 @@
 
 /**** Group ****/
 
-bNodeSocket *node_group_find_input(bNode *gnode, bNodeSocket *gsock)
+bNodeSocket *node_group_find_input_socket(bNode *groupnode, int own_index)
 {
 	bNodeSocket *sock;
-	for (sock=gnode->inputs.first; sock; sock=sock->next)
-		if (sock->groupsock == gsock)
+	for (sock=groupnode->inputs.first; sock; sock=sock->next)
+		if (sock->own_index == own_index)
 			return sock;
 	return NULL;
 }
 
-bNodeSocket *node_group_find_output(bNode *gnode, bNodeSocket *gsock)
+bNodeSocket *node_group_find_output_socket(bNode *groupnode, int own_index)
 {
 	bNodeSocket *sock;
-	for (sock=gnode->outputs.first; sock; sock=sock->next)
-		if (sock->groupsock == gsock)
+	for (sock=groupnode->outputs.first; sock; sock=sock->next)
+		if (sock->own_index == own_index)
 			return sock;
 	return NULL;
 }
 
-bNodeSocket *node_group_add_extern_socket(bNodeTree *UNUSED(ntree), ListBase *lb, int in_out, bNodeSocket *gsock)
+bNodeSocket *node_group_add_extern_socket(bNodeTree *UNUSED(ntree), ListBase *lb, int in_out, struct bNodeSocket *gsock)
 {
 	bNodeSocket *sock;
 	
@@ -97,7 +93,6 @@
 	sock->flag |= SOCK_DYNAMIC;
 	
 	sock->own_index = gsock->own_index;
-	sock->groupsock = gsock;
 	sock->limit = (in_out==SOCK_IN ? 1 : 0xFFF);
 	
 	sock->default_value = node_socket_make_default_value(sock->type);
@@ -109,381 +104,6 @@
 	return sock;
 }
 
-bNode *node_group_make_from_selected(bNodeTree *ntree)
-{
-	bNodeLink *link, *linkn;
-	bNode *node, *gnode, *nextn;
-	bNodeTree *ngroup;
-	bNodeSocket *gsock;
-	ListBase anim_basepaths = {NULL, NULL};
-	float min[2], max[2];
-	int totnode=0;
-	bNodeTemplate ntemp;
-	
-	INIT_MINMAX2(min, max);
-	
-	/* is there something to group? also do some clearing */
-	for(node= ntree->nodes.first; node; node= node->next) {
-		if(node->flag & NODE_SELECT) {
-			/* no groups in groups */
-			if(node->type==NODE_GROUP)
-				return NULL;
-			DO_MINMAX2( (&node->locx), min, max);
-			totnode++;
-		}
-		node->done= 0;
-	}
-	if(totnode==0) return NULL;
-	
-	/* check if all connections are OK, no unselected node has both
-		inputs and outputs to a selection */
-	for(link= ntree->links.first; link; link= link->next) {
-		if(link->fromnode && link->tonode && link->fromnode->flag & NODE_SELECT)
-			link->tonode->done |= 1;
-		if(link->fromnode && link->tonode && link->tonode->flag & NODE_SELECT)
-			link->fromnode->done |= 2;
-	}	
-	
-	for(node= ntree->nodes.first; node; node= node->next) {
-		if((node->flag & NODE_SELECT)==0)
-			if(node->done==3)
-				break;
-	}
-	if(node) 
-		return NULL;
-	
-	/* OK! new nodetree */
-	ngroup= ntreeAddTree("NodeGroup", ntree->type, NODE_GROUP);
-	
-	/* move nodes over */
-	for(node= ntree->nodes.first; node; node= nextn) {
-		nextn= node->next;
-		if(node->flag & NODE_SELECT) {
-			/* keep track of this node's RNA "base" path (the part of the pat identifying the node) 
-			 * if the old nodetree has animation data which potentially covers this node
-			 */
-			if (ntree->adt) {
-				PointerRNA ptr;
-				char *path;
-				
-				RNA_pointer_create(&ntree->id, &RNA_Node, node, &ptr);
-				path = RNA_path_from_ID_to_struct(&ptr);
-				
-				if (path)
-					BLI_addtail(&anim_basepaths, BLI_genericNodeN(path));
-			}
-			
-			/* change node-collection membership */
-			BLI_remlink(&ntree->nodes, node);
-			BLI_addtail(&ngroup->nodes, node);
-			
-			node->locx-= 0.5f*(min[0]+max[0]);
-			node->locy-= 0.5f*(min[1]+max[1]);
-		}
-	}
-
-	/* move animation data over */
-	if (ntree->adt) {
-		LinkData *ld, *ldn=NULL;
-		
-		BKE_animdata_separate_by_basepath(&ntree->id, &ngroup->id, &anim_basepaths);
-		
-		/* paths + their wrappers need to be freed */
-		for (ld = anim_basepaths.first; ld; ld = ldn) {
-			ldn = ld->next;
-			
-			MEM_freeN(ld->data);
-			BLI_freelinkN(&anim_basepaths, ld);
-		}
-	}
-	
-	/* node groups don't use internal cached data */
-	ntreeFreeCache(ngroup);
-	
-	/* make group node */
-	ntemp.type = NODE_GROUP;
-	ntemp.ngroup = ngroup;
-	gnode= nodeAddNode(ntree, &ntemp);
-	gnode->locx= 0.5f*(min[0]+max[0]);
-	gnode->locy= 0.5f*(min[1]+max[1]);
-	
-	/* relink external sockets */
-	for(link= ntree->links.first; link; link= linkn) {
-		linkn= link->next;
-		
-		if(link->fromnode && link->tonode && (link->fromnode->flag & link->tonode->flag & NODE_SELECT)) {
-			BLI_remlink(&ntree->links, link);
-			BLI_addtail(&ngroup->links, link);
-		}
-		else if(link->tonode && (link->tonode->flag & NODE_SELECT)) {
-			gsock = node_group_expose_socket(ngroup, link->tosock, SOCK_IN);
-			link->tosock->link = nodeAddLink(ngroup, NULL, gsock, link->tonode, link->tosock);
-			link->tosock = node_group_add_extern_socket(ntree, &gnode->inputs, SOCK_IN, gsock);
-			link->tonode = gnode;
-		}
-		else if(link->fromnode && (link->fromnode->flag & NODE_SELECT)) {
-			/* search for existing group node socket */
-			for (gsock=ngroup->outputs.first; gsock; gsock=gsock->next)
-				if (gsock->link && gsock->link->fromsock==link->fromsock)
-					break;
-			if (!gsock) {
-				gsock = node_group_expose_socket(ngroup, link->fromsock, SOCK_OUT);
-				gsock->link = nodeAddLink(ngroup, link->fromnode, link->fromsock, NULL, gsock);
-				link->fromsock = node_group_add_extern_socket(ntree, &gnode->outputs, SOCK_OUT, gsock);
-			}
-			else
-				link->fromsock = node_group_find_output(gnode, gsock);
-			link->fromnode = gnode;
-		}
-	}
-
-	/* update of the group tree */
-	ngroup->update |= NTREE_UPDATE;
-	ntreeUpdateTree(ngroup);
-	/* update of the tree containing the group instance node */
-	ntree->update |= NTREE_UPDATE_NODES | NTREE_UPDATE_LINKS;
-	ntreeUpdateTree(ntree);
-
-	return gnode;
-}
-
-/* returns 1 if its OK */
-int node_group_ungroup(bNodeTree *ntree, bNode *gnode)
-{
-	bNodeLink *link, *linkn;
-	bNode *node, *nextn;
-	bNodeTree *ngroup, *wgroup;
-	ListBase anim_basepaths = {NULL, NULL};
-	
-	ngroup= (bNodeTree *)gnode->id;
-	if(ngroup==NULL) return 0;
-	
-	/* clear new pointers, set in copytree */
-	for(node= ntree->nodes.first; node; node= node->next)
-		node->new_node= NULL;
-	
-	/* wgroup is a temporary copy of the NodeTree we're merging in
-	 *	- all of wgroup's nodes are transferred across to their new home
-	 *	- ngroup (i.e. the source NodeTree) is left unscathed
-	 */
-	wgroup= ntreeCopyTree(ngroup);
-	
-	/* add the nodes into the ntree */
-	for(node= wgroup->nodes.first; node; node= nextn) {
-		nextn= node->next;
-		
-		/* keep track of this node's RNA "base" path (the part of the pat identifying the node) 
-		 * if the old nodetree has animation data which potentially covers this node
-		 */
-		if (wgroup->adt) {
-			PointerRNA ptr;
-			char *path;
-			
-			RNA_pointer_create(&wgroup->id, &RNA_Node, node, &ptr);
-			path = RNA_path_from_ID_to_struct(&ptr);
-			
-			if (path)
-				BLI_addtail(&anim_basepaths, BLI_genericNodeN(path));
-		}
-		
-		/* migrate node */
-		BLI_remlink(&wgroup->nodes, node);
-		BLI_addtail(&ntree->nodes, node);
-		
-		node->locx+= gnode->locx;
-		node->locy+= gnode->locy;
-		
-		node->flag |= NODE_SELECT;
-	}
-	
-	/* restore external links to and from the gnode */
-	for(link= ntree->links.first; link; link= link->next) {
-		if (link->fromnode==gnode) {
-			if (link->fromsock->groupsock) {
-				bNodeSocket *gsock= link->fromsock->groupsock;
-				if (gsock->link) {
-					if (gsock->link->fromnode) {
-						/* NB: using the new internal copies here! the groupsock pointer still maps to the old tree */
-						link->fromnode = (gsock->link->fromnode ? gsock->link->fromnode->new_node : NULL);
-						link->fromsock = gsock->link->fromsock->new_sock;
-					}
-					else {
-						/* group output directly maps to group input */
-						bNodeSocket *insock= node_group_find_input(gnode, gsock->link->fromsock);
-						if (insock->link) {
-							link->fromnode = insock->link->fromnode;
-							link->fromsock = insock->link->fromsock;
-						}
-					}
-				}
-				else {
-					/* copy the default input value from the group socket default to the external socket */
-					node_socket_convert_default_value(link->tosock->type, link->tosock->default_value, gsock->type, gsock->default_value);
-				}
-			}
-		}
-	}
-	/* remove internal output links, these are not used anymore */
-	for(link=wgroup->links.first; link; link= linkn) {
-		linkn = link->next;
-		if (!link->tonode)
-			nodeRemLink(wgroup, link);
-	}
-	/* restore links from internal nodes */
-	for(link= wgroup->links.first; link; link= link->next) {
-		/* indicates link to group input */
-		if (!link->fromnode) {
-			/* NB: can't use find_group_node_input here,
-			 * because gnode sockets still point to the old tree!
-			 */
-			bNodeSocket *insock;
-			for (insock= gnode->inputs.first; insock; insock= insock->next)
-				if (insock->groupsock->new_sock == link->fromsock)
-					break;
-			if (insock->link) {
-				link->fromnode = insock->link->fromnode;
-				link->fromsock = insock->link->fromsock;
-			}
-			else {
-				/* copy the default input value from the group node socket default to the internal socket */
-				node_socket_convert_default_value(link->tosock->type, link->tosock->default_value, insock->type, insock->default_value);
-				nodeRemLink(wgroup, link);
-			}
-		}
-	}
-	
-	/* add internal links to the ntree */
-	for(link= wgroup->links.first; link; link= linkn) {
-		linkn= link->next;
-		BLI_remlink(&wgroup->links, link);
-		BLI_addtail(&ntree->links, link);
-	}
-	
-	/* and copy across the animation,
-	 * note that the animation data's action can be NULL here */
-	if (wgroup->adt) {
-		LinkData *ld, *ldn=NULL;
-		bAction *waction;
-		
-		/* firstly, wgroup needs to temporary dummy action that can be destroyed, as it shares copies */
-		waction = wgroup->adt->action = copy_action(wgroup->adt->action);
-		
-		/* now perform the moving */
-		BKE_animdata_separate_by_basepath(&wgroup->id, &ntree->id, &anim_basepaths);
-		
-		/* paths + their wrappers need to be freed */
-		for (ld = anim_basepaths.first; ld; ld = ldn) {
-			ldn = ld->next;
-			
-			MEM_freeN(ld->data);
-			BLI_freelinkN(&anim_basepaths, ld);
-		}
-		
-		/* free temp action too */
-		if (waction) {
-			free_libblock(&G.main->action, waction);
-		}
-	}
-	
-	/* delete the group instance. this also removes old input links! */
-	nodeFreeNode(ntree, gnode);
-
-	/* free the group tree (takes care of user count) */
-	free_libblock(&G.main->nodetree, wgroup);
-	
-	ntree->update |= NTREE_UPDATE_NODES | NTREE_UPDATE_LINKS;
-	ntreeUpdateTree(ntree);
-	
-	return 1;
-}
-
-bNodeSocket *node_group_add_socket(bNodeTree *ngroup, const char *name, int type, int in_out)
-{
-	bNodeSocketType *stype = ntreeGetSocketType(type);
-	bNodeSocket *gsock = MEM_callocN(sizeof(bNodeSocket), "bNodeSocket");
-	
-	BLI_strncpy(gsock->name, name, sizeof(gsock->name));
-	gsock->type = type;
-	/* group sockets are dynamically added */
-	gsock->flag |= SOCK_DYNAMIC;
-
-	gsock->next = gsock->prev = NULL;
-	gsock->new_sock = NULL;
-	gsock->link = NULL;
-	/* assign new unique index */
-	gsock->own_index = ngroup->cur_index++;
-	gsock->limit = (in_out==SOCK_IN ? 0xFFF : 1);
-	
-	if (stype->value_structsize > 0)
-		gsock->default_value = MEM_callocN(stype->value_structsize, "default socket value");
-	
-	BLI_addtail(in_out==SOCK_IN ? &ngroup->inputs : &ngroup->outputs, gsock);
-	
-	ngroup->update |= (in_out==SOCK_IN ? NTREE_UPDATE_GROUP_IN : NTREE_UPDATE_GROUP_OUT);
-	
-	return gsock;
-}
-
-bNodeSocket *node_group_expose_socket(bNodeTree *ngroup, bNodeSocket *sock, int in_out)
-{
-	bNodeSocket *gsock= node_group_add_socket(ngroup, sock->name, sock->type, in_out);
-	
-	/* initialize the default value. */
-	node_socket_copy_default_value(gsock->type, gsock->default_value, sock->default_value);
-	
-	return gsock;
-}
-
-void node_group_expose_all_sockets(bNodeTree *ngroup)
-{
-	bNode *node;
-	bNodeSocket *sock, *gsock;
-	
-	for (node=ngroup->nodes.first; node; node=node->next) {
-		for (sock=node->inputs.first; sock; sock=sock->next) {
-			if (!sock->link && !nodeSocketIsHidden(sock)) {
-				gsock = node_group_add_socket(ngroup, sock->name, sock->type, SOCK_IN);
-				
-				/* initialize the default value. */
-				node_socket_copy_default_value(gsock->type, gsock->default_value, sock->default_value);
-				
-				sock->link = nodeAddLink(ngroup, NULL, gsock, node, sock);
-			}
-		}
-		for (sock=node->outputs.first; sock; sock=sock->next) {
-			if (nodeCountSocketLinks(ngroup, sock)==0 && !nodeSocketIsHidden(sock)) {
-				gsock = node_group_add_socket(ngroup, sock->name, sock->type, SOCK_OUT);
-				
-				/* initialize the default value. */
-				node_socket_copy_default_value(gsock->type, gsock->default_value, sock->default_value);
-				
-				gsock->link = nodeAddLink(ngroup, node, sock, NULL, gsock);
-			}
-		}
-	}
-}
-
-void node_group_remove_socket(bNodeTree *ngroup, bNodeSocket *gsock, int in_out)
-{
-	nodeRemSocketLinks(ngroup, gsock);
-	
-	switch (in_out) {
-	case SOCK_IN:
-		BLI_remlink(&ngroup->inputs, gsock);
-		ngroup->update |= NTREE_UPDATE_GROUP_IN;
-		break;
-	case SOCK_OUT:
-		BLI_remlink(&ngroup->outputs, gsock);
-		ngroup->update |= NTREE_UPDATE_GROUP_OUT;
-		break;
-	}
-	
-	if (gsock->default_value)
-		MEM_freeN(gsock->default_value);
-	
-	MEM_freeN(gsock);
-}
-
 /* groups display their internal tree name as label */
 const char *node_group_label(bNode *node)
 {
@@ -521,16 +141,7 @@
 {
 	node->id = (ID*)ntemp->ngroup;
 	
-	/* NB: group socket input/output roles are inverted internally!
-	 * Group "inputs" work as outputs in links and vice versa.
-	 */
-	if (ntemp->ngroup) {
-		bNodeSocket *gsock;
-		for (gsock=ntemp->ngroup->inputs.first; gsock; gsock=gsock->next)
-			node_group_add_extern_socket(ntree, &node->inputs, SOCK_IN, gsock);
-		for (gsock=ntemp->ngroup->outputs.first; gsock; gsock=gsock->next)
-			node_group_add_extern_socket(ntree, &node->outputs, SOCK_OUT, gsock);
-	}
+	node_group_verify(ntree, node, (ID*)ntemp->ngroup);
 }
 
 static bNodeSocket *group_verify_socket(bNodeTree *ntree, ListBase *lb, int in_out, bNodeSocket *gsock)
@@ -546,11 +157,14 @@
 				break;
 	}
 	if(sock) {
-		sock->groupsock = gsock;
-		
 		BLI_strncpy(sock->name, gsock->name, sizeof(sock->name));
-		sock->type= gsock->type;
 		
+		if (gsock->type != sock->type)
+			nodeSocketSetType(sock, gsock->type);
+		
+		/* update type details from internal socket */
+		node_socket_verify_default_value_type(sock->type, sock->default_value, gsock->default_value);
+		
 		/* XXX hack: group socket input/output roles are inverted internally,
 		 * need to change the limit value when making actual node sockets from them.
 		 */
@@ -565,23 +179,29 @@
 	}
 }
 
-static void group_verify_socket_list(bNodeTree *ntree, bNode *node, ListBase *lb, int in_out, ListBase *glb)
+static void group_verify_socket_list(bNodeTree *ntree, bNode *gnode, ListBase *lb, int in_out, bNodeTree *ngroup)
 {
-	bNodeSocket *sock, *nextsock, *gsock;
+	bNodeProxyItem *item;
+	bNodeSocket *sock, *nextsock;
 	
 	/* step by step compare */
-	for (gsock= glb->first; gsock; gsock=gsock->next) {
+	
+	item = (in_out==SOCK_IN ? ngroup->proxy_inputs.first : ngroup->proxy_outputs.first);
+	for (; item; item=item->next) {
+		bNodeSocket *gsock = (in_out==SOCK_IN ? item->node->outputs.first : item->node->inputs.first);
 		/* abusing new_sock pointer for verification here! only used inside this function */
-		gsock->new_sock= group_verify_socket(ntree, lb, in_out, gsock);
+		gsock->new_sock = group_verify_socket(ntree, lb, in_out, gsock);
 	}
 	/* leftovers are removed */
 	for (sock=lb->first; sock; sock=nextsock) {
 		nextsock=sock->next;
 		if (sock->flag & SOCK_DYNAMIC)
-			nodeRemoveSocket(ntree, node, sock);
+			nodeRemoveSocket(ntree, gnode, sock);
 	}
 	/* and we put back the verified sockets */
-	for (gsock= glb->first; gsock; gsock=gsock->next) {
+	item = (in_out==SOCK_IN ? ngroup->proxy_inputs.first : ngroup->proxy_outputs.first);
+	for (; item; item=item->next) {
+		bNodeSocket *gsock = (in_out==SOCK_IN ? item->node->outputs.first : item->node->inputs.first);
 		if (gsock->new_sock) {
 			BLI_addtail(lb, gsock->new_sock);
 			gsock->new_sock = NULL;
@@ -595,8 +215,8 @@
 	/* check inputs and outputs, and remove or insert them */
 	if (node->id==id) {
 		bNodeTree *ngroup= (bNodeTree*)node->id;
-		group_verify_socket_list(ntree, node, &node->inputs, SOCK_IN, &ngroup->inputs);
-		group_verify_socket_list(ntree, node, &node->outputs, SOCK_OUT, &ngroup->outputs);
+		group_verify_socket_list(ntree, node, &node->inputs, SOCK_IN, ngroup);
+		group_verify_socket_list(ntree, node, &node->outputs, SOCK_OUT, ngroup);
 	}
 }
 
@@ -638,11 +258,7 @@
 			nodeGroupEditClear(inode);
 }
 
-void node_group_link(bNodeTree *ntree, bNodeSocket *sock, int in_out)
-{
-	node_group_expose_socket(ntree, sock, in_out);
-}
-
+#if 0
 /**** For Loop ****/
 
 /* Essentially a group node with slightly different behavior.
@@ -804,6 +420,7 @@
 	ntemp.ngroup = (bNodeTree*)node->id;
 	return ntemp;
 }
+#endif
 
 /**** FRAME ****/
 
@@ -819,3 +436,110 @@
 	ntype->needs_free = 1;
 	nodeRegisterType(ttype, ntype);
 }
+
+/**** PROXY_INPUT / PROXY_OUTPUT ****/
+
+static void node_proxy_input_init(bNodeTree *ntree, bNode *node, bNodeTemplate *UNUSED(ntemp))
+{
+	bNodeSocketType *stype;
+	bNodeSocket *sock;
+	
+	/* node tree input becomes output socket on the node */
+	stype = ntreeGetSocketType(SOCK_FLOAT);
+	sock = nodeAddSocket(ntree, node, SOCK_OUT, stype->ui_name, SOCK_FLOAT);
+	
+	/* assign new unique index */
+	sock->own_index = ntree->cur_index++;
+}
+
+static void node_proxy_input_copy(bNodeTree *dest_ntree, bNode *dest_node, bNode *UNUSED(src_node))
+{
+	/* socket has already been copied */
+	bNodeSocket *sock = (bNodeSocket*)dest_node->outputs.first;
+	
+	/* assign new unique index */
+	sock->own_index = dest_ntree->cur_index++;
+}
+
+static const char *node_proxy_input_label(bNode *node)
+{
+	bNodeSocket *sock = node->outputs.first;
+	return sock->name;
+}
+
+void register_node_type_proxy_input(struct bNodeTreeType *ttype)
+{
+	/* used for all tree types, needs dynamic allocation */
+	bNodeType *ntype= MEM_callocN(sizeof(bNodeType), "node type");
+	
+	node_type_base(ttype, ntype, NODE_PROXY_INPUT, "Proxy Input", NODE_CLASS_INPUT, NODE_OPTIONS);
+	node_type_size(ntype, 140, 80, 200);
+	node_type_init(ntype, node_proxy_input_init);
+	node_type_storage(ntype, NULL, NULL, node_proxy_input_copy);
+	node_type_compatibility(ntype, NODE_OLD_SHADING|NODE_NEW_SHADING);
+	node_type_label(ntype, node_proxy_input_label);
+	
+	ntype->needs_free = 1;
+	nodeRegisterType(ttype, ntype);
+}
+
+static void node_proxy_output_init(bNodeTree *ntree, bNode *node, bNodeTemplate *UNUSED(ntemp))
+{
+	bNodeSocketType *stype;
+	bNodeSocket *sock;
+	
+	/* node tree output becomes input socket on the node */
+	stype = ntreeGetSocketType(SOCK_FLOAT);
+	sock = nodeAddSocket(ntree, node, SOCK_IN, stype->ui_name, SOCK_FLOAT);
+	
+	/* assign new unique index */
+	sock->own_index = ntree->cur_index++;
+	
+	/* output proxy nodes automatically update type by default */
+	node->custom1 |= NODE_PROXY_AUTOTYPE;
+}
+
+static void node_proxy_output_copy(bNodeTree *dest_ntree, bNode *dest_node, bNode *UNUSED(src_node))
+{
+	/* socket has already been copied */
+	bNodeSocket *sock = (bNodeSocket*)dest_node->inputs.first;
+	
+	/* assign new unique index */
+	sock->own_index = dest_ntree->cur_index++;
+}
+
+static void node_proxy_output_update(bNodeTree *ntree, bNode *node)
+{
+	if (node->custom1 & NODE_PROXY_AUTOTYPE) {
+		/* automatically update the socket type based on linked input */
+		bNodeSocket *sock = (bNodeSocket*)node->inputs.first;
+		if (sock->link && sock->link->fromsock->type != sock->type) {
+			nodeSocketSetType(sock, sock->link->fromsock->type);
+			
+			ntree->update |= NTREE_UPDATE_GROUP_OUT;
+		}
+	}
+}
+
+static const char *node_proxy_output_label(bNode *node)
+{
+	bNodeSocket *sock = node->inputs.first;
+	return sock->name;
+}
+
+void register_node_type_proxy_output(struct bNodeTreeType *ttype)
+{
+	/* used for all tree types, needs dynamic allocation */
+	bNodeType *ntype= MEM_callocN(sizeof(bNodeType), "node type");
+	
+	node_type_base(ttype, ntype, NODE_PROXY_OUTPUT, "Proxy Output", NODE_CLASS_OUTPUT, NODE_OPTIONS);
+	node_type_size(ntype, 140, 80, 200);
+	node_type_init(ntype, node_proxy_output_init);
+	node_type_storage(ntype, NULL, NULL, node_proxy_output_copy);
+	node_type_compatibility(ntype, NODE_OLD_SHADING|NODE_NEW_SHADING);
+	node_type_label(ntype, node_proxy_output_label);
+	node_type_update(ntype, node_proxy_output_update, NULL);
+	
+	ntype->needs_free = 1;
+	nodeRegisterType(ttype, ntype);
+}