RenderEngine/Nodes: system to check for shading nodes compatibility
[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         if (gsock->default_value)
104                 sock->default_value = MEM_dupallocN(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 /* XXX This is a makeshift function to have useful initial group socket values.
251  * In the end this should be implemented by a flexible socket data conversion system,
252  * which is yet to be implemented. The idea is that beside default standard conversions,
253  * such as int-to-float, it should be possible to quickly select a conversion method or
254  * a chain of conversions for each input, whenever there is more than one option.
255  * E.g. a vector-to-float conversion could use either of the x/y/z components or
256  * the vector length.
257  *
258  * In the interface this could be implemented by a pseudo-script textbox on linked inputs,
259  * with quick selection from a predefined list of conversion options. Some Examples:
260  * - vector component 'z' (vector->float):                                              "z"
261  * - greyscale color (float->color):                                                    "grey"
262  * - color luminance (color->float):                                                    "lum"
263  * - matrix column 2 length (matrix->vector->float):                    "col[1].len"
264  * - mesh vertex coordinate 'y' (mesh->vertex->vector->float):  "vertex.co.y"
265  *
266  * The actual conversion is then done by a series of conversion functions,
267  * which are defined in the socket type structs.
268  */
269 static void convert_socket_value(bNodeSocket *from, bNodeSocket *to)
270 {
271         /* XXX only one of these pointers is valid! just putting them here for convenience */
272         bNodeSocketValueFloat *fromfloat= (bNodeSocketValueFloat*)from->default_value;
273         bNodeSocketValueInt *fromint= (bNodeSocketValueInt*)from->default_value;
274         bNodeSocketValueBoolean *frombool= (bNodeSocketValueBoolean*)from->default_value;
275         bNodeSocketValueVector *fromvector= (bNodeSocketValueVector*)from->default_value;
276         bNodeSocketValueRGBA *fromrgba= (bNodeSocketValueRGBA*)from->default_value;
277
278         bNodeSocketValueFloat *tofloat= (bNodeSocketValueFloat*)to->default_value;
279         bNodeSocketValueInt *toint= (bNodeSocketValueInt*)to->default_value;
280         bNodeSocketValueBoolean *tobool= (bNodeSocketValueBoolean*)to->default_value;
281         bNodeSocketValueVector *tovector= (bNodeSocketValueVector*)to->default_value;
282         bNodeSocketValueRGBA *torgba= (bNodeSocketValueRGBA*)to->default_value;
283
284         switch (from->type) {
285         case SOCK_FLOAT:
286                 switch (to->type) {
287                 case SOCK_FLOAT:
288                         tofloat->value = fromfloat->value;
289                         break;
290                 case SOCK_INT:
291                         toint->value = (int)fromfloat->value;
292                         break;
293                 case SOCK_BOOLEAN:
294                         tobool->value = (fromfloat->value > 0.0f);
295                         break;
296                 case SOCK_VECTOR:
297                         tovector->value[0] = tovector->value[1] = tovector->value[2] = fromfloat->value;
298                         break;
299                 case SOCK_RGBA:
300                         torgba->value[0] = torgba->value[1] = torgba->value[2] = torgba->value[3] = fromfloat->value;
301                         break;
302                 }
303                 break;
304         case SOCK_INT:
305                 switch (to->type) {
306                 case SOCK_FLOAT:
307                         tofloat->value = (float)fromint->value;
308                         break;
309                 case SOCK_INT:
310                         toint->value = fromint->value;
311                         break;
312                 case SOCK_BOOLEAN:
313                         tobool->value = (fromint->value > 0);
314                         break;
315                 case SOCK_VECTOR:
316                         tovector->value[0] = tovector->value[1] = tovector->value[2] = (float)fromint->value;
317                         break;
318                 case SOCK_RGBA:
319                         torgba->value[0] = torgba->value[1] = torgba->value[2] = torgba->value[3] = (float)fromint->value;
320                         break;
321                 }
322                 break;
323         case SOCK_BOOLEAN:
324                 switch (to->type) {
325                 case SOCK_FLOAT:
326                         tofloat->value = (float)frombool->value;
327                         break;
328                 case SOCK_INT:
329                         toint->value = (int)frombool->value;
330                         break;
331                 case SOCK_BOOLEAN:
332                         tobool->value = frombool->value;
333                         break;
334                 case SOCK_VECTOR:
335                         tovector->value[0] = tovector->value[1] = tovector->value[2] = (float)frombool->value;
336                         break;
337                 case SOCK_RGBA:
338                         torgba->value[0] = torgba->value[1] = torgba->value[2] = torgba->value[3] = (float)frombool->value;
339                         break;
340                 }
341                 break;
342         case SOCK_VECTOR:
343                 switch (to->type) {
344                 case SOCK_FLOAT:
345                         tofloat->value = fromvector->value[0];
346                         break;
347                 case SOCK_INT:
348                         toint->value = (int)fromvector->value[0];
349                         break;
350                 case SOCK_BOOLEAN:
351                         tobool->value = (fromvector->value[0] > 0.0f);
352                         break;
353                 case SOCK_VECTOR:
354                         copy_v3_v3(tovector->value, fromvector->value);
355                         break;
356                 case SOCK_RGBA:
357                         copy_v3_v3(torgba->value, fromvector->value);
358                         torgba->value[3] = 1.0f;
359                         break;
360                 }
361                 break;
362         case SOCK_RGBA:
363                 switch (to->type) {
364                 case SOCK_FLOAT:
365                         tofloat->value = fromrgba->value[0];
366                         break;
367                 case SOCK_INT:
368                         toint->value = (int)fromrgba->value[0];
369                         break;
370                 case SOCK_BOOLEAN:
371                         tobool->value = (fromrgba->value[0] > 0.0f);
372                         break;
373                 case SOCK_VECTOR:
374                         copy_v3_v3(tovector->value, fromrgba->value);
375                         break;
376                 case SOCK_RGBA:
377                         copy_v4_v4(torgba->value, fromrgba->value);
378                         break;
379                 }
380                 break;
381         }
382 }
383
384 static void copy_socket_value(bNodeSocket *from, bNodeSocket *to)
385 {
386         /* XXX only one of these pointers is valid! just putting them here for convenience */
387         bNodeSocketValueFloat *fromfloat= (bNodeSocketValueFloat*)from->default_value;
388         bNodeSocketValueInt *fromint= (bNodeSocketValueInt*)from->default_value;
389         bNodeSocketValueBoolean *frombool= (bNodeSocketValueBoolean*)from->default_value;
390         bNodeSocketValueVector *fromvector= (bNodeSocketValueVector*)from->default_value;
391         bNodeSocketValueRGBA *fromrgba= (bNodeSocketValueRGBA*)from->default_value;
392
393         bNodeSocketValueFloat *tofloat= (bNodeSocketValueFloat*)to->default_value;
394         bNodeSocketValueInt *toint= (bNodeSocketValueInt*)to->default_value;
395         bNodeSocketValueBoolean *tobool= (bNodeSocketValueBoolean*)to->default_value;
396         bNodeSocketValueVector *tovector= (bNodeSocketValueVector*)to->default_value;
397         bNodeSocketValueRGBA *torgba= (bNodeSocketValueRGBA*)to->default_value;
398
399         if (from->type != to->type)
400                 return;
401
402         switch (from->type) {
403         case SOCK_FLOAT:
404                 *tofloat = *fromfloat;
405                 break;
406         case SOCK_INT:
407                 *toint = *fromint;
408                 break;
409         case SOCK_BOOLEAN:
410                 *tobool = *frombool;
411                 break;
412         case SOCK_VECTOR:
413                 *tovector = *fromvector;
414                 break;
415         case SOCK_RGBA:
416                 *torgba = *fromrgba;
417                 break;
418         }
419 }
420
421 /* returns 1 if its OK */
422 int node_group_ungroup(bNodeTree *ntree, bNode *gnode)
423 {
424         bNodeLink *link, *linkn;
425         bNode *node, *nextn;
426         bNodeTree *ngroup, *wgroup;
427         ListBase anim_basepaths = {NULL, NULL};
428         
429         ngroup= (bNodeTree *)gnode->id;
430         if(ngroup==NULL) return 0;
431         
432         /* clear new pointers, set in copytree */
433         for(node= ntree->nodes.first; node; node= node->next)
434                 node->new_node= NULL;
435         
436         /* wgroup is a temporary copy of the NodeTree we're merging in
437          *      - all of wgroup's nodes are transferred across to their new home
438          *      - ngroup (i.e. the source NodeTree) is left unscathed
439          */
440         wgroup= ntreeCopyTree(ngroup);
441         
442         /* add the nodes into the ntree */
443         for(node= wgroup->nodes.first; node; node= nextn) {
444                 nextn= node->next;
445                 
446                 /* keep track of this node's RNA "base" path (the part of the pat identifying the node) 
447                  * if the old nodetree has animation data which potentially covers this node
448                  */
449                 if (wgroup->adt) {
450                         PointerRNA ptr;
451                         char *path;
452                         
453                         RNA_pointer_create(&wgroup->id, &RNA_Node, node, &ptr);
454                         path = RNA_path_from_ID_to_struct(&ptr);
455                         
456                         if (path)
457                                 BLI_addtail(&anim_basepaths, BLI_genericNodeN(path));
458                 }
459                 
460                 /* migrate node */
461                 BLI_remlink(&wgroup->nodes, node);
462                 BLI_addtail(&ntree->nodes, node);
463                 
464                 node->locx+= gnode->locx;
465                 node->locy+= gnode->locy;
466                 
467                 node->flag |= NODE_SELECT;
468         }
469         
470         /* restore external links to and from the gnode */
471         for(link= ntree->links.first; link; link= link->next) {
472                 if (link->fromnode==gnode) {
473                         if (link->fromsock->groupsock) {
474                                 bNodeSocket *gsock= link->fromsock->groupsock;
475                                 if (gsock->link) {
476                                         if (gsock->link->fromnode) {
477                                                 /* NB: using the new internal copies here! the groupsock pointer still maps to the old tree */
478                                                 link->fromnode = (gsock->link->fromnode ? gsock->link->fromnode->new_node : NULL);
479                                                 link->fromsock = gsock->link->fromsock->new_sock;
480                                         }
481                                         else {
482                                                 /* group output directly maps to group input */
483                                                 bNodeSocket *insock= node_group_find_input(gnode, gsock->link->fromsock);
484                                                 if (insock->link) {
485                                                         link->fromnode = insock->link->fromnode;
486                                                         link->fromsock = insock->link->fromsock;
487                                                 }
488                                         }
489                                 }
490                                 else {
491                                         /* copy the default input value from the group socket default to the external socket */
492                                         convert_socket_value(gsock, link->tosock);
493                                 }
494                         }
495                 }
496         }
497         /* remove internal output links, these are not used anymore */
498         for(link=wgroup->links.first; link; link= linkn) {
499                 linkn = link->next;
500                 if (!link->tonode)
501                         nodeRemLink(wgroup, link);
502         }
503         /* restore links from internal nodes */
504         for(link= wgroup->links.first; link; link= link->next) {
505                 /* indicates link to group input */
506                 if (!link->fromnode) {
507                         /* NB: can't use find_group_node_input here,
508                          * because gnode sockets still point to the old tree!
509                          */
510                         bNodeSocket *insock;
511                         for (insock= gnode->inputs.first; insock; insock= insock->next)
512                                 if (insock->groupsock->new_sock == link->fromsock)
513                                         break;
514                         if (insock->link) {
515                                 link->fromnode = insock->link->fromnode;
516                                 link->fromsock = insock->link->fromsock;
517                         }
518                         else {
519                                 /* copy the default input value from the group node socket default to the internal socket */
520                                 convert_socket_value(insock, link->tosock);
521                                 nodeRemLink(wgroup, link);
522                         }
523                 }
524         }
525         
526         /* add internal links to the ntree */
527         for(link= wgroup->links.first; link; link= linkn) {
528                 linkn= link->next;
529                 BLI_remlink(&wgroup->links, link);
530                 BLI_addtail(&ntree->links, link);
531         }
532         
533         /* and copy across the animation */
534         if (wgroup->adt) {
535                 LinkData *ld, *ldn=NULL;
536                 bAction *waction;
537                 
538                 /* firstly, wgroup needs to temporary dummy action that can be destroyed, as it shares copies */
539                 waction = wgroup->adt->action = copy_action(wgroup->adt->action);
540                 
541                 /* now perform the moving */
542                 BKE_animdata_separate_by_basepath(&wgroup->id, &ntree->id, &anim_basepaths);
543                 
544                 /* paths + their wrappers need to be freed */
545                 for (ld = anim_basepaths.first; ld; ld = ldn) {
546                         ldn = ld->next;
547                         
548                         MEM_freeN(ld->data);
549                         BLI_freelinkN(&anim_basepaths, ld);
550                 }
551                 
552                 /* free temp action too */
553                 free_libblock(&G.main->action, waction);
554         }
555         
556         /* delete the group instance. this also removes old input links! */
557         nodeFreeNode(ntree, gnode);
558
559         /* free the group tree (takes care of user count) */
560         free_libblock(&G.main->nodetree, wgroup);
561         
562         ntree->update |= NTREE_UPDATE_NODES | NTREE_UPDATE_LINKS;
563         ntreeUpdateTree(ntree);
564         
565         return 1;
566 }
567
568 bNodeSocket *node_group_add_socket(bNodeTree *ngroup, const char *name, int type, int in_out)
569 {
570         bNodeSocketType *stype = ntreeGetSocketType(type);
571         bNodeSocket *gsock = MEM_callocN(sizeof(bNodeSocket), "bNodeSocket");
572         
573         BLI_strncpy(gsock->name, name, sizeof(gsock->name));
574         gsock->type = type;
575         /* group sockets are dynamically added */
576         gsock->flag |= SOCK_DYNAMIC;
577
578         gsock->next = gsock->prev = NULL;
579         gsock->new_sock = NULL;
580         gsock->link = NULL;
581         /* assign new unique index */
582         gsock->own_index = ngroup->cur_index++;
583         gsock->limit = (in_out==SOCK_IN ? 0xFFF : 1);
584         
585         if (stype->value_structsize > 0)
586                 gsock->default_value = MEM_callocN(stype->value_structsize, "default socket value");
587         
588         BLI_addtail(in_out==SOCK_IN ? &ngroup->inputs : &ngroup->outputs, gsock);
589         
590         ngroup->update |= (in_out==SOCK_IN ? NTREE_UPDATE_GROUP_IN : NTREE_UPDATE_GROUP_OUT);
591         
592         return gsock;
593 }
594
595 bNodeSocket *node_group_expose_socket(bNodeTree *ngroup, bNodeSocket *sock, int in_out)
596 {
597         bNodeSocket *gsock= node_group_add_socket(ngroup, sock->name, sock->type, in_out);
598         
599         /* initialize the default value. */
600         copy_socket_value(sock, gsock);
601         
602         return gsock;
603 }
604
605 void node_group_expose_all_sockets(bNodeTree *ngroup)
606 {
607         bNode *node;
608         bNodeSocket *sock, *gsock;
609         
610         for (node=ngroup->nodes.first; node; node=node->next) {
611                 for (sock=node->inputs.first; sock; sock=sock->next) {
612                         if (!sock->link && !(sock->flag & SOCK_HIDDEN)) {
613                                 gsock = node_group_add_socket(ngroup, sock->name, sock->type, SOCK_IN);
614                                 
615                                 /* initialize the default value. */
616                                 copy_socket_value(sock, gsock);
617                                 
618                                 sock->link = nodeAddLink(ngroup, NULL, gsock, node, sock);
619                         }
620                 }
621                 for (sock=node->outputs.first; sock; sock=sock->next) {
622                         if (nodeCountSocketLinks(ngroup, sock)==0 && !(sock->flag & SOCK_HIDDEN)) {
623                                 gsock = node_group_add_socket(ngroup, sock->name, sock->type, SOCK_OUT);
624                                 
625                                 /* initialize the default value. */
626                                 copy_socket_value(sock, gsock);
627                                 
628                                 gsock->link = nodeAddLink(ngroup, node, sock, NULL, gsock);
629                         }
630                 }
631         }
632 }
633
634 void node_group_remove_socket(bNodeTree *ngroup, bNodeSocket *gsock, int in_out)
635 {
636         nodeRemSocketLinks(ngroup, gsock);
637         
638         switch (in_out) {
639         case SOCK_IN:
640                 BLI_remlink(&ngroup->inputs, gsock);
641                 ngroup->update |= NTREE_UPDATE_GROUP_IN;
642                 break;
643         case SOCK_OUT:
644                 BLI_remlink(&ngroup->outputs, gsock);
645                 ngroup->update |= NTREE_UPDATE_GROUP_OUT;
646                 break;
647         }
648         
649         if (gsock->default_value)
650                 MEM_freeN(gsock->default_value);
651         
652         MEM_freeN(gsock);
653 }
654
655 /* groups display their internal tree name as label */
656 const char *node_group_label(bNode *node)
657 {
658         return (node->id)? node->id->name+2: "Missing Datablock";
659 }
660
661 int node_group_valid(bNodeTree *ntree, bNodeTemplate *ntemp)
662 {
663         bNodeTemplate childtemp;
664         bNode *node;
665         
666         /* regular groups cannot be recursive */
667         if (ntree == ntemp->ngroup)
668                 return 0;
669         
670         /* make sure all children are valid */
671         for (node=ntemp->ngroup->nodes.first; node; node=node->next) {
672                 childtemp = nodeMakeTemplate(node);
673                 if (!nodeValid(ntree, &childtemp))
674                         return 0;
675         }
676         
677         return 1;
678 }
679
680 bNodeTemplate node_group_template(bNode *node)
681 {
682         bNodeTemplate ntemp;
683         ntemp.type = NODE_GROUP;
684         ntemp.ngroup = (bNodeTree*)node->id;
685         return ntemp;
686 }
687
688 void node_group_init(bNodeTree *ntree, bNode *node, bNodeTemplate *ntemp)
689 {
690         node->id = (ID*)ntemp->ngroup;
691         
692         /* NB: group socket input/output roles are inverted internally!
693          * Group "inputs" work as outputs in links and vice versa.
694          */
695         if (ntemp->ngroup) {
696                 bNodeSocket *gsock;
697                 for (gsock=ntemp->ngroup->inputs.first; gsock; gsock=gsock->next)
698                         node_group_add_extern_socket(ntree, &node->inputs, SOCK_IN, gsock);
699                 for (gsock=ntemp->ngroup->outputs.first; gsock; gsock=gsock->next)
700                         node_group_add_extern_socket(ntree, &node->outputs, SOCK_OUT, gsock);
701         }
702 }
703
704 static bNodeSocket *group_verify_socket(bNodeTree *ntree, ListBase *lb, int in_out, bNodeSocket *gsock)
705 {
706         bNodeSocket *sock;
707         
708         /* group sockets tagged as internal are not exposed ever */
709         if (gsock->flag & SOCK_INTERNAL)
710                 return NULL;
711         
712         for(sock= lb->first; sock; sock= sock->next) {
713                 if(sock->own_index==gsock->own_index)
714                                 break;
715         }
716         if(sock) {
717                 sock->groupsock = gsock;
718                 
719                 BLI_strncpy(sock->name, gsock->name, sizeof(sock->name));
720                 sock->type= gsock->type;
721                 
722                 /* XXX hack: group socket input/output roles are inverted internally,
723                  * need to change the limit value when making actual node sockets from them.
724                  */
725                 sock->limit = (in_out==SOCK_IN ? 1 : 0xFFF);
726                 
727                 BLI_remlink(lb, sock);
728                 
729                 return sock;
730         }
731         else {
732                 return node_group_add_extern_socket(ntree, NULL, in_out, gsock);
733         }
734 }
735
736 static void group_verify_socket_list(bNodeTree *ntree, bNode *node, ListBase *lb, int in_out, ListBase *glb)
737 {
738         bNodeSocket *sock, *nextsock, *gsock;
739         
740         /* step by step compare */
741         for (gsock= glb->first; gsock; gsock=gsock->next) {
742                 /* abusing new_sock pointer for verification here! only used inside this function */
743                 gsock->new_sock= group_verify_socket(ntree, lb, in_out, gsock);
744         }
745         /* leftovers are removed */
746         for (sock=lb->first; sock; sock=nextsock) {
747                 nextsock=sock->next;
748                 if (sock->flag & SOCK_DYNAMIC)
749                         nodeRemoveSocket(ntree, node, sock);
750         }
751         /* and we put back the verified sockets */
752         for (gsock= glb->first; gsock; gsock=gsock->next) {
753                 if (gsock->new_sock) {
754                         BLI_addtail(lb, gsock->new_sock);
755                         gsock->new_sock = NULL;
756                 }
757         }
758 }
759
760 /* make sure all group node in ntree, which use ngroup, are sync'd */
761 void node_group_verify(struct bNodeTree *ntree, struct bNode *node, struct ID *id)
762 {
763         /* check inputs and outputs, and remove or insert them */
764         if (node->id==id) {
765                 bNodeTree *ngroup= (bNodeTree*)node->id;
766                 group_verify_socket_list(ntree, node, &node->inputs, SOCK_IN, &ngroup->inputs);
767                 group_verify_socket_list(ntree, node, &node->outputs, SOCK_OUT, &ngroup->outputs);
768         }
769 }
770
771 struct bNodeTree *node_group_edit_get(bNode *node)
772 {
773         if (node->flag & NODE_GROUP_EDIT)
774                 return (bNodeTree*)node->id;
775         else
776                 return NULL;
777 }
778
779 struct bNodeTree *node_group_edit_set(bNode *node, int edit)
780 {
781         if (edit) {
782                 bNodeTree *ngroup= (bNodeTree*)node->id;
783                 if (ngroup) {
784                         if(ngroup->id.lib)
785                                 ntreeMakeLocal(ngroup);
786                         
787                         node->flag |= NODE_GROUP_EDIT;
788                 }
789                 return ngroup;
790         }
791         else {
792                 node->flag &= ~NODE_GROUP_EDIT;
793                 return NULL;
794         }
795 }
796
797 void node_group_edit_clear(bNode *node)
798 {
799         bNodeTree *ngroup= (bNodeTree*)node->id;
800         bNode *inode;
801         
802         node->flag &= ~NODE_GROUP_EDIT;
803         
804         if (ngroup)
805                 for (inode=ngroup->nodes.first; inode; inode=inode->next)
806                         nodeGroupEditClear(inode);
807 }
808
809 void node_group_link(bNodeTree *ntree, bNodeSocket *sock, int in_out)
810 {
811         node_group_expose_socket(ntree, sock, in_out);
812 }
813
814 /**** For Loop ****/
815
816 /* Essentially a group node with slightly different behavior.
817  * The internal tree is executed several times, with each output being re-used
818  * as an input in the next iteration. For this purpose, input and output socket
819  * lists are kept identical!
820  */
821
822 bNodeTemplate node_forloop_template(bNode *node)
823 {
824         bNodeTemplate ntemp;
825         ntemp.type = NODE_FORLOOP;
826         ntemp.ngroup = (bNodeTree*)node->id;
827         return ntemp;
828 }
829
830 void node_forloop_init(bNodeTree *ntree, bNode *node, bNodeTemplate *ntemp)
831 {
832         /* bNodeSocket *sock; */ /* UNUSED */
833         
834         node->id = (ID*)ntemp->ngroup;
835         
836         /* sock = */ nodeAddInputFloat(ntree, node, "Iterations", PROP_UNSIGNED, 1, 0, 10000);
837         
838         /* NB: group socket input/output roles are inverted internally!
839          * Group "inputs" work as outputs in links and vice versa.
840          */
841         if (ntemp->ngroup) {
842                 bNodeSocket *gsock;
843                 for (gsock=ntemp->ngroup->inputs.first; gsock; gsock=gsock->next)
844                         node_group_add_extern_socket(ntree, &node->inputs, SOCK_IN, gsock);
845                 for (gsock=ntemp->ngroup->outputs.first; gsock; gsock=gsock->next)
846                         node_group_add_extern_socket(ntree, &node->outputs, SOCK_OUT, gsock);
847         }
848 }
849
850 void node_forloop_init_tree(bNodeTree *ntree)
851 {
852         bNodeSocket *sock;
853         sock = node_group_add_socket(ntree, "Iteration", SOCK_FLOAT, SOCK_IN);
854         sock->flag |= SOCK_INTERNAL;
855 }
856
857 static void loop_sync(bNodeTree *ntree, int sync_in_out)
858 {
859         bNodeSocket *sock, *sync, *nsync, *mirror;
860         ListBase *sync_lb;
861         
862         if (sync_in_out==SOCK_IN) {
863                 sock = ntree->outputs.first;
864                 
865                 sync = ntree->inputs.first;
866                 sync_lb = &ntree->inputs;
867         }
868         else {
869                 sock = ntree->inputs.first;
870                 
871                 sync = ntree->outputs.first;
872                 sync_lb = &ntree->outputs;
873         }
874         
875         /* NB: the sock->storage pointer is used here directly to store the own_index int
876          * out the mirrored socket counterpart!
877          */
878         
879         while (sock) {
880                 /* skip static and internal sockets on the sync side (preserves socket order!) */
881                 while (sync && ((sync->flag & SOCK_INTERNAL) || !(sync->flag & SOCK_DYNAMIC)))
882                         sync = sync->next;
883                 
884                 if (sync && !(sync->flag & SOCK_INTERNAL) && (sync->flag & SOCK_DYNAMIC)) {
885                         if (sock->storage==NULL) {
886                                 /* if mirror index is 0, the sockets is newly added and a new mirror must be created. */
887                                 mirror = node_group_expose_socket(ntree, sock, sync_in_out);
888                                 /* store the mirror index */
889                                 sock->storage = SET_INT_IN_POINTER(mirror->own_index);
890                                 mirror->storage = SET_INT_IN_POINTER(sock->own_index);
891                                 /* move mirror to the right place */
892                                 BLI_remlink(sync_lb, mirror);
893                                 if (sync)
894                                         BLI_insertlinkbefore(sync_lb, sync, mirror);
895                                 else
896                                         BLI_addtail(sync_lb, mirror);
897                         }
898                         else {
899                                 /* look up the mirror socket */
900                                 for (mirror=sync; mirror; mirror=mirror->next)
901                                         if (mirror->own_index == GET_INT_FROM_POINTER(sock->storage))
902                                                 break;
903                                 /* make sure the name is the same (only for identification by user, no deeper meaning) */
904                                 BLI_strncpy(mirror->name, sock->name, sizeof(mirror->name));
905                                 /* fix the socket order if necessary */
906                                 if (mirror != sync) {
907                                         BLI_remlink(sync_lb, mirror);
908                                         BLI_insertlinkbefore(sync_lb, sync, mirror);
909                                 }
910                                 else
911                                         sync = sync->next;
912                         }
913                 }
914                 
915                 sock = sock->next;
916         }
917         
918         /* remaining sockets in sync_lb are leftovers from deleted sockets, remove them */
919         while (sync) {
920                 nsync = sync->next;
921                 if (!(sync->flag & SOCK_INTERNAL) && (sync->flag & SOCK_DYNAMIC))
922                         node_group_remove_socket(ntree, sync, sync_in_out);
923                 sync = nsync;
924         }
925 }
926
927 void node_loop_update_tree(bNodeTree *ngroup)
928 {
929         /* make sure inputs & outputs are identical */
930         if (ngroup->update & NTREE_UPDATE_GROUP_IN)
931                 loop_sync(ngroup, SOCK_OUT);
932         if (ngroup->update & NTREE_UPDATE_GROUP_OUT)
933                 loop_sync(ngroup, SOCK_IN);
934 }
935
936 void node_whileloop_init(bNodeTree *ntree, bNode *node, bNodeTemplate *ntemp)
937 {
938         /* bNodeSocket *sock; */ /* UNUSED */
939         
940         node->id = (ID*)ntemp->ngroup;
941         
942         /* sock = */ nodeAddInputFloat(ntree, node, "Condition", PROP_NONE, 1, 0, 1);
943         
944         /* max iterations */
945         node->custom1 = 10000;
946         
947         /* NB: group socket input/output roles are inverted internally!
948          * Group "inputs" work as outputs in links and vice versa.
949          */
950         if (ntemp->ngroup) {
951                 bNodeSocket *gsock;
952                 for (gsock=ntemp->ngroup->inputs.first; gsock; gsock=gsock->next)
953                         node_group_add_extern_socket(ntree, &node->inputs, SOCK_IN, gsock);
954                 for (gsock=ntemp->ngroup->outputs.first; gsock; gsock=gsock->next)
955                         node_group_add_extern_socket(ntree, &node->outputs, SOCK_OUT, gsock);
956         }
957 }
958
959 void node_whileloop_init_tree(bNodeTree *ntree)
960 {
961         bNodeSocket *sock;
962         sock = node_group_add_socket(ntree, "Condition", SOCK_FLOAT, SOCK_OUT);
963         sock->flag |= SOCK_INTERNAL;
964 }
965
966 bNodeTemplate node_whileloop_template(bNode *node)
967 {
968         bNodeTemplate ntemp;
969         ntemp.type = NODE_WHILELOOP;
970         ntemp.ngroup = (bNodeTree*)node->id;
971         return ntemp;
972 }
973
974 /**** FRAME ****/
975
976 void register_node_type_frame(ListBase *lb)
977 {
978         /* frame type is used for all tree types, needs dynamic allocation */
979         bNodeType *ntype= MEM_callocN(sizeof(bNodeType), "frame node type");
980
981         node_type_base(ntype, NODE_FRAME, "Frame", NODE_CLASS_LAYOUT, NODE_BACKGROUND);
982         node_type_size(ntype, 150, 100, 0);
983         node_type_compatibility(ntype, NODE_OLD_SHADING|NODE_NEW_SHADING);
984         
985         ntype->needs_free = 1;
986         nodeRegisterType(lb, ntype);
987 }