59a4d6818c83925cb3d9436bd7e57a55257645b9
[blender.git] / source / blender / nodes / intern / node_common.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version. 
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2007 Blender Foundation.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): Lukas Toenne.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/nodes/intern/node_common.c
29  *  \ingroup nodes
30  */
31
32
33 #include <string.h>
34
35 #include "DNA_node_types.h"
36
37 #include "BLI_listbase.h"
38 #include "BLI_string.h"
39 #include "BLI_utildefines.h"
40
41 #include "BLF_translation.h"
42
43 #include "BKE_global.h"
44 #include "BKE_library.h"
45 #include "BKE_main.h"
46 #include "BLI_math.h"
47 #include "BKE_node.h"
48
49 #include "RNA_access.h"
50 #include "RNA_types.h"
51
52 #include "MEM_guardedalloc.h"
53
54 #include "node_common.h"
55 #include "node_util.h"
56 #include "node_exec.h"
57 #include "NOD_socket.h"
58
59 /**** Group ****/
60
61 bNodeSocket *node_group_find_input(bNode *gnode, bNodeSocket *gsock)
62 {
63         bNodeSocket *sock;
64         for (sock=gnode->inputs.first; sock; sock=sock->next)
65                 if (sock->groupsock == gsock)
66                         return sock;
67         return NULL;
68 }
69
70 bNodeSocket *node_group_find_output(bNode *gnode, bNodeSocket *gsock)
71 {
72         bNodeSocket *sock;
73         for (sock=gnode->outputs.first; sock; sock=sock->next)
74                 if (sock->groupsock == gsock)
75                         return sock;
76         return NULL;
77 }
78
79 bNodeSocket *node_group_add_extern_socket(bNodeTree *UNUSED(ntree), ListBase *lb, int in_out, bNodeSocket *gsock)
80 {
81         bNodeSocket *sock;
82         
83         if (gsock->flag & SOCK_INTERNAL)
84                 return NULL;
85         
86         sock= MEM_callocN(sizeof(bNodeSocket), "sock");
87         
88         /* make a copy of the group socket */
89         *sock = *gsock;
90         sock->link = NULL;
91         sock->next = sock->prev = NULL;
92         sock->new_sock = NULL;
93         
94         /* group sockets are dynamically added */
95         sock->flag |= SOCK_DYNAMIC;
96         
97         sock->own_index = gsock->own_index;
98         sock->groupsock = gsock;
99         sock->limit = (in_out==SOCK_IN ? 1 : 0xFFF);
100         
101         sock->default_value = node_socket_make_default_value(sock->type);
102         node_socket_copy_default_value(sock->type, sock->default_value, gsock->default_value);
103         
104         if (lb)
105                 BLI_addtail(lb, sock);
106         
107         return sock;
108 }
109
110 bNodeSocket *node_group_add_socket(bNodeTree *ngroup, const char *name, int type, int in_out)
111 {
112         bNodeSocketType *stype = ntreeGetSocketType(type);
113         bNodeSocket *gsock = MEM_callocN(sizeof(bNodeSocket), "bNodeSocket");
114         
115         BLI_strncpy(gsock->name, name, sizeof(gsock->name));
116         gsock->type = type;
117         /* group sockets are dynamically added */
118         gsock->flag |= SOCK_DYNAMIC;
119
120         gsock->next = gsock->prev = NULL;
121         gsock->new_sock = NULL;
122         gsock->link = NULL;
123         /* assign new unique index */
124         gsock->own_index = ngroup->cur_index++;
125         gsock->limit = (in_out==SOCK_IN ? 0xFFF : 1);
126         
127         if (stype->value_structsize > 0)
128                 gsock->default_value = MEM_callocN(stype->value_structsize, "default socket value");
129         
130         BLI_addtail(in_out==SOCK_IN ? &ngroup->inputs : &ngroup->outputs, gsock);
131         
132         ngroup->update |= (in_out==SOCK_IN ? NTREE_UPDATE_GROUP_IN : NTREE_UPDATE_GROUP_OUT);
133         
134         return gsock;
135 }
136
137 bNodeSocket *node_group_expose_socket(bNodeTree *ngroup, bNodeSocket *sock, int in_out)
138 {
139         bNodeSocket *gsock= node_group_add_socket(ngroup, sock->name, sock->type, in_out);
140         
141         /* initialize the default value. */
142         node_socket_copy_default_value(gsock->type, gsock->default_value, sock->default_value);
143         
144         return gsock;
145 }
146
147 void node_group_expose_all_sockets(bNodeTree *ngroup)
148 {
149         bNode *node;
150         bNodeSocket *sock, *gsock;
151         
152         for (node=ngroup->nodes.first; node; node=node->next) {
153                 for (sock=node->inputs.first; sock; sock=sock->next) {
154                         if (!sock->link && !nodeSocketIsHidden(sock)) {
155                                 gsock = node_group_add_socket(ngroup, sock->name, sock->type, SOCK_IN);
156                                 
157                                 /* initialize the default value. */
158                                 node_socket_copy_default_value(gsock->type, gsock->default_value, sock->default_value);
159                                 
160                                 sock->link = nodeAddLink(ngroup, NULL, gsock, node, sock);
161                         }
162                 }
163                 for (sock=node->outputs.first; sock; sock=sock->next) {
164                         if (nodeCountSocketLinks(ngroup, sock)==0 && !nodeSocketIsHidden(sock)) {
165                                 gsock = node_group_add_socket(ngroup, sock->name, sock->type, SOCK_OUT);
166                                 
167                                 /* initialize the default value. */
168                                 node_socket_copy_default_value(gsock->type, gsock->default_value, sock->default_value);
169                                 
170                                 gsock->link = nodeAddLink(ngroup, node, sock, NULL, gsock);
171                         }
172                 }
173         }
174 }
175
176 void node_group_remove_socket(bNodeTree *ngroup, bNodeSocket *gsock, int in_out)
177 {
178         nodeRemSocketLinks(ngroup, gsock);
179         
180         switch (in_out) {
181         case SOCK_IN:
182                 BLI_remlink(&ngroup->inputs, gsock);
183                 ngroup->update |= NTREE_UPDATE_GROUP_IN;
184                 break;
185         case SOCK_OUT:
186                 BLI_remlink(&ngroup->outputs, gsock);
187                 ngroup->update |= NTREE_UPDATE_GROUP_OUT;
188                 break;
189         }
190         
191         if (gsock->default_value)
192                 MEM_freeN(gsock->default_value);
193         
194         MEM_freeN(gsock);
195 }
196
197 /* groups display their internal tree name as label */
198 const char *node_group_label(bNode *node)
199 {
200         return (node->id)? node->id->name+2: IFACE_("Missing Datablock");
201 }
202
203 int node_group_valid(bNodeTree *ntree, bNodeTemplate *ntemp)
204 {
205         bNodeTemplate childtemp;
206         bNode *node;
207         
208         /* regular groups cannot be recursive */
209         if (ntree == ntemp->ngroup)
210                 return 0;
211         
212         /* make sure all children are valid */
213         for (node=ntemp->ngroup->nodes.first; node; node=node->next) {
214                 childtemp = nodeMakeTemplate(node);
215                 if (!nodeValid(ntree, &childtemp))
216                         return 0;
217         }
218         
219         return 1;
220 }
221
222 bNodeTemplate node_group_template(bNode *node)
223 {
224         bNodeTemplate ntemp;
225         ntemp.type = NODE_GROUP;
226         ntemp.ngroup = (bNodeTree*)node->id;
227         return ntemp;
228 }
229
230 void node_group_init(bNodeTree *ntree, bNode *node, bNodeTemplate *ntemp)
231 {
232         node->id = (ID*)ntemp->ngroup;
233         
234         /* NB: group socket input/output roles are inverted internally!
235          * Group "inputs" work as outputs in links and vice versa.
236          */
237         if (ntemp->ngroup) {
238                 bNodeSocket *gsock;
239                 for (gsock=ntemp->ngroup->inputs.first; gsock; gsock=gsock->next)
240                         node_group_add_extern_socket(ntree, &node->inputs, SOCK_IN, gsock);
241                 for (gsock=ntemp->ngroup->outputs.first; gsock; gsock=gsock->next)
242                         node_group_add_extern_socket(ntree, &node->outputs, SOCK_OUT, gsock);
243         }
244 }
245
246 static bNodeSocket *group_verify_socket(bNodeTree *ntree, ListBase *lb, int in_out, bNodeSocket *gsock)
247 {
248         bNodeSocket *sock;
249         
250         /* group sockets tagged as internal are not exposed ever */
251         if (gsock->flag & SOCK_INTERNAL)
252                 return NULL;
253         
254         for (sock= lb->first; sock; sock= sock->next) {
255                 if (sock->own_index==gsock->own_index)
256                                 break;
257         }
258         if (sock) {
259                 sock->groupsock = gsock;
260                 
261                 BLI_strncpy(sock->name, gsock->name, sizeof(sock->name));
262                 if (gsock->type != sock->type)
263                         nodeSocketSetType(sock, gsock->type);
264                 
265                 /* XXX hack: group socket input/output roles are inverted internally,
266                  * need to change the limit value when making actual node sockets from them.
267                  */
268                 sock->limit = (in_out==SOCK_IN ? 1 : 0xFFF);
269                 
270                 BLI_remlink(lb, sock);
271                 
272                 return sock;
273         }
274         else {
275                 return node_group_add_extern_socket(ntree, NULL, in_out, gsock);
276         }
277 }
278
279 static void group_verify_socket_list(bNodeTree *ntree, bNode *node, ListBase *lb, int in_out, ListBase *glb)
280 {
281         bNodeSocket *sock, *nextsock, *gsock;
282         
283         /* step by step compare */
284         for (gsock= glb->first; gsock; gsock=gsock->next) {
285                 /* abusing new_sock pointer for verification here! only used inside this function */
286                 gsock->new_sock= group_verify_socket(ntree, lb, in_out, gsock);
287         }
288         /* leftovers are removed */
289         for (sock=lb->first; sock; sock=nextsock) {
290                 nextsock=sock->next;
291                 if (sock->flag & SOCK_DYNAMIC)
292                         nodeRemoveSocket(ntree, node, sock);
293         }
294         /* and we put back the verified sockets */
295         for (gsock= glb->first; gsock; gsock=gsock->next) {
296                 if (gsock->new_sock) {
297                         BLI_addtail(lb, gsock->new_sock);
298                         gsock->new_sock = NULL;
299                 }
300         }
301 }
302
303 /* make sure all group node in ntree, which use ngroup, are sync'd */
304 void node_group_verify(struct bNodeTree *ntree, struct bNode *node, struct ID *id)
305 {
306         /* check inputs and outputs, and remove or insert them */
307         if (node->id==id) {
308                 bNodeTree *ngroup= (bNodeTree*)node->id;
309                 group_verify_socket_list(ntree, node, &node->inputs, SOCK_IN, &ngroup->inputs);
310                 group_verify_socket_list(ntree, node, &node->outputs, SOCK_OUT, &ngroup->outputs);
311         }
312 }
313
314 struct bNodeTree *node_group_edit_get(bNode *node)
315 {
316         if (node->flag & NODE_GROUP_EDIT)
317                 return (bNodeTree*)node->id;
318         else
319                 return NULL;
320 }
321
322 struct bNodeTree *node_group_edit_set(bNode *node, int edit)
323 {
324         if (edit) {
325                 bNodeTree *ngroup= (bNodeTree*)node->id;
326                 if (ngroup) {
327                         if (ngroup->id.lib)
328                                 ntreeMakeLocal(ngroup);
329                         
330                         node->flag |= NODE_GROUP_EDIT;
331                 }
332                 return ngroup;
333         }
334         else {
335                 node->flag &= ~NODE_GROUP_EDIT;
336                 return NULL;
337         }
338 }
339
340 void node_group_edit_clear(bNode *node)
341 {
342         bNodeTree *ngroup= (bNodeTree*)node->id;
343         bNode *inode;
344         
345         node->flag &= ~NODE_GROUP_EDIT;
346         
347         if (ngroup)
348                 for (inode=ngroup->nodes.first; inode; inode=inode->next)
349                         nodeGroupEditClear(inode);
350 }
351
352 static void UNUSED_FUNCTION(node_group_link)(bNodeTree *ntree, bNodeSocket *sock, int in_out)
353 {
354         node_group_expose_socket(ntree, sock, in_out);
355 }
356
357 /**** For Loop ****/
358
359 /* Essentially a group node with slightly different behavior.
360  * The internal tree is executed several times, with each output being re-used
361  * as an input in the next iteration. For this purpose, input and output socket
362  * lists are kept identical!
363  */
364
365 bNodeTemplate node_forloop_template(bNode *node)
366 {
367         bNodeTemplate ntemp;
368         ntemp.type = NODE_FORLOOP;
369         ntemp.ngroup = (bNodeTree*)node->id;
370         return ntemp;
371 }
372
373 void node_forloop_init(bNodeTree *ntree, bNode *node, bNodeTemplate *ntemp)
374 {
375         bNodeSocket *sock;
376         
377         node->id = (ID*)ntemp->ngroup;
378         
379         sock = nodeAddSocket(ntree, node, SOCK_IN, "Iterations", SOCK_FLOAT);
380         node_socket_set_default_value_float(sock->default_value, PROP_UNSIGNED, 1, 0, 10000);
381         
382         /* NB: group socket input/output roles are inverted internally!
383          * Group "inputs" work as outputs in links and vice versa.
384          */
385         if (ntemp->ngroup) {
386                 bNodeSocket *gsock;
387                 for (gsock=ntemp->ngroup->inputs.first; gsock; gsock=gsock->next)
388                         node_group_add_extern_socket(ntree, &node->inputs, SOCK_IN, gsock);
389                 for (gsock=ntemp->ngroup->outputs.first; gsock; gsock=gsock->next)
390                         node_group_add_extern_socket(ntree, &node->outputs, SOCK_OUT, gsock);
391         }
392 }
393
394 void node_forloop_init_tree(bNodeTree *ntree)
395 {
396         bNodeSocket *sock;
397         sock = node_group_add_socket(ntree, "Iteration", SOCK_FLOAT, SOCK_IN);
398         sock->flag |= SOCK_INTERNAL;
399 }
400
401 static void loop_sync(bNodeTree *ntree, int sync_in_out)
402 {
403         bNodeSocket *sock, *sync, *nsync, *mirror;
404         ListBase *sync_lb;
405         
406         if (sync_in_out==SOCK_IN) {
407                 sock = ntree->outputs.first;
408                 
409                 sync = ntree->inputs.first;
410                 sync_lb = &ntree->inputs;
411         }
412         else {
413                 sock = ntree->inputs.first;
414                 
415                 sync = ntree->outputs.first;
416                 sync_lb = &ntree->outputs;
417         }
418         
419         /* NB: the sock->storage pointer is used here directly to store the own_index int
420          * out the mirrored socket counterpart!
421          */
422         
423         while (sock) {
424                 /* skip static and internal sockets on the sync side (preserves socket order!) */
425                 while (sync && ((sync->flag & SOCK_INTERNAL) || !(sync->flag & SOCK_DYNAMIC)))
426                         sync = sync->next;
427                 
428                 if (sync && !(sync->flag & SOCK_INTERNAL) && (sync->flag & SOCK_DYNAMIC)) {
429                         if (sock->storage==NULL) {
430                                 /* if mirror index is 0, the sockets is newly added and a new mirror must be created. */
431                                 mirror = node_group_expose_socket(ntree, sock, sync_in_out);
432                                 /* store the mirror index */
433                                 sock->storage = SET_INT_IN_POINTER(mirror->own_index);
434                                 mirror->storage = SET_INT_IN_POINTER(sock->own_index);
435                                 /* move mirror to the right place */
436                                 BLI_remlink(sync_lb, mirror);
437                                 if (sync)
438                                         BLI_insertlinkbefore(sync_lb, sync, mirror);
439                                 else
440                                         BLI_addtail(sync_lb, mirror);
441                         }
442                         else {
443                                 /* look up the mirror socket */
444                                 for (mirror=sync; mirror; mirror=mirror->next)
445                                         if (mirror->own_index == GET_INT_FROM_POINTER(sock->storage))
446                                                 break;
447                                 /* make sure the name is the same (only for identification by user, no deeper meaning) */
448                                 BLI_strncpy(mirror->name, sock->name, sizeof(mirror->name));
449                                 /* fix the socket order if necessary */
450                                 if (mirror != sync) {
451                                         BLI_remlink(sync_lb, mirror);
452                                         BLI_insertlinkbefore(sync_lb, sync, mirror);
453                                 }
454                                 else
455                                         sync = sync->next;
456                         }
457                 }
458                 
459                 sock = sock->next;
460         }
461         
462         /* remaining sockets in sync_lb are leftovers from deleted sockets, remove them */
463         while (sync) {
464                 nsync = sync->next;
465                 if (!(sync->flag & SOCK_INTERNAL) && (sync->flag & SOCK_DYNAMIC))
466                         node_group_remove_socket(ntree, sync, sync_in_out);
467                 sync = nsync;
468         }
469 }
470
471 void node_loop_update_tree(bNodeTree *ngroup)
472 {
473         /* make sure inputs & outputs are identical */
474         if (ngroup->update & NTREE_UPDATE_GROUP_IN)
475                 loop_sync(ngroup, SOCK_OUT);
476         if (ngroup->update & NTREE_UPDATE_GROUP_OUT)
477                 loop_sync(ngroup, SOCK_IN);
478 }
479
480 void node_whileloop_init(bNodeTree *ntree, bNode *node, bNodeTemplate *ntemp)
481 {
482         bNodeSocket *sock;
483         
484         node->id = (ID*)ntemp->ngroup;
485         
486         sock = nodeAddSocket(ntree, node, SOCK_IN, "Condition", SOCK_FLOAT);
487         node_socket_set_default_value_float(sock->default_value, PROP_NONE, 1, 0, 1);
488         
489         /* max iterations */
490         node->custom1 = 10000;
491         
492         /* NB: group socket input/output roles are inverted internally!
493          * Group "inputs" work as outputs in links and vice versa.
494          */
495         if (ntemp->ngroup) {
496                 bNodeSocket *gsock;
497                 for (gsock=ntemp->ngroup->inputs.first; gsock; gsock=gsock->next)
498                         node_group_add_extern_socket(ntree, &node->inputs, SOCK_IN, gsock);
499                 for (gsock=ntemp->ngroup->outputs.first; gsock; gsock=gsock->next)
500                         node_group_add_extern_socket(ntree, &node->outputs, SOCK_OUT, gsock);
501         }
502 }
503
504 void node_whileloop_init_tree(bNodeTree *ntree)
505 {
506         bNodeSocket *sock;
507         sock = node_group_add_socket(ntree, "Condition", SOCK_FLOAT, SOCK_OUT);
508         sock->flag |= SOCK_INTERNAL;
509 }
510
511 bNodeTemplate node_whileloop_template(bNode *node)
512 {
513         bNodeTemplate ntemp;
514         ntemp.type = NODE_WHILELOOP;
515         ntemp.ngroup = (bNodeTree*)node->id;
516         return ntemp;
517 }
518
519 /**** FRAME ****/
520
521 static void node_frame_init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp))
522 {
523         NodeFrame *data = (NodeFrame *)MEM_callocN(sizeof(NodeFrame), "frame node storage");
524         node->storage = data;
525         
526         data->flag |= NODE_FRAME_SHRINK;
527         
528         data->label_size = 20;
529 }
530
531 void register_node_type_frame(bNodeTreeType *ttype)
532 {
533         /* frame type is used for all tree types, needs dynamic allocation */
534         bNodeType *ntype= MEM_callocN(sizeof(bNodeType), "frame node type");
535
536         node_type_base(ttype, ntype, NODE_FRAME, "Frame", NODE_CLASS_LAYOUT, NODE_BACKGROUND|NODE_OPTIONS);
537         node_type_init(ntype, node_frame_init);
538         node_type_storage(ntype, "NodeFrame", node_free_standard_storage, node_copy_standard_storage);
539         node_type_size(ntype, 150, 100, 0);
540         node_type_compatibility(ntype, NODE_OLD_SHADING|NODE_NEW_SHADING);
541         
542         ntype->needs_free = 1;
543         nodeRegisterType(ttype, ntype);
544 }
545
546
547 /* **************** REROUTE ******************** */
548
549 /* simple, only a single input and output here */
550 static ListBase node_reroute_internal_connect(bNodeTree *ntree, bNode *node)
551 {
552         bNodeLink *link;
553         ListBase ret;
554
555         ret.first = ret.last = NULL;
556
557         /* Security check! */
558         if (!ntree)
559                 return ret;
560
561         link = MEM_callocN(sizeof(bNodeLink), "internal node link");
562         link->fromnode = node;
563         link->fromsock = node->inputs.first;
564         link->tonode = node;
565         link->tosock = node->outputs.first;
566         /* internal link is always valid */
567         link->flag |= NODE_LINK_VALID;
568         BLI_addtail(&ret, link);
569
570         return ret;
571 }
572
573 static void node_reroute_init(bNodeTree *ntree, bNode *node, bNodeTemplate *UNUSED(ntemp))
574 {
575         /* Note: Cannot use socket templates for this, since it would reset the socket type
576          * on each file read via the template verification procedure.
577          */
578         nodeAddSocket(ntree, node, SOCK_IN, "Input", SOCK_RGBA);
579         nodeAddSocket(ntree, node, SOCK_OUT, "Output", SOCK_RGBA);
580 }
581
582 void register_node_type_reroute(bNodeTreeType *ttype)
583 {
584         /* frame type is used for all tree types, needs dynamic allocation */
585         bNodeType *ntype= MEM_callocN(sizeof(bNodeType), "frame node type");
586         
587         node_type_base(ttype, ntype, NODE_REROUTE, "Reroute", NODE_CLASS_LAYOUT, 0);
588         node_type_init(ntype, node_reroute_init);
589         node_type_internal_connect(ntype, node_reroute_internal_connect);
590         
591         ntype->needs_free = 1;
592         nodeRegisterType(ttype, ntype);
593 }
594
595 static void node_reroute_inherit_type_recursive(bNodeTree *ntree, bNode *node)
596 {
597         bNodeSocket *input = node->inputs.first;
598         bNodeSocket *output = node->outputs.first;
599         int type = SOCK_FLOAT;
600         bNodeLink *link;
601         
602         /* XXX it would be a little bit more efficient to restrict actual updates
603          * to rerout nodes connected to an updated node, but there's no reliable flag
604          * to indicate updated nodes (node->update is not set on linking).
605          */
606         
607         node->done = 1;
608         
609         /* recursive update */
610         for (link = ntree->links.first; link; link = link->next)
611         {
612                 bNode *fromnode = link->fromnode;
613                 bNode *tonode = link->tonode;
614                 if (!tonode || !fromnode)
615                         continue;
616                 
617                 if (tonode == node && fromnode->type == NODE_REROUTE && !fromnode->done)
618                         node_reroute_inherit_type_recursive(ntree, fromnode);
619                 
620                 if (fromnode == node && tonode->type == NODE_REROUTE && !tonode->done)
621                         node_reroute_inherit_type_recursive(ntree, tonode);
622         }
623         
624         /* determine socket type from unambiguous input/output connection if possible */
625         if (input->limit==1 && input->link)
626                 type = input->link->fromsock->type;
627         else if (output->limit==1 && output->link)
628                 type = output->link->tosock->type;
629         
630         /* arbitrary, could also test output->type, both are the same */
631         if (input->type != type) {
632                 /* same type for input/output */
633                 nodeSocketSetType(input, type);
634                 nodeSocketSetType(output, type);
635         }
636 }
637
638 /* Global update function for Reroute node types.
639  * This depends on connected nodes, so must be done as a tree-wide update.
640  */
641 void ntree_update_reroute_nodes(bNodeTree *ntree)
642 {
643         bNode *node;
644         
645         /* clear tags */
646         for (node = ntree->nodes.first; node; node = node->next)
647                 node->done = 0;
648         
649         for (node = ntree->nodes.first; node; node = node->next)
650                 if (node->type == NODE_REROUTE && !node->done)
651                         node_reroute_inherit_type_recursive(ntree, node);
652 }