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