13882d631d80d54bac4e674234d4dc0e4a8f43f2
[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_action_types.h"
36 #include "DNA_anim_types.h"
37 #include "DNA_node_types.h"
38
39 #include "BLI_listbase.h"
40 #include "BLI_string.h"
41 #include "BLI_utildefines.h"
42
43 #include "BLF_translation.h"
44
45 #include "BKE_action.h"
46 #include "BKE_animsys.h"
47 #include "BKE_global.h"
48 #include "BKE_library.h"
49 #include "BKE_main.h"
50 #include "BLI_math.h"
51 #include "BKE_node.h"
52 #include "BKE_utildefines.h"
53
54 #include "RNA_access.h"
55 #include "RNA_types.h"
56
57 #include "MEM_guardedalloc.h"
58
59 #include "node_common.h"
60 #include "node_exec.h"
61 #include "NOD_socket.h"
62
63 /**** Group ****/
64
65 bNodeSocket *node_group_find_input(bNode *gnode, bNodeSocket *gsock)
66 {
67         bNodeSocket *sock;
68         for (sock=gnode->inputs.first; sock; sock=sock->next)
69                 if (sock->groupsock == gsock)
70                         return sock;
71         return NULL;
72 }
73
74 bNodeSocket *node_group_find_output(bNode *gnode, bNodeSocket *gsock)
75 {
76         bNodeSocket *sock;
77         for (sock=gnode->outputs.first; sock; sock=sock->next)
78                 if (sock->groupsock == gsock)
79                         return sock;
80         return NULL;
81 }
82
83 bNodeSocket *node_group_add_extern_socket(bNodeTree *UNUSED(ntree), ListBase *lb, int in_out, bNodeSocket *gsock)
84 {
85         bNodeSocket *sock;
86         
87         if (gsock->flag & SOCK_INTERNAL)
88                 return NULL;
89         
90         sock= MEM_callocN(sizeof(bNodeSocket), "sock");
91         
92         /* make a copy of the group socket */
93         *sock = *gsock;
94         sock->link = NULL;
95         sock->next = sock->prev = NULL;
96         sock->new_sock = NULL;
97         
98         /* group sockets are dynamically added */
99         sock->flag |= SOCK_DYNAMIC;
100         
101         sock->own_index = gsock->own_index;
102         sock->groupsock = gsock;
103         sock->limit = (in_out==SOCK_IN ? 1 : 0xFFF);
104         
105         sock->default_value = node_socket_make_default_value(sock->type);
106         node_socket_copy_default_value(sock->type, sock->default_value, gsock->default_value);
107         
108         if (lb)
109                 BLI_addtail(lb, sock);
110         
111         return sock;
112 }
113
114 bNode *node_group_make_from_selected(bNodeTree *ntree)
115 {
116         bNodeLink *link, *linkn;
117         bNode *node, *gnode, *nextn;
118         bNodeTree *ngroup;
119         bNodeSocket *gsock;
120         ListBase anim_basepaths = {NULL, NULL};
121         float min[2], max[2];
122         int totnode=0;
123         bNodeTemplate ntemp;
124         
125         INIT_MINMAX2(min, max);
126         
127         /* is there something to group? also do some clearing */
128         for (node= ntree->nodes.first; node; node= node->next) {
129                 if (node->flag & NODE_SELECT) {
130                         /* no groups in groups */
131                         if (node->type==NODE_GROUP)
132                                 return NULL;
133                         DO_MINMAX2((&node->locx), min, max);
134                         totnode++;
135                 }
136                 node->done= 0;
137         }
138         if (totnode==0) return NULL;
139         
140         /* check if all connections are OK, no unselected node has both
141          * inputs and outputs to a selection */
142         for (link= ntree->links.first; link; link= link->next) {
143                 if (link->fromnode && link->tonode && link->fromnode->flag & NODE_SELECT)
144                         link->tonode->done |= 1;
145                 if (link->fromnode && link->tonode && link->tonode->flag & NODE_SELECT)
146                         link->fromnode->done |= 2;
147         }       
148         
149         for (node= ntree->nodes.first; node; node= node->next) {
150                 if ((node->flag & NODE_SELECT)==0)
151                         if (node->done==3)
152                                 break;
153         }
154         if (node) 
155                 return NULL;
156         
157         /* OK! new nodetree */
158         ngroup= ntreeAddTree("NodeGroup", ntree->type, NODE_GROUP);
159         
160         /* move nodes over */
161         for (node= ntree->nodes.first; node; node= nextn) {
162                 nextn= node->next;
163                 if (node->flag & NODE_SELECT) {
164                         /* keep track of this node's RNA "base" path (the part of the pat identifying the node) 
165                          * if the old nodetree has animation data which potentially covers this node
166                          */
167                         if (ntree->adt) {
168                                 PointerRNA ptr;
169                                 char *path;
170                                 
171                                 RNA_pointer_create(&ntree->id, &RNA_Node, node, &ptr);
172                                 path = RNA_path_from_ID_to_struct(&ptr);
173                                 
174                                 if (path)
175                                         BLI_addtail(&anim_basepaths, BLI_genericNodeN(path));
176                         }
177                         
178                         /* change node-collection membership */
179                         BLI_remlink(&ntree->nodes, node);
180                         BLI_addtail(&ngroup->nodes, node);
181                         
182                         node->locx-= 0.5f*(min[0]+max[0]);
183                         node->locy-= 0.5f*(min[1]+max[1]);
184                 }
185         }
186
187         /* move animation data over */
188         if (ntree->adt) {
189                 LinkData *ld, *ldn=NULL;
190                 
191                 BKE_animdata_separate_by_basepath(&ntree->id, &ngroup->id, &anim_basepaths);
192                 
193                 /* paths + their wrappers need to be freed */
194                 for (ld = anim_basepaths.first; ld; ld = ldn) {
195                         ldn = ld->next;
196                         
197                         MEM_freeN(ld->data);
198                         BLI_freelinkN(&anim_basepaths, ld);
199                 }
200         }
201         
202         /* node groups don't use internal cached data */
203         ntreeFreeCache(ngroup);
204         
205         /* make group node */
206         ntemp.type = NODE_GROUP;
207         ntemp.ngroup = ngroup;
208         gnode= nodeAddNode(ntree, &ntemp);
209         gnode->locx= 0.5f*(min[0]+max[0]);
210         gnode->locy= 0.5f*(min[1]+max[1]);
211         
212         /* relink external sockets */
213         for (link= ntree->links.first; link; link= linkn) {
214                 linkn= link->next;
215                 
216                 if (link->fromnode && link->tonode && (link->fromnode->flag & link->tonode->flag & NODE_SELECT)) {
217                         BLI_remlink(&ntree->links, link);
218                         BLI_addtail(&ngroup->links, link);
219                 }
220                 else if (link->tonode && (link->tonode->flag & NODE_SELECT)) {
221                         gsock = node_group_expose_socket(ngroup, link->tosock, SOCK_IN);
222                         link->tosock->link = nodeAddLink(ngroup, NULL, gsock, link->tonode, link->tosock);
223                         link->tosock = node_group_add_extern_socket(ntree, &gnode->inputs, SOCK_IN, gsock);
224                         link->tonode = gnode;
225                 }
226                 else if (link->fromnode && (link->fromnode->flag & NODE_SELECT)) {
227                         /* search for existing group node socket */
228                         for (gsock=ngroup->outputs.first; gsock; gsock=gsock->next)
229                                 if (gsock->link && gsock->link->fromsock==link->fromsock)
230                                         break;
231                         if (!gsock) {
232                                 gsock = node_group_expose_socket(ngroup, link->fromsock, SOCK_OUT);
233                                 gsock->link = nodeAddLink(ngroup, link->fromnode, link->fromsock, NULL, gsock);
234                                 link->fromsock = node_group_add_extern_socket(ntree, &gnode->outputs, SOCK_OUT, gsock);
235                         }
236                         else
237                                 link->fromsock = node_group_find_output(gnode, gsock);
238                         link->fromnode = gnode;
239                 }
240         }
241
242         /* update of the group tree */
243         ngroup->update |= NTREE_UPDATE;
244         ntreeUpdateTree(ngroup);
245         /* update of the tree containing the group instance node */
246         ntree->update |= NTREE_UPDATE_NODES | NTREE_UPDATE_LINKS;
247         ntreeUpdateTree(ntree);
248
249         return gnode;
250 }
251
252 /* returns 1 if its OK */
253 int node_group_ungroup(bNodeTree *ntree, bNode *gnode)
254 {
255         bNodeLink *link, *linkn;
256         bNode *node, *nextn;
257         bNodeTree *ngroup, *wgroup;
258         ListBase anim_basepaths = {NULL, NULL};
259         
260         ngroup= (bNodeTree *)gnode->id;
261         if (ngroup==NULL) return 0;
262         
263         /* clear new pointers, set in copytree */
264         for (node= ntree->nodes.first; node; node= node->next)
265                 node->new_node= NULL;
266         
267         /* wgroup is a temporary copy of the NodeTree we're merging in
268          *      - all of wgroup's nodes are transferred across to their new home
269          *      - ngroup (i.e. the source NodeTree) is left unscathed
270          */
271         wgroup= ntreeCopyTree(ngroup);
272         
273         /* add the nodes into the ntree */
274         for (node= wgroup->nodes.first; node; node= nextn) {
275                 nextn= node->next;
276                 
277                 /* keep track of this node's RNA "base" path (the part of the pat identifying the node) 
278                  * if the old nodetree has animation data which potentially covers this node
279                  */
280                 if (wgroup->adt) {
281                         PointerRNA ptr;
282                         char *path;
283                         
284                         RNA_pointer_create(&wgroup->id, &RNA_Node, node, &ptr);
285                         path = RNA_path_from_ID_to_struct(&ptr);
286                         
287                         if (path)
288                                 BLI_addtail(&anim_basepaths, BLI_genericNodeN(path));
289                 }
290                 
291                 /* migrate node */
292                 BLI_remlink(&wgroup->nodes, node);
293                 BLI_addtail(&ntree->nodes, node);
294                 
295                 node->locx+= gnode->locx;
296                 node->locy+= gnode->locy;
297                 
298                 node->flag |= NODE_SELECT;
299         }
300         
301         /* restore external links to and from the gnode */
302         for (link= ntree->links.first; link; link= link->next) {
303                 if (link->fromnode==gnode) {
304                         if (link->fromsock->groupsock) {
305                                 bNodeSocket *gsock= link->fromsock->groupsock;
306                                 if (gsock->link) {
307                                         if (gsock->link->fromnode) {
308                                                 /* NB: using the new internal copies here! the groupsock pointer still maps to the old tree */
309                                                 link->fromnode = (gsock->link->fromnode ? gsock->link->fromnode->new_node : NULL);
310                                                 link->fromsock = gsock->link->fromsock->new_sock;
311                                         }
312                                         else {
313                                                 /* group output directly maps to group input */
314                                                 bNodeSocket *insock= node_group_find_input(gnode, gsock->link->fromsock);
315                                                 if (insock->link) {
316                                                         link->fromnode = insock->link->fromnode;
317                                                         link->fromsock = insock->link->fromsock;
318                                                 }
319                                         }
320                                 }
321                                 else {
322                                         /* copy the default input value from the group socket default to the external socket */
323                                         node_socket_convert_default_value(link->tosock->type, link->tosock->default_value, gsock->type, gsock->default_value);
324                                 }
325                         }
326                 }
327         }
328         /* remove internal output links, these are not used anymore */
329         for (link=wgroup->links.first; link; link= linkn) {
330                 linkn = link->next;
331                 if (!link->tonode)
332                         nodeRemLink(wgroup, link);
333         }
334         /* restore links from internal nodes */
335         for (link= wgroup->links.first; link; link= link->next) {
336                 /* indicates link to group input */
337                 if (!link->fromnode) {
338                         /* NB: can't use find_group_node_input here,
339                          * because gnode sockets still point to the old tree!
340                          */
341                         bNodeSocket *insock;
342                         for (insock= gnode->inputs.first; insock; insock= insock->next)
343                                 if (insock->groupsock->new_sock == link->fromsock)
344                                         break;
345                         if (insock->link) {
346                                 link->fromnode = insock->link->fromnode;
347                                 link->fromsock = insock->link->fromsock;
348                         }
349                         else {
350                                 /* copy the default input value from the group node socket default to the internal socket */
351                                 node_socket_convert_default_value(link->tosock->type, link->tosock->default_value, insock->type, insock->default_value);
352                                 nodeRemLink(wgroup, link);
353                         }
354                 }
355         }
356         
357         /* add internal links to the ntree */
358         for (link= wgroup->links.first; link; link= linkn) {
359                 linkn= link->next;
360                 BLI_remlink(&wgroup->links, link);
361                 BLI_addtail(&ntree->links, link);
362         }
363         
364         /* and copy across the animation,
365          * note that the animation data's action can be NULL here */
366         if (wgroup->adt) {
367                 LinkData *ld, *ldn=NULL;
368                 bAction *waction;
369                 
370                 /* firstly, wgroup needs to temporary dummy action that can be destroyed, as it shares copies */
371                 waction = wgroup->adt->action = copy_action(wgroup->adt->action);
372                 
373                 /* now perform the moving */
374                 BKE_animdata_separate_by_basepath(&wgroup->id, &ntree->id, &anim_basepaths);
375                 
376                 /* paths + their wrappers need to be freed */
377                 for (ld = anim_basepaths.first; ld; ld = ldn) {
378                         ldn = ld->next;
379                         
380                         MEM_freeN(ld->data);
381                         BLI_freelinkN(&anim_basepaths, ld);
382                 }
383                 
384                 /* free temp action too */
385                 if (waction) {
386                         free_libblock(&G.main->action, waction);
387                 }
388         }
389         
390         /* delete the group instance. this also removes old input links! */
391         nodeFreeNode(ntree, gnode);
392
393         /* free the group tree (takes care of user count) */
394         free_libblock(&G.main->nodetree, wgroup);
395         
396         ntree->update |= NTREE_UPDATE_NODES | NTREE_UPDATE_LINKS;
397         ntreeUpdateTree(ntree);
398         
399         return 1;
400 }
401
402 bNodeSocket *node_group_add_socket(bNodeTree *ngroup, const char *name, int type, int in_out)
403 {
404         bNodeSocketType *stype = ntreeGetSocketType(type);
405         bNodeSocket *gsock = MEM_callocN(sizeof(bNodeSocket), "bNodeSocket");
406         
407         BLI_strncpy(gsock->name, name, sizeof(gsock->name));
408         gsock->type = type;
409         /* group sockets are dynamically added */
410         gsock->flag |= SOCK_DYNAMIC;
411
412         gsock->next = gsock->prev = NULL;
413         gsock->new_sock = NULL;
414         gsock->link = NULL;
415         /* assign new unique index */
416         gsock->own_index = ngroup->cur_index++;
417         gsock->limit = (in_out==SOCK_IN ? 0xFFF : 1);
418         
419         if (stype->value_structsize > 0)
420                 gsock->default_value = MEM_callocN(stype->value_structsize, "default socket value");
421         
422         BLI_addtail(in_out==SOCK_IN ? &ngroup->inputs : &ngroup->outputs, gsock);
423         
424         ngroup->update |= (in_out==SOCK_IN ? NTREE_UPDATE_GROUP_IN : NTREE_UPDATE_GROUP_OUT);
425         
426         return gsock;
427 }
428
429 bNodeSocket *node_group_expose_socket(bNodeTree *ngroup, bNodeSocket *sock, int in_out)
430 {
431         bNodeSocket *gsock= node_group_add_socket(ngroup, sock->name, sock->type, in_out);
432         
433         /* initialize the default value. */
434         node_socket_copy_default_value(gsock->type, gsock->default_value, sock->default_value);
435         
436         return gsock;
437 }
438
439 void node_group_expose_all_sockets(bNodeTree *ngroup)
440 {
441         bNode *node;
442         bNodeSocket *sock, *gsock;
443         
444         for (node=ngroup->nodes.first; node; node=node->next) {
445                 for (sock=node->inputs.first; sock; sock=sock->next) {
446                         if (!sock->link && !nodeSocketIsHidden(sock)) {
447                                 gsock = node_group_add_socket(ngroup, sock->name, sock->type, SOCK_IN);
448                                 
449                                 /* initialize the default value. */
450                                 node_socket_copy_default_value(gsock->type, gsock->default_value, sock->default_value);
451                                 
452                                 sock->link = nodeAddLink(ngroup, NULL, gsock, node, sock);
453                         }
454                 }
455                 for (sock=node->outputs.first; sock; sock=sock->next) {
456                         if (nodeCountSocketLinks(ngroup, sock)==0 && !nodeSocketIsHidden(sock)) {
457                                 gsock = node_group_add_socket(ngroup, sock->name, sock->type, SOCK_OUT);
458                                 
459                                 /* initialize the default value. */
460                                 node_socket_copy_default_value(gsock->type, gsock->default_value, sock->default_value);
461                                 
462                                 gsock->link = nodeAddLink(ngroup, node, sock, NULL, gsock);
463                         }
464                 }
465         }
466 }
467
468 void node_group_remove_socket(bNodeTree *ngroup, bNodeSocket *gsock, int in_out)
469 {
470         nodeRemSocketLinks(ngroup, gsock);
471         
472         switch (in_out) {
473         case SOCK_IN:
474                 BLI_remlink(&ngroup->inputs, gsock);
475                 ngroup->update |= NTREE_UPDATE_GROUP_IN;
476                 break;
477         case SOCK_OUT:
478                 BLI_remlink(&ngroup->outputs, gsock);
479                 ngroup->update |= NTREE_UPDATE_GROUP_OUT;
480                 break;
481         }
482         
483         if (gsock->default_value)
484                 MEM_freeN(gsock->default_value);
485         
486         MEM_freeN(gsock);
487 }
488
489 /* groups display their internal tree name as label */
490 const char *node_group_label(bNode *node)
491 {
492         return (node->id)? node->id->name+2: IFACE_("Missing Datablock");
493 }
494
495 int node_group_valid(bNodeTree *ntree, bNodeTemplate *ntemp)
496 {
497         bNodeTemplate childtemp;
498         bNode *node;
499         
500         /* regular groups cannot be recursive */
501         if (ntree == ntemp->ngroup)
502                 return 0;
503         
504         /* make sure all children are valid */
505         for (node=ntemp->ngroup->nodes.first; node; node=node->next) {
506                 childtemp = nodeMakeTemplate(node);
507                 if (!nodeValid(ntree, &childtemp))
508                         return 0;
509         }
510         
511         return 1;
512 }
513
514 bNodeTemplate node_group_template(bNode *node)
515 {
516         bNodeTemplate ntemp;
517         ntemp.type = NODE_GROUP;
518         ntemp.ngroup = (bNodeTree*)node->id;
519         return ntemp;
520 }
521
522 void node_group_init(bNodeTree *ntree, bNode *node, bNodeTemplate *ntemp)
523 {
524         node->id = (ID*)ntemp->ngroup;
525         
526         /* NB: group socket input/output roles are inverted internally!
527          * Group "inputs" work as outputs in links and vice versa.
528          */
529         if (ntemp->ngroup) {
530                 bNodeSocket *gsock;
531                 for (gsock=ntemp->ngroup->inputs.first; gsock; gsock=gsock->next)
532                         node_group_add_extern_socket(ntree, &node->inputs, SOCK_IN, gsock);
533                 for (gsock=ntemp->ngroup->outputs.first; gsock; gsock=gsock->next)
534                         node_group_add_extern_socket(ntree, &node->outputs, SOCK_OUT, gsock);
535         }
536 }
537
538 static bNodeSocket *group_verify_socket(bNodeTree *ntree, ListBase *lb, int in_out, bNodeSocket *gsock)
539 {
540         bNodeSocket *sock;
541         
542         /* group sockets tagged as internal are not exposed ever */
543         if (gsock->flag & SOCK_INTERNAL)
544                 return NULL;
545         
546         for (sock= lb->first; sock; sock= sock->next) {
547                 if (sock->own_index==gsock->own_index)
548                                 break;
549         }
550         if (sock) {
551                 sock->groupsock = gsock;
552                 
553                 BLI_strncpy(sock->name, gsock->name, sizeof(sock->name));
554                 sock->type= gsock->type;
555                 
556                 /* XXX hack: group socket input/output roles are inverted internally,
557                  * need to change the limit value when making actual node sockets from them.
558                  */
559                 sock->limit = (in_out==SOCK_IN ? 1 : 0xFFF);
560                 
561                 BLI_remlink(lb, sock);
562                 
563                 return sock;
564         }
565         else {
566                 return node_group_add_extern_socket(ntree, NULL, in_out, gsock);
567         }
568 }
569
570 static void group_verify_socket_list(bNodeTree *ntree, bNode *node, ListBase *lb, int in_out, ListBase *glb)
571 {
572         bNodeSocket *sock, *nextsock, *gsock;
573         
574         /* step by step compare */
575         for (gsock= glb->first; gsock; gsock=gsock->next) {
576                 /* abusing new_sock pointer for verification here! only used inside this function */
577                 gsock->new_sock= group_verify_socket(ntree, lb, in_out, gsock);
578         }
579         /* leftovers are removed */
580         for (sock=lb->first; sock; sock=nextsock) {
581                 nextsock=sock->next;
582                 if (sock->flag & SOCK_DYNAMIC)
583                         nodeRemoveSocket(ntree, node, sock);
584         }
585         /* and we put back the verified sockets */
586         for (gsock= glb->first; gsock; gsock=gsock->next) {
587                 if (gsock->new_sock) {
588                         BLI_addtail(lb, gsock->new_sock);
589                         gsock->new_sock = NULL;
590                 }
591         }
592 }
593
594 /* make sure all group node in ntree, which use ngroup, are sync'd */
595 void node_group_verify(struct bNodeTree *ntree, struct bNode *node, struct ID *id)
596 {
597         /* check inputs and outputs, and remove or insert them */
598         if (node->id==id) {
599                 bNodeTree *ngroup= (bNodeTree*)node->id;
600                 group_verify_socket_list(ntree, node, &node->inputs, SOCK_IN, &ngroup->inputs);
601                 group_verify_socket_list(ntree, node, &node->outputs, SOCK_OUT, &ngroup->outputs);
602         }
603 }
604
605 struct bNodeTree *node_group_edit_get(bNode *node)
606 {
607         if (node->flag & NODE_GROUP_EDIT)
608                 return (bNodeTree*)node->id;
609         else
610                 return NULL;
611 }
612
613 struct bNodeTree *node_group_edit_set(bNode *node, int edit)
614 {
615         if (edit) {
616                 bNodeTree *ngroup= (bNodeTree*)node->id;
617                 if (ngroup) {
618                         if (ngroup->id.lib)
619                                 ntreeMakeLocal(ngroup);
620                         
621                         node->flag |= NODE_GROUP_EDIT;
622                 }
623                 return ngroup;
624         }
625         else {
626                 node->flag &= ~NODE_GROUP_EDIT;
627                 return NULL;
628         }
629 }
630
631 void node_group_edit_clear(bNode *node)
632 {
633         bNodeTree *ngroup= (bNodeTree*)node->id;
634         bNode *inode;
635         
636         node->flag &= ~NODE_GROUP_EDIT;
637         
638         if (ngroup)
639                 for (inode=ngroup->nodes.first; inode; inode=inode->next)
640                         nodeGroupEditClear(inode);
641 }
642
643 void node_group_link(bNodeTree *ntree, bNodeSocket *sock, int in_out)
644 {
645         node_group_expose_socket(ntree, sock, in_out);
646 }
647
648 /**** For Loop ****/
649
650 /* Essentially a group node with slightly different behavior.
651  * The internal tree is executed several times, with each output being re-used
652  * as an input in the next iteration. For this purpose, input and output socket
653  * lists are kept identical!
654  */
655
656 bNodeTemplate node_forloop_template(bNode *node)
657 {
658         bNodeTemplate ntemp;
659         ntemp.type = NODE_FORLOOP;
660         ntemp.ngroup = (bNodeTree*)node->id;
661         return ntemp;
662 }
663
664 void node_forloop_init(bNodeTree *ntree, bNode *node, bNodeTemplate *ntemp)
665 {
666         bNodeSocket *sock;
667         
668         node->id = (ID*)ntemp->ngroup;
669         
670         sock = nodeAddSocket(ntree, node, SOCK_IN, "Iterations", SOCK_FLOAT);
671         node_socket_set_default_value_float(sock->default_value, PROP_UNSIGNED, 1, 0, 10000);
672         
673         /* NB: group socket input/output roles are inverted internally!
674          * Group "inputs" work as outputs in links and vice versa.
675          */
676         if (ntemp->ngroup) {
677                 bNodeSocket *gsock;
678                 for (gsock=ntemp->ngroup->inputs.first; gsock; gsock=gsock->next)
679                         node_group_add_extern_socket(ntree, &node->inputs, SOCK_IN, gsock);
680                 for (gsock=ntemp->ngroup->outputs.first; gsock; gsock=gsock->next)
681                         node_group_add_extern_socket(ntree, &node->outputs, SOCK_OUT, gsock);
682         }
683 }
684
685 void node_forloop_init_tree(bNodeTree *ntree)
686 {
687         bNodeSocket *sock;
688         sock = node_group_add_socket(ntree, "Iteration", SOCK_FLOAT, SOCK_IN);
689         sock->flag |= SOCK_INTERNAL;
690 }
691
692 static void loop_sync(bNodeTree *ntree, int sync_in_out)
693 {
694         bNodeSocket *sock, *sync, *nsync, *mirror;
695         ListBase *sync_lb;
696         
697         if (sync_in_out==SOCK_IN) {
698                 sock = ntree->outputs.first;
699                 
700                 sync = ntree->inputs.first;
701                 sync_lb = &ntree->inputs;
702         }
703         else {
704                 sock = ntree->inputs.first;
705                 
706                 sync = ntree->outputs.first;
707                 sync_lb = &ntree->outputs;
708         }
709         
710         /* NB: the sock->storage pointer is used here directly to store the own_index int
711          * out the mirrored socket counterpart!
712          */
713         
714         while (sock) {
715                 /* skip static and internal sockets on the sync side (preserves socket order!) */
716                 while (sync && ((sync->flag & SOCK_INTERNAL) || !(sync->flag & SOCK_DYNAMIC)))
717                         sync = sync->next;
718                 
719                 if (sync && !(sync->flag & SOCK_INTERNAL) && (sync->flag & SOCK_DYNAMIC)) {
720                         if (sock->storage==NULL) {
721                                 /* if mirror index is 0, the sockets is newly added and a new mirror must be created. */
722                                 mirror = node_group_expose_socket(ntree, sock, sync_in_out);
723                                 /* store the mirror index */
724                                 sock->storage = SET_INT_IN_POINTER(mirror->own_index);
725                                 mirror->storage = SET_INT_IN_POINTER(sock->own_index);
726                                 /* move mirror to the right place */
727                                 BLI_remlink(sync_lb, mirror);
728                                 if (sync)
729                                         BLI_insertlinkbefore(sync_lb, sync, mirror);
730                                 else
731                                         BLI_addtail(sync_lb, mirror);
732                         }
733                         else {
734                                 /* look up the mirror socket */
735                                 for (mirror=sync; mirror; mirror=mirror->next)
736                                         if (mirror->own_index == GET_INT_FROM_POINTER(sock->storage))
737                                                 break;
738                                 /* make sure the name is the same (only for identification by user, no deeper meaning) */
739                                 BLI_strncpy(mirror->name, sock->name, sizeof(mirror->name));
740                                 /* fix the socket order if necessary */
741                                 if (mirror != sync) {
742                                         BLI_remlink(sync_lb, mirror);
743                                         BLI_insertlinkbefore(sync_lb, sync, mirror);
744                                 }
745                                 else
746                                         sync = sync->next;
747                         }
748                 }
749                 
750                 sock = sock->next;
751         }
752         
753         /* remaining sockets in sync_lb are leftovers from deleted sockets, remove them */
754         while (sync) {
755                 nsync = sync->next;
756                 if (!(sync->flag & SOCK_INTERNAL) && (sync->flag & SOCK_DYNAMIC))
757                         node_group_remove_socket(ntree, sync, sync_in_out);
758                 sync = nsync;
759         }
760 }
761
762 void node_loop_update_tree(bNodeTree *ngroup)
763 {
764         /* make sure inputs & outputs are identical */
765         if (ngroup->update & NTREE_UPDATE_GROUP_IN)
766                 loop_sync(ngroup, SOCK_OUT);
767         if (ngroup->update & NTREE_UPDATE_GROUP_OUT)
768                 loop_sync(ngroup, SOCK_IN);
769 }
770
771 void node_whileloop_init(bNodeTree *ntree, bNode *node, bNodeTemplate *ntemp)
772 {
773         bNodeSocket *sock;
774         
775         node->id = (ID*)ntemp->ngroup;
776         
777         sock = nodeAddSocket(ntree, node, SOCK_IN, "Condition", SOCK_FLOAT);
778         node_socket_set_default_value_float(sock->default_value, PROP_NONE, 1, 0, 1);
779         
780         /* max iterations */
781         node->custom1 = 10000;
782         
783         /* NB: group socket input/output roles are inverted internally!
784          * Group "inputs" work as outputs in links and vice versa.
785          */
786         if (ntemp->ngroup) {
787                 bNodeSocket *gsock;
788                 for (gsock=ntemp->ngroup->inputs.first; gsock; gsock=gsock->next)
789                         node_group_add_extern_socket(ntree, &node->inputs, SOCK_IN, gsock);
790                 for (gsock=ntemp->ngroup->outputs.first; gsock; gsock=gsock->next)
791                         node_group_add_extern_socket(ntree, &node->outputs, SOCK_OUT, gsock);
792         }
793 }
794
795 void node_whileloop_init_tree(bNodeTree *ntree)
796 {
797         bNodeSocket *sock;
798         sock = node_group_add_socket(ntree, "Condition", SOCK_FLOAT, SOCK_OUT);
799         sock->flag |= SOCK_INTERNAL;
800 }
801
802 bNodeTemplate node_whileloop_template(bNode *node)
803 {
804         bNodeTemplate ntemp;
805         ntemp.type = NODE_WHILELOOP;
806         ntemp.ngroup = (bNodeTree*)node->id;
807         return ntemp;
808 }
809
810 /**** FRAME ****/
811
812 void register_node_type_frame(bNodeTreeType *ttype)
813 {
814         /* frame type is used for all tree types, needs dynamic allocation */
815         bNodeType *ntype= MEM_callocN(sizeof(bNodeType), "frame node type");
816
817         node_type_base(ttype, ntype, NODE_FRAME, "Frame", NODE_CLASS_LAYOUT, NODE_BACKGROUND);
818         node_type_size(ntype, 150, 100, 0);
819         node_type_compatibility(ntype, NODE_OLD_SHADING|NODE_NEW_SHADING);
820         
821         ntype->needs_free = 1;
822         nodeRegisterType(ttype, ntype);
823 }