99edd4bac8ca59de5536b593e1a18c2a25be9705
[blender.git] / source / blender / blenkernel / intern / node.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) 2005 Blender Foundation.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): Bob Holcomb.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/blenkernel/intern/node.c
29  *  \ingroup bke
30  */
31
32
33 #if 0 /* pynodes commented for now */
34 #  ifdef WITH_PYTHON
35 #    include <Python.h>
36 #  endif
37 #endif
38
39 #include "MEM_guardedalloc.h"
40
41 #include <stdlib.h>
42 #include <stddef.h>
43 #include <string.h>
44 #include <limits.h>
45
46 #include "DNA_action_types.h"
47 #include "DNA_anim_types.h"
48 #include "DNA_node_types.h"
49 #include "DNA_node_types.h"
50 #include "DNA_scene_types.h"
51
52 #include "BLI_string.h"
53 #include "BLI_math.h"
54 #include "BLI_listbase.h"
55 #include "BLI_path_util.h"
56 #include "BLI_utildefines.h"
57
58 #include "BKE_animsys.h"
59 #include "BKE_action.h"
60 #include "BKE_fcurve.h"
61 #include "BKE_global.h"
62 #include "BKE_image.h"
63 #include "BKE_library.h"
64 #include "BKE_main.h"
65 #include "BKE_node.h"
66 #include "BKE_utildefines.h"
67 #include "BKE_utildefines.h"
68
69 #include "BLI_listbase.h"
70
71 #include "RNA_access.h"
72
73 #include "NOD_socket.h"
74 #include "NOD_composite.h"
75 #include "NOD_shader.h"
76 #include "NOD_texture.h"
77
78
79 bNodeTreeType *ntreeGetType(int type)
80 {
81         static bNodeTreeType *types[NUM_NTREE_TYPES];
82         static int types_init = 1;
83         if (types_init) {
84                 types[NTREE_SHADER] = &ntreeType_Shader;
85                 types[NTREE_COMPOSIT] = &ntreeType_Composite;
86                 types[NTREE_TEXTURE] = &ntreeType_Texture;
87                 types_init = 0;
88         }
89         
90         if(type >= 0 && type < NUM_NTREE_TYPES) {
91                 return types[type];
92         }
93         else {
94                 return NULL;
95         }
96 }
97
98 static bNodeType *node_get_type(bNodeTree *ntree, int type)
99 {
100         bNodeType *ntype = ntreeGetType(ntree->type)->node_types.first;
101         for(; ntype; ntype= ntype->next)
102                 if(ntype->type==type)
103                         return ntype;
104         
105         return NULL;
106 }
107
108 bNodeType *ntreeGetNodeType(bNodeTree *ntree)
109 {
110         return node_get_type(ntree, ntree->nodetype);
111 }
112
113 bNodeSocketType *ntreeGetSocketType(int type)
114 {
115         static bNodeSocketType *types[NUM_SOCKET_TYPES]= {NULL};
116         static int types_init = 1;
117
118         if (types_init) {
119                 node_socket_type_init(types);
120                 types_init= 0;
121         }
122
123         if(type < NUM_SOCKET_TYPES) {
124                 return types[type];
125         }
126         else {
127                 return NULL;
128         }
129 }
130
131 void ntreeInitTypes(bNodeTree *ntree)
132 {
133         bNode *node, *next;
134         
135         for(node= ntree->nodes.first; node; node= next) {
136                 next= node->next;
137                 
138                 node->typeinfo= node_get_type(ntree, node->type);
139                 
140                 if(node->type==NODE_DYNAMIC) {
141                         /* needed info if the pynode script fails now: */
142                         node->storage= ntree;
143                         if(node->id!=NULL) { /* not an empty script node */
144                                 node->custom1= 0;
145                                 node->custom1= BSET(node->custom1,NODE_DYNAMIC_ADDEXIST);
146                         }
147 //                      if(node->typeinfo)
148 //                              node->typeinfo->initfunc(node);
149                 }
150
151                 if(node->typeinfo==NULL) {
152                         printf("Error: Node type %s doesn't exist anymore, removed\n", node->name);
153                         nodeFreeNode(ntree, node);
154                 }
155         }
156                         
157         ntree->init |= NTREE_TYPE_INIT;
158 }
159
160 static bNodeSocket *make_socket(bNodeTree *UNUSED(ntree), int in_out, const char *name, int type)
161 {
162         bNodeSocket *sock;
163         
164         sock= MEM_callocN(sizeof(bNodeSocket), "sock");
165         
166         BLI_strncpy(sock->name, name, NODE_MAXSTR);
167         sock->limit = (in_out==SOCK_IN ? 1 : 0xFFF);
168         sock->type= type;
169         sock->storage = NULL;
170         
171         sock->default_value = node_socket_make_default_value(type);
172         node_socket_init_default_value(type, sock->default_value);
173         
174         return sock;
175 }
176
177 bNodeSocket *nodeAddSocket(bNodeTree *ntree, bNode *node, int in_out, const char *name, int type)
178 {
179         bNodeSocket *sock = make_socket(ntree, in_out, name, type);
180         if (in_out==SOCK_IN)
181                 BLI_addtail(&node->inputs, sock);
182         else if (in_out==SOCK_OUT)
183                 BLI_addtail(&node->outputs, sock);
184         
185         node->update |= NODE_UPDATE;
186         
187         return sock;
188 }
189
190 bNodeSocket *nodeInsertSocket(bNodeTree *ntree, bNode *node, int in_out, bNodeSocket *next_sock, const char *name, int type)
191 {
192         bNodeSocket *sock = make_socket(ntree, in_out, name, type);
193         if (in_out==SOCK_IN)
194                 BLI_insertlinkbefore(&node->inputs, next_sock, sock);
195         else if (in_out==SOCK_OUT)
196                 BLI_insertlinkbefore(&node->outputs, next_sock, sock);
197         
198         node->update |= NODE_UPDATE;
199         
200         return sock;
201 }
202
203 void nodeRemoveSocket(bNodeTree *ntree, bNode *node, bNodeSocket *sock)
204 {
205         bNodeLink *link, *next;
206         
207         for(link= ntree->links.first; link; link= next) {
208                 next= link->next;
209                 if(link->fromsock==sock || link->tosock==sock) {
210                         nodeRemLink(ntree, link);
211                 }
212         }
213         
214         /* this is fast, this way we don't need an in_out argument */
215         BLI_remlink(&node->inputs, sock);
216         BLI_remlink(&node->outputs, sock);
217         
218         node_socket_free_default_value(sock->type, sock->default_value);
219         MEM_freeN(sock);
220         
221         node->update |= NODE_UPDATE;
222 }
223
224 void nodeRemoveAllSockets(bNodeTree *ntree, bNode *node)
225 {
226         bNodeSocket *sock;
227         bNodeLink *link, *next;
228         
229         for(link= ntree->links.first; link; link= next) {
230                 next= link->next;
231                 if(link->fromnode==node || link->tonode==node) {
232                         nodeRemLink(ntree, link);
233                 }
234         }
235         
236         for (sock=node->inputs.first; sock; sock=sock->next)
237                 node_socket_free_default_value(sock->type, sock->default_value);
238         BLI_freelistN(&node->inputs);
239         for (sock=node->outputs.first; sock; sock=sock->next)
240                 node_socket_free_default_value(sock->type, sock->default_value);
241         BLI_freelistN(&node->outputs);
242         
243         node->update |= NODE_UPDATE;
244 }
245
246 /* finds a node based on its name */
247 bNode *nodeFindNodebyName(bNodeTree *ntree, const char *name)
248 {
249         return BLI_findstring(&ntree->nodes, name, offsetof(bNode, name));
250 }
251
252 /* finds a node based on given socket */
253 int nodeFindNode(bNodeTree *ntree, bNodeSocket *sock, bNode **nodep, int *sockindex, int *in_out)
254 {
255         bNode *node;
256         bNodeSocket *tsock;
257         int index= 0;
258         
259         for(node= ntree->nodes.first; node; node= node->next) {
260                 for(index=0, tsock= node->inputs.first; tsock; tsock= tsock->next, index++) {
261                         if(tsock==sock) {
262                                 if (in_out) *in_out= SOCK_IN;
263                                 break;
264                         }
265                 }
266                 if(tsock)
267                         break;
268                 for(index=0, tsock= node->outputs.first; tsock; tsock= tsock->next, index++) {
269                         if(tsock==sock) {
270                                 if (in_out) *in_out= SOCK_OUT;
271                                 break;
272                         }
273                 }
274                 if(tsock)
275                         break;
276         }
277
278         if(node) {
279                 *nodep= node;
280                 if(sockindex) *sockindex= index;
281                 return 1;
282         }
283         
284         *nodep= NULL;
285         return 0;
286 }
287
288 /* ************** Add stuff ********** */
289 static void node_add_sockets_from_type(bNodeTree *ntree, bNode *node, bNodeType *ntype)
290 {
291         bNodeSocketTemplate *sockdef;
292         /* bNodeSocket *sock; */ /* UNUSED */
293
294         if(ntype->inputs) {
295                 sockdef= ntype->inputs;
296                 while(sockdef->type != -1) {
297                         /* sock = */ node_add_input_from_template(ntree, node, sockdef);
298                         
299                         sockdef++;
300                 }
301         }
302         if(ntype->outputs) {
303                 sockdef= ntype->outputs;
304                 while(sockdef->type != -1) {
305                         /* sock = */ node_add_output_from_template(ntree, node, sockdef);
306                         
307                         sockdef++;
308                 }
309         }
310 }
311
312 /* Find the first available, non-duplicate name for a given node */
313 void nodeUniqueName(bNodeTree *ntree, bNode *node)
314 {
315         BLI_uniquename(&ntree->nodes, node, "Node", '.', offsetof(bNode, name), sizeof(node->name));
316 }
317
318 bNode *nodeAddNode(bNodeTree *ntree, struct bNodeTemplate *ntemp)
319 {
320         bNode *node;
321         bNodeType *ntype;
322         
323         ntype= node_get_type(ntree, ntemp->type);
324         if(ntype == NULL) {
325                 printf("nodeAddNodeType() error: '%d' type invalid\n", ntemp->type);
326                 return NULL;
327         }
328         /* validity check */
329         if (!nodeValid(ntree, ntemp))
330                 return NULL;
331         
332         node= MEM_callocN(sizeof(bNode), "new node");
333         node->type= ntype->type;
334         node->typeinfo= ntype;
335         node->flag= NODE_SELECT|ntype->flag;
336         node->width= ntype->width;
337         node->miniwidth= 42.0f;
338         node->height= ntype->height;
339         
340         node_add_sockets_from_type(ntree, node, ntype);
341         
342         if(ntype->initfunc!=NULL)
343                 ntype->initfunc(ntree, node, ntemp);
344         
345         /* initialize the node name with the node label */
346         BLI_strncpy(node->name, nodeLabel(node), NODE_MAXSTR);
347         nodeUniqueName(ntree, node);
348         
349         BLI_addtail(&ntree->nodes, node);
350         
351         ntree->update |= NTREE_UPDATE_NODES;
352         
353         return node;
354 }
355
356 void nodeMakeDynamicType(bNode *node)
357 {
358         /* find SH_DYNAMIC_NODE ntype */
359         bNodeType *ntype= ntreeGetType(NTREE_SHADER)->node_types.first;
360         while(ntype) {
361                 if(ntype->type==NODE_DYNAMIC)
362                         break;
363                 ntype= ntype->next;
364         }
365
366         /* make own type struct to fill */
367         if(ntype) {
368                 /*node->typeinfo= MEM_dupallocN(ntype);*/
369                 bNodeType *newtype= MEM_callocN(sizeof(bNodeType), "dynamic bNodeType");
370                 *newtype= *ntype;
371                 BLI_strncpy(newtype->name, ntype->name, sizeof(newtype->name));
372                 node->typeinfo= newtype;
373         }
374 }
375
376 /* keep socket listorder identical, for copying links */
377 /* ntree is the target tree */
378 bNode *nodeCopyNode(struct bNodeTree *ntree, struct bNode *node)
379 {
380         bNode *nnode= MEM_callocN(sizeof(bNode), "dupli node");
381         bNodeSocket *sock, *oldsock;
382
383         *nnode= *node;
384         nodeUniqueName(ntree, nnode);
385         
386         BLI_addtail(&ntree->nodes, nnode);
387
388         BLI_duplicatelist(&nnode->inputs, &node->inputs);
389         oldsock= node->inputs.first;
390         for(sock= nnode->inputs.first; sock; sock= sock->next, oldsock= oldsock->next) {
391                 oldsock->new_sock= sock;
392                 sock->stack_index= 0;
393                 
394                 sock->default_value = node_socket_make_default_value(oldsock->type);
395                 node_socket_copy_default_value(oldsock->type, sock->default_value, oldsock->default_value);
396                 
397                 /* XXX some compositor node (e.g. image, render layers) still store
398                  * some persistent buffer data here, need to clear this to avoid dangling pointers.
399                  */
400                 sock->cache = NULL;
401         }
402         
403         BLI_duplicatelist(&nnode->outputs, &node->outputs);
404         oldsock= node->outputs.first;
405         for(sock= nnode->outputs.first; sock; sock= sock->next, oldsock= oldsock->next) {
406                 oldsock->new_sock= sock;
407                 sock->stack_index= 0;
408                 
409                 sock->default_value = node_socket_make_default_value(oldsock->type);
410                 node_socket_copy_default_value(oldsock->type, sock->default_value, oldsock->default_value);
411                 
412                 /* XXX some compositor node (e.g. image, render layers) still store
413                  * some persistent buffer data here, need to clear this to avoid dangling pointers.
414                  */
415                 sock->cache = NULL;
416         }
417         
418         /* don't increase node->id users, freenode doesn't decrement either */
419         
420         if(node->typeinfo->copystoragefunc)
421                 node->typeinfo->copystoragefunc(node, nnode);
422         
423         node->new_node= nnode;
424         nnode->new_node= NULL;
425         nnode->preview= NULL;
426         
427         ntree->update |= NTREE_UPDATE_NODES;
428         
429         return nnode;
430 }
431
432 /* also used via rna api, so we check for proper input output direction */
433 bNodeLink *nodeAddLink(bNodeTree *ntree, bNode *fromnode, bNodeSocket *fromsock, bNode *tonode, bNodeSocket *tosock)
434 {
435         bNodeSocket *sock;
436         bNodeLink *link= NULL; 
437         int from= 0, to= 0;
438         
439         if(fromnode) {
440                 /* test valid input */
441                 for(sock= fromnode->outputs.first; sock; sock= sock->next)
442                         if(sock==fromsock)
443                                 break;
444                 if(sock)
445                         from= 1; /* OK */
446                 else {
447                         for(sock= fromnode->inputs.first; sock; sock= sock->next)
448                                 if(sock==fromsock)
449                                         break;
450                         if(sock)
451                                 from= -1; /* OK but flip */
452                 }
453         }
454         else {
455                 /* check tree sockets */
456                 for(sock= ntree->inputs.first; sock; sock= sock->next)
457                         if(sock==fromsock)
458                                 break;
459                 if(sock)
460                         from= 1; /* OK */
461                 else {
462                         for(sock= ntree->outputs.first; sock; sock= sock->next)
463                                 if(sock==fromsock)
464                                         break;
465                         if(sock)
466                                 from= -1; /* OK but flip */
467                 }
468         }
469         if(tonode) {
470                 for(sock= tonode->inputs.first; sock; sock= sock->next)
471                         if(sock==tosock)
472                                 break;
473                 if(sock)
474                         to= 1; /* OK */
475                 else {
476                         for(sock= tonode->outputs.first; sock; sock= sock->next)
477                                 if(sock==tosock)
478                                         break;
479                         if(sock)
480                                 to= -1; /* OK but flip */
481                 }
482         }
483         else {
484                 /* check tree sockets */
485                 for(sock= ntree->outputs.first; sock; sock= sock->next)
486                         if(sock==tosock)
487                                 break;
488                 if(sock)
489                         to= 1; /* OK */
490                 else {
491                         for(sock= ntree->inputs.first; sock; sock= sock->next)
492                                 if(sock==tosock)
493                                         break;
494                         if(sock)
495                                 to= -1; /* OK but flip */
496                 }
497         }
498         
499         if(from >= 0 && to >= 0) {
500                 link= MEM_callocN(sizeof(bNodeLink), "link");
501                 BLI_addtail(&ntree->links, link);
502                 link->fromnode= fromnode;
503                 link->fromsock= fromsock;
504                 link->tonode= tonode;
505                 link->tosock= tosock;
506         }
507         else if(from <= 0 && to <= 0) {
508                 link= MEM_callocN(sizeof(bNodeLink), "link");
509                 BLI_addtail(&ntree->links, link);
510                 link->fromnode= tonode;
511                 link->fromsock= tosock;
512                 link->tonode= fromnode;
513                 link->tosock= fromsock;
514         }
515         
516         ntree->update |= NTREE_UPDATE_LINKS;
517         
518         return link;
519 }
520
521 void nodeRemLink(bNodeTree *ntree, bNodeLink *link)
522 {
523         BLI_remlink(&ntree->links, link);
524         if(link->tosock)
525                 link->tosock->link= NULL;
526         MEM_freeN(link);
527         
528         ntree->update |= NTREE_UPDATE_LINKS;
529 }
530
531 void nodeRemSocketLinks(bNodeTree *ntree, bNodeSocket *sock)
532 {
533         bNodeLink *link, *next;
534         
535         for(link= ntree->links.first; link; link= next) {
536                 next= link->next;
537                 if(link->fromsock==sock || link->tosock==sock) {
538                         nodeRemLink(ntree, link);
539                 }
540         }
541         
542         ntree->update |= NTREE_UPDATE_LINKS;
543 }
544
545 void nodeInternalRelink(bNodeTree *ntree, bNode *node)
546 {
547         bNodeLink *link, *link_next;
548         ListBase intlinks;
549         
550         if (!node->typeinfo->internal_connect)
551                 return;
552         
553         intlinks = node->typeinfo->internal_connect(ntree, node);
554         
555         /* store link pointers in output sockets, for efficient lookup */
556         for (link=intlinks.first; link; link=link->next)
557                 link->tosock->link = link;
558         
559         /* redirect downstream links */
560         for (link=ntree->links.first; link; link=link_next) {
561                 link_next = link->next;
562                 
563                 /* do we have internal link? */
564                 if (link->fromnode==node) {
565                         if (link->fromsock->link) {
566                                 /* get the upstream input link */
567                                 bNodeLink *fromlink = link->fromsock->link->fromsock->link;
568                                 /* skip the node */
569                                 if (fromlink) {
570                                         link->fromnode = fromlink->fromnode;
571                                         link->fromsock = fromlink->fromsock;
572                                         
573                                         ntree->update |= NTREE_UPDATE_LINKS;
574                                 }
575                                 else
576                                         nodeRemLink(ntree, link);
577                         }
578                         else
579                                 nodeRemLink(ntree, link);
580                 }
581         }
582         
583         /* remove remaining upstream links */
584         for (link=ntree->links.first; link; link=link_next) {
585                 link_next = link->next;
586                 
587                 if (link->tonode==node)
588                         nodeRemLink(ntree, link);
589         }
590         
591         BLI_freelistN(&intlinks);
592 }
593
594 /* transforms node location to area coords */
595 void nodeSpaceCoords(bNode *node, float *locx, float *locy)
596 {
597         if (node->parent) {
598                 nodeSpaceCoords(node->parent, locx, locy);
599                 *locx += node->locx;
600                 *locy += node->locy;
601         }
602         else {
603                 *locx = node->locx;
604                 *locy = node->locy;
605         }
606 }
607
608 void nodeAttachNode(bNode *node, bNode *parent)
609 {
610         float parentx, parenty;
611         
612         node->parent = parent;
613         /* transform to parent space */
614         nodeSpaceCoords(parent, &parentx, &parenty);
615         node->locx -= parentx;
616         node->locy -= parenty;
617 }
618
619 void nodeDetachNode(struct bNode *node)
620 {
621         float parentx, parenty;
622         
623         if (node->parent) {
624                 /* transform to "global" (area) space */
625                 nodeSpaceCoords(node->parent, &parentx, &parenty);
626                 node->locx += parentx;
627                 node->locy += parenty;
628                 node->parent = NULL;
629         }
630 }
631
632 bNodeTree *ntreeAddTree(const char *name, int type, int nodetype)
633 {
634         bNodeTree *ntree;
635         bNodeType *ntype;
636         
637         /* trees are created as local trees if they of compositor, material or texture type,
638          * node groups and other tree types are created as library data.
639          */
640         if (ELEM3(type, NTREE_COMPOSIT, NTREE_SHADER, NTREE_TEXTURE) && nodetype==0) {
641                 ntree= MEM_callocN(sizeof(bNodeTree), "new node tree");
642                 *( (short *)ntree->id.name )= ID_NT; /* not "type", as that is ntree->type */
643                 BLI_strncpy(ntree->id.name+2, name, sizeof(ntree->id.name));
644         }
645         else
646                 ntree= alloc_libblock(&G.main->nodetree, ID_NT, name);
647         
648         ntree->type= type;
649         ntree->nodetype = nodetype;
650         
651         ntreeInitTypes(ntree);
652         
653         ntype = node_get_type(ntree, ntree->nodetype);
654         if (ntype && ntype->inittreefunc)
655                 ntype->inittreefunc(ntree);
656         
657         return ntree;
658 }
659
660 /* Warning: this function gets called during some rather unexpected times
661  *      - this gets called when executing compositing updates (for threaded previews)
662  *      - when the nodetree datablock needs to be copied (i.e. when users get copied)
663  *      - for scene duplication use ntreeSwapID() after so we dont have stale pointers.
664  */
665 bNodeTree *ntreeCopyTree(bNodeTree *ntree)
666 {
667         bNodeTree *newtree;
668         bNode *node /*, *nnode */ /* UNUSED */, *last;
669         bNodeLink *link;
670         bNodeSocket *gsock, *oldgsock;
671         
672         if(ntree==NULL) return NULL;
673         
674         /* is ntree part of library? */
675         for(newtree=G.main->nodetree.first; newtree; newtree= newtree->id.next)
676                 if(newtree==ntree) break;
677         if(newtree) {
678                 newtree= copy_libblock(&ntree->id);
679         } else {
680                 newtree= MEM_dupallocN(ntree);
681                 copy_libblock_data(&newtree->id, &ntree->id, TRUE); /* copy animdata and ID props */
682         }
683
684         id_us_plus((ID *)newtree->gpd);
685
686         /* in case a running nodetree is copied */
687         newtree->execdata= NULL;
688         
689         newtree->nodes.first= newtree->nodes.last= NULL;
690         newtree->links.first= newtree->links.last= NULL;
691         
692         last = ntree->nodes.last;
693         for(node= ntree->nodes.first; node; node= node->next) {
694                 node->new_node= NULL;
695                 /* nnode= */ nodeCopyNode(newtree, node);       /* sets node->new */
696                 
697                 /* make sure we don't copy new nodes again! */
698                 if (node==last)
699                         break;
700         }
701         
702         /* socket definition for group usage */
703         BLI_duplicatelist(&newtree->inputs, &ntree->inputs);
704         for(gsock= newtree->inputs.first, oldgsock= ntree->inputs.first; gsock; gsock=gsock->next, oldgsock=oldgsock->next) {
705                 oldgsock->new_sock= gsock;
706                 gsock->groupsock = (oldgsock->groupsock ? oldgsock->groupsock->new_sock : NULL);
707                 gsock->default_value = node_socket_make_default_value(oldgsock->type);
708                 node_socket_copy_default_value(oldgsock->type, gsock->default_value, oldgsock->default_value);
709         }
710         BLI_duplicatelist(&newtree->outputs, &ntree->outputs);
711         for(gsock= newtree->outputs.first, oldgsock= ntree->outputs.first; gsock; gsock=gsock->next, oldgsock=oldgsock->next) {
712                 oldgsock->new_sock= gsock;
713                 gsock->groupsock = (oldgsock->groupsock ? oldgsock->groupsock->new_sock : NULL);
714                 gsock->default_value = node_socket_make_default_value(oldgsock->type);
715                 node_socket_copy_default_value(oldgsock->type, gsock->default_value, oldgsock->default_value);
716         }
717         
718         /* copy links */
719         BLI_duplicatelist(&newtree->links, &ntree->links);
720         for(link= newtree->links.first; link; link= link->next) {
721                 link->fromnode = (link->fromnode ? link->fromnode->new_node : NULL);
722                 link->fromsock = (link->fromsock ? link->fromsock->new_sock : NULL);
723                 link->tonode = (link->tonode ? link->tonode->new_node : NULL);
724                 link->tosock = (link->tosock ? link->tosock->new_sock : NULL);
725                 /* update the link socket's pointer */
726                 if (link->tosock)
727                         link->tosock->link = link;
728         }
729         
730         /* update node->parent pointers */
731         for (node=newtree->nodes.first; node; node=node->next) {
732                 if (node->parent)
733                         node->parent = node->parent->new_node;
734         }
735         
736         return newtree;
737 }
738
739 /* use when duplicating scenes */
740 void ntreeSwitchID(bNodeTree *ntree, ID *id_from, ID *id_to)
741 {
742         bNode *node;
743         /* for scene duplication only */
744         for(node= ntree->nodes.first; node; node= node->next) {
745                 if(node->id==id_from) {
746                         node->id= id_to;
747                 }
748         }
749 }
750
751 /* *************** preview *********** */
752 /* if node->preview, then we assume the rect to exist */
753
754 void nodeFreePreview(bNode *node)
755 {
756         if(node->preview) {
757                 if(node->preview->rect)
758                         MEM_freeN(node->preview->rect);
759                 MEM_freeN(node->preview);
760                 node->preview= NULL;
761         }       
762 }
763
764 static void node_init_preview(bNode *node, int xsize, int ysize)
765 {
766         
767         if(node->preview==NULL) {
768                 node->preview= MEM_callocN(sizeof(bNodePreview), "node preview");
769                 //              printf("added preview %s\n", node->name);
770         }
771         
772         /* node previews can get added with variable size this way */
773         if(xsize==0 || ysize==0)
774                 return;
775         
776         /* sanity checks & initialize */
777         if(node->preview->rect) {
778                 if(node->preview->xsize!=xsize && node->preview->ysize!=ysize) {
779                         MEM_freeN(node->preview->rect);
780                         node->preview->rect= NULL;
781                 }
782         }
783         
784         if(node->preview->rect==NULL) {
785                 node->preview->rect= MEM_callocN(4*xsize + xsize*ysize*sizeof(char)*4, "node preview rect");
786                 node->preview->xsize= xsize;
787                 node->preview->ysize= ysize;
788         }
789         /* no clear, makes nicer previews */
790 }
791
792 void ntreeInitPreview(bNodeTree *ntree, int xsize, int ysize)
793 {
794         bNode *node;
795         
796         if(ntree==NULL)
797                 return;
798         
799         for(node= ntree->nodes.first; node; node= node->next) {
800                 if(node->typeinfo->flag & NODE_PREVIEW) /* hrms, check for closed nodes? */
801                         node_init_preview(node, xsize, ysize);
802                 if(node->type==NODE_GROUP && (node->flag & NODE_GROUP_EDIT))
803                         ntreeInitPreview((bNodeTree *)node->id, xsize, ysize);
804         }               
805 }
806
807 static void nodeClearPreview(bNode *node)
808 {
809         if(node->preview && node->preview->rect)
810                 memset(node->preview->rect, 0, MEM_allocN_len(node->preview->rect));
811 }
812
813 /* use it to enforce clear */
814 void ntreeClearPreview(bNodeTree *ntree)
815 {
816         bNode *node;
817         
818         if(ntree==NULL)
819                 return;
820         
821         for(node= ntree->nodes.first; node; node= node->next) {
822                 if(node->typeinfo->flag & NODE_PREVIEW)
823                         nodeClearPreview(node);
824                 if(node->type==NODE_GROUP && (node->flag & NODE_GROUP_EDIT))
825                         ntreeClearPreview((bNodeTree *)node->id);
826         }               
827 }
828
829 /* hack warning! this function is only used for shader previews, and 
830 since it gets called multiple times per pixel for Ztransp we only
831 add the color once. Preview gets cleared before it starts render though */
832 void nodeAddToPreview(bNode *node, float *col, int x, int y, int do_manage)
833 {
834         bNodePreview *preview= node->preview;
835         if(preview) {
836                 if(x>=0 && y>=0) {
837                         if(x<preview->xsize && y<preview->ysize) {
838                                 unsigned char *tar= preview->rect+ 4*((preview->xsize*y) + x);
839                                 
840                                 if(do_manage) {
841                                         linearrgb_to_srgb_uchar4(tar, col);
842                                 }
843                                 else {
844                                         rgba_float_to_uchar(tar, col);
845                                 }
846                         }
847                         //else printf("prv out bound x y %d %d\n", x, y);
848                 }
849                 //else printf("prv out bound x y %d %d\n", x, y);
850         }
851 }
852
853 /* ************** Free stuff ********** */
854
855 /* goes over entire tree */
856 void nodeUnlinkNode(bNodeTree *ntree, bNode *node)
857 {
858         bNodeLink *link, *next;
859         bNodeSocket *sock;
860         ListBase *lb;
861         
862         for(link= ntree->links.first; link; link= next) {
863                 next= link->next;
864                 
865                 if(link->fromnode==node) {
866                         lb= &node->outputs;
867                         if (link->tonode)
868                                 link->tonode->update |= NODE_UPDATE;
869                 }
870                 else if(link->tonode==node)
871                         lb= &node->inputs;
872                 else
873                         lb= NULL;
874
875                 if(lb) {
876                         for(sock= lb->first; sock; sock= sock->next) {
877                                 if(link->fromsock==sock || link->tosock==sock)
878                                         break;
879                         }
880                         if(sock) {
881                                 nodeRemLink(ntree, link);
882                         }
883                 }
884         }
885 }
886
887 static void node_unlink_attached(bNodeTree *ntree, bNode *parent)
888 {
889         bNode *node;
890         for (node=ntree->nodes.first; node; node=node->next) {
891                 if (node->parent == parent)
892                         nodeDetachNode(node);
893         }
894 }
895
896 void nodeFreeNode(bNodeTree *ntree, bNode *node)
897 {
898         bNodeTreeType *treetype= ntreeGetType(ntree->type);
899         bNodeSocket *sock, *nextsock;
900         
901         /* remove all references to this node */
902         nodeUnlinkNode(ntree, node);
903         node_unlink_attached(ntree, node);
904         
905         BLI_remlink(&ntree->nodes, node);
906
907         /* since it is called while free database, node->id is undefined */
908         
909         if (treetype->free_node_cache)
910                 treetype->free_node_cache(ntree, node);
911         
912         for (sock=node->inputs.first; sock; sock = nextsock) {
913                 nextsock = sock->next;
914                 node_socket_free_default_value(sock->type, sock->default_value);
915                 MEM_freeN(sock);
916         }
917         for (sock=node->outputs.first; sock; sock = nextsock) {
918                 nextsock = sock->next;
919                 node_socket_free_default_value(sock->type, sock->default_value);
920                 MEM_freeN(sock);
921         }
922
923         nodeFreePreview(node);
924
925         if(node->typeinfo && node->typeinfo->freestoragefunc) {
926                 node->typeinfo->freestoragefunc(node);
927         }
928
929         MEM_freeN(node);
930         
931         ntree->update |= NTREE_UPDATE_NODES;
932 }
933
934 /* do not free ntree itself here, free_libblock calls this function too */
935 void ntreeFreeTree(bNodeTree *ntree)
936 {
937         bNode *node, *next;
938         bNodeSocket *sock;
939         
940         if(ntree==NULL) return;
941         
942         /* XXX hack! node trees should not store execution graphs at all.
943          * This should be removed when old tree types no longer require it.
944          * Currently the execution data for texture nodes remains in the tree
945          * after execution, until the node tree is updated or freed.
946          */
947         if (ntree->execdata) {
948                 switch (ntree->type) {
949                 case NTREE_COMPOSIT:
950                         ntreeCompositEndExecTree(ntree->execdata, 1);
951                         break;
952                 case NTREE_SHADER:
953                         ntreeShaderEndExecTree(ntree->execdata, 1);
954                         break;
955                 case NTREE_TEXTURE:
956                         ntreeTexEndExecTree(ntree->execdata, 1);
957                         break;
958                 }
959         }
960         
961         BKE_free_animdata((ID *)ntree);
962         
963         id_us_min((ID *)ntree->gpd);
964
965         BLI_freelistN(&ntree->links);   /* do first, then unlink_node goes fast */
966         
967         for(node= ntree->nodes.first; node; node= next) {
968                 next= node->next;
969                 nodeFreeNode(ntree, node);
970         }
971         
972         for (sock=ntree->inputs.first; sock; sock=sock->next)
973                 node_socket_free_default_value(sock->type, sock->default_value);
974         BLI_freelistN(&ntree->inputs);
975         for (sock=ntree->outputs.first; sock; sock=sock->next)
976                 node_socket_free_default_value(sock->type, sock->default_value);
977         BLI_freelistN(&ntree->outputs);
978 }
979
980 void ntreeFreeCache(bNodeTree *ntree)
981 {
982         bNodeTreeType *treetype;
983         
984         if(ntree==NULL) return;
985         
986         treetype= ntreeGetType(ntree->type);
987         if (treetype->free_cache)
988                 treetype->free_cache(ntree);
989 }
990
991 void ntreeSetOutput(bNodeTree *ntree)
992 {
993         bNode *node;
994
995         /* find the active outputs, might become tree type dependant handler */
996         for(node= ntree->nodes.first; node; node= node->next) {
997                 if(node->typeinfo->nclass==NODE_CLASS_OUTPUT) {
998                         bNode *tnode;
999                         int output= 0;
1000                         
1001                         /* we need a check for which output node should be tagged like this, below an exception */
1002                         if(node->type==CMP_NODE_OUTPUT_FILE)
1003                                 continue;
1004
1005                         /* there is more types having output class, each one is checked */
1006                         for(tnode= ntree->nodes.first; tnode; tnode= tnode->next) {
1007                                 if(tnode->typeinfo->nclass==NODE_CLASS_OUTPUT) {
1008                                         
1009                                         if(ntree->type==NTREE_COMPOSIT) {
1010                                                         
1011                                                 /* same type, exception for viewer */
1012                                                 if(tnode->type==node->type ||
1013                                                    (ELEM(tnode->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER) &&
1014                                                         ELEM(node->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER))) {
1015                                                         if(tnode->flag & NODE_DO_OUTPUT) {
1016                                                                 output++;
1017                                                                 if(output>1)
1018                                                                         tnode->flag &= ~NODE_DO_OUTPUT;
1019                                                         }
1020                                                 }
1021                                         }
1022                                         else {
1023                                                 /* same type */
1024                                                 if(tnode->type==node->type) {
1025                                                         if(tnode->flag & NODE_DO_OUTPUT) {
1026                                                                 output++;
1027                                                                 if(output>1)
1028                                                                         tnode->flag &= ~NODE_DO_OUTPUT;
1029                                                         }
1030                                                 }
1031                                         }
1032                                 }
1033                         }
1034                         if(output==0)
1035                                 node->flag |= NODE_DO_OUTPUT;
1036                 }
1037         }
1038         
1039         /* here we could recursively set which nodes have to be done,
1040                 might be different for editor or for "real" use... */
1041 }
1042
1043 typedef struct MakeLocalCallData {
1044         ID *group_id;
1045         ID *new_id;
1046         int lib, local;
1047 } MakeLocalCallData;
1048
1049 static void ntreeMakeLocal_CheckLocal(void *calldata, ID *owner_id, bNodeTree *ntree)
1050 {
1051         MakeLocalCallData *cd= (MakeLocalCallData*)calldata;
1052         bNode *node;
1053         
1054         /* find if group is in tree */
1055         for(node= ntree->nodes.first; node; node= node->next) {
1056                 if(node->id == cd->group_id) {
1057                         if(owner_id->lib) cd->lib= 1;
1058                         else cd->local= 1;
1059                 }
1060         }
1061 }
1062
1063 static void ntreeMakeLocal_LinkNew(void *calldata, ID *owner_id, bNodeTree *ntree)
1064 {
1065         MakeLocalCallData *cd= (MakeLocalCallData*)calldata;
1066         bNode *node;
1067         
1068         /* find if group is in tree */
1069         for(node= ntree->nodes.first; node; node= node->next) {
1070                 if(node->id == cd->group_id) {
1071                         if(owner_id->lib==NULL) {
1072                                 node->id= cd->new_id;
1073                                 cd->new_id->us++;
1074                                 cd->group_id->us--;
1075                         }
1076                 }
1077         }
1078 }
1079
1080 void ntreeMakeLocal(bNodeTree *ntree)
1081 {
1082         Main *bmain= G.main;
1083         bNodeTreeType *treetype= ntreeGetType(ntree->type);
1084         MakeLocalCallData cd;
1085         
1086         /* - only lib users: do nothing
1087                 * - only local users: set flag
1088                 * - mixed: make copy
1089                 */
1090         
1091         if(ntree->id.lib==NULL) return;
1092         if(ntree->id.us==1) {
1093                 id_clear_lib_data(bmain, (ID *)ntree);
1094                 return;
1095         }
1096         
1097         /* now check users of groups... again typedepending, callback... */
1098         cd.group_id = &ntree->id;
1099         cd.new_id = NULL;
1100         cd.local = 0;
1101         cd.lib = 0;
1102         
1103         treetype->foreach_nodetree(G.main, &cd, &ntreeMakeLocal_CheckLocal);
1104         
1105         /* if all users are local, we simply make tree local */
1106         if(cd.local && cd.lib==0) {
1107                 id_clear_lib_data(bmain, (ID *)ntree);
1108         }
1109         else if(cd.local && cd.lib) {
1110                 /* this is the mixed case, we copy the tree and assign it to local users */
1111                 bNodeTree *newtree= ntreeCopyTree(ntree);
1112                 
1113                 newtree->id.us= 0;
1114                 
1115
1116                 cd.new_id = &newtree->id;
1117                 treetype->foreach_nodetree(G.main, &cd, &ntreeMakeLocal_LinkNew);
1118         }
1119 }
1120
1121 int ntreeNodeExists(bNodeTree *ntree, bNode *testnode)
1122 {
1123         bNode *node= ntree->nodes.first;
1124         for(; node; node= node->next)
1125                 if(node==testnode)
1126                         return 1;
1127         return 0;
1128 }
1129
1130 int ntreeOutputExists(bNode *node, bNodeSocket *testsock)
1131 {
1132         bNodeSocket *sock= node->outputs.first;
1133         for(; sock; sock= sock->next)
1134                 if(sock==testsock)
1135                         return 1;
1136         return 0;
1137 }
1138
1139 /* returns localized tree for execution in threads */
1140 bNodeTree *ntreeLocalize(bNodeTree *ntree)
1141 {
1142         bNodeTreeType *ntreetype= ntreeGetType(ntree->type);
1143
1144         bNodeTree *ltree;
1145         bNode *node;
1146         
1147         bAction *action_backup= NULL, *tmpact_backup= NULL;
1148         
1149         /* Workaround for copying an action on each render!
1150          * set action to NULL so animdata actions dont get copied */
1151         AnimData *adt= BKE_animdata_from_id(&ntree->id);
1152
1153         if(adt) {
1154                 action_backup= adt->action;
1155                 tmpact_backup= adt->tmpact;
1156
1157                 adt->action= NULL;
1158                 adt->tmpact= NULL;
1159         }
1160
1161         /* node copy func */
1162         ltree= ntreeCopyTree(ntree);
1163
1164         if(adt) {
1165                 AnimData *ladt= BKE_animdata_from_id(&ltree->id);
1166
1167                 adt->action= ladt->action= action_backup;
1168                 adt->tmpact= ladt->tmpact= tmpact_backup;
1169
1170                 if(action_backup) action_backup->id.us++;
1171                 if(tmpact_backup) tmpact_backup->id.us++;
1172                 
1173         }
1174         /* end animdata uglyness */
1175
1176         /* ensures only a single output node is enabled */
1177         ntreeSetOutput(ntree);
1178
1179         for(node= ntree->nodes.first; node; node= node->next) {
1180                 /* store new_node pointer to original */
1181                 node->new_node->new_node= node;
1182         }
1183
1184         if (ntreetype->localize)
1185                 ntreetype->localize(ltree, ntree);
1186
1187         return ltree;
1188 }
1189
1190 /* sync local composite with real tree */
1191 /* local tree is supposed to be running, be careful moving previews! */
1192 /* is called by jobs manager, outside threads, so it doesnt happen during draw */
1193 void ntreeLocalSync(bNodeTree *localtree, bNodeTree *ntree)
1194 {
1195         bNodeTreeType *ntreetype= ntreeGetType(ntree->type);
1196
1197         if (ntreetype->local_sync)
1198                 ntreetype->local_sync(localtree, ntree);
1199 }
1200
1201 /* merge local tree results back, and free local tree */
1202 /* we have to assume the editor already changed completely */
1203 void ntreeLocalMerge(bNodeTree *localtree, bNodeTree *ntree)
1204 {
1205         bNodeTreeType *ntreetype= ntreeGetType(ntree->type);
1206         bNode *lnode;
1207         
1208         /* move over the compbufs and previews */
1209         for(lnode= localtree->nodes.first; lnode; lnode= lnode->next) {
1210                 if(ntreeNodeExists(ntree, lnode->new_node)) {
1211                         if(lnode->preview && lnode->preview->rect) {
1212                                 nodeFreePreview(lnode->new_node);
1213                                 lnode->new_node->preview= lnode->preview;
1214                                 lnode->preview= NULL;
1215                         }
1216                 }
1217         }
1218
1219         if (ntreetype->local_merge)
1220                 ntreetype->local_merge(localtree, ntree);
1221
1222         ntreeFreeTree(localtree);
1223         MEM_freeN(localtree);
1224 }
1225
1226 /* ************ find stuff *************** */
1227
1228 int ntreeHasType(bNodeTree *ntree, int type)
1229 {
1230         bNode *node;
1231         
1232         if(ntree)
1233                 for(node= ntree->nodes.first; node; node= node->next)
1234                         if(node->type == type)
1235                                 return 1;
1236         return 0;
1237 }
1238
1239 bNodeLink *nodeFindLink(bNodeTree *ntree, bNodeSocket *from, bNodeSocket *to)
1240 {
1241         bNodeLink *link;
1242         
1243         for(link= ntree->links.first; link; link= link->next) {
1244                 if(link->fromsock==from && link->tosock==to)
1245                         return link;
1246                 if(link->fromsock==to && link->tosock==from)    /* hrms? */
1247                         return link;
1248         }
1249         return NULL;
1250 }
1251
1252 int nodeCountSocketLinks(bNodeTree *ntree, bNodeSocket *sock)
1253 {
1254         bNodeLink *link;
1255         int tot= 0;
1256         
1257         for(link= ntree->links.first; link; link= link->next) {
1258                 if(link->fromsock==sock || link->tosock==sock)
1259                         tot++;
1260         }
1261         return tot;
1262 }
1263
1264 bNode *nodeGetActive(bNodeTree *ntree)
1265 {
1266         bNode *node;
1267         
1268         if(ntree==NULL) return NULL;
1269         
1270         for(node= ntree->nodes.first; node; node= node->next)
1271                 if(node->flag & NODE_ACTIVE)
1272                         break;
1273         return node;
1274 }
1275
1276 /* two active flags, ID nodes have special flag for buttons display */
1277 bNode *nodeGetActiveID(bNodeTree *ntree, short idtype)
1278 {
1279         bNode *node;
1280         
1281         if(ntree==NULL) return NULL;
1282
1283         /* check for group edit */
1284         for(node= ntree->nodes.first; node; node= node->next)
1285                 if(node->flag & NODE_GROUP_EDIT)
1286                         break;
1287
1288         if(node)
1289                 ntree= (bNodeTree*)node->id;
1290         
1291         /* now find active node with this id */
1292         for(node= ntree->nodes.first; node; node= node->next)
1293                 if(node->id && GS(node->id->name)==idtype)
1294                         if(node->flag & NODE_ACTIVE_ID)
1295                                 break;
1296
1297         return node;
1298 }
1299
1300 int nodeSetActiveID(bNodeTree *ntree, short idtype, ID *id)
1301 {
1302         bNode *node;
1303         int ok= FALSE;
1304
1305         if(ntree==NULL) return ok;
1306
1307         /* check for group edit */
1308         for(node= ntree->nodes.first; node; node= node->next)
1309                 if(node->flag & NODE_GROUP_EDIT)
1310                         break;
1311
1312         if(node)
1313                 ntree= (bNodeTree*)node->id;
1314
1315         /* now find active node with this id */
1316         for(node= ntree->nodes.first; node; node= node->next) {
1317                 if(node->id && GS(node->id->name)==idtype) {
1318                         if(id && ok==FALSE && node->id==id) {
1319                                 node->flag |= NODE_ACTIVE_ID;
1320                                 ok= TRUE;
1321                         } else {
1322                                 node->flag &= ~NODE_ACTIVE_ID;
1323                         }
1324                 }
1325         }
1326
1327         return ok;
1328 }
1329
1330
1331 /* two active flags, ID nodes have special flag for buttons display */
1332 void nodeClearActiveID(bNodeTree *ntree, short idtype)
1333 {
1334         bNode *node;
1335         
1336         if(ntree==NULL) return;
1337         
1338         for(node= ntree->nodes.first; node; node= node->next)
1339                 if(node->id && GS(node->id->name)==idtype)
1340                         node->flag &= ~NODE_ACTIVE_ID;
1341 }
1342
1343 /* two active flags, ID nodes have special flag for buttons display */
1344 void nodeSetActive(bNodeTree *ntree, bNode *node)
1345 {
1346         bNode *tnode;
1347         
1348         /* make sure only one node is active, and only one per ID type */
1349         for(tnode= ntree->nodes.first; tnode; tnode= tnode->next) {
1350                 tnode->flag &= ~NODE_ACTIVE;
1351                 
1352                 if(node->id && tnode->id) {
1353                         if(GS(node->id->name) == GS(tnode->id->name))
1354                                 tnode->flag &= ~NODE_ACTIVE_ID;
1355                 }
1356                 if(node->typeinfo->nclass == NODE_CLASS_TEXTURE)
1357                         tnode->flag &= ~NODE_ACTIVE_TEXTURE;
1358         }
1359         
1360         node->flag |= NODE_ACTIVE;
1361         if(node->id)
1362                 node->flag |= NODE_ACTIVE_ID;
1363         if(node->typeinfo->nclass == NODE_CLASS_TEXTURE)
1364                 node->flag |= NODE_ACTIVE_TEXTURE;
1365 }
1366
1367 int nodeSocketIsHidden(bNodeSocket *sock)
1368 {
1369         return ((sock->flag & (SOCK_HIDDEN | SOCK_AUTO_HIDDEN | SOCK_UNAVAIL)) != 0);
1370 }
1371
1372 void nodeSocketSetType(bNodeSocket *sock, int type)
1373 {
1374         int old_type = sock->type;
1375         void *old_default_value = sock->default_value;
1376         
1377         sock->type = type;
1378         
1379         sock->default_value = node_socket_make_default_value(sock->type);
1380         node_socket_init_default_value(type, sock->default_value);
1381         node_socket_convert_default_value(sock->type, sock->default_value, old_type, old_default_value);
1382         node_socket_free_default_value(old_type, old_default_value);
1383 }
1384
1385 /* ************** dependency stuff *********** */
1386
1387 /* node is guaranteed to be not checked before */
1388 static int node_get_deplist_recurs(bNode *node, bNode ***nsort)
1389 {
1390         bNode *fromnode;
1391         bNodeSocket *sock;
1392         int level = 0xFFF;
1393         
1394         node->done= 1;
1395         
1396         /* check linked nodes */
1397         for(sock= node->inputs.first; sock; sock= sock->next) {
1398                 if(sock->link) {
1399                         fromnode= sock->link->fromnode;
1400                         if(fromnode) {
1401                                 if (fromnode->done==0)
1402                                         fromnode->level= node_get_deplist_recurs(fromnode, nsort);
1403                                 if (fromnode->level <= level)
1404                                         level = fromnode->level - 1;
1405                         }
1406                 }
1407         }
1408         
1409         /* check parent node */
1410         if (node->parent) {
1411                 if (node->parent->done==0)
1412                         node->parent->level= node_get_deplist_recurs(node->parent, nsort);
1413                 if (node->parent->level <= level)
1414                         level = node->parent->level - 1;
1415         }
1416         
1417         if (nsort) {
1418                 **nsort= node;
1419                 (*nsort)++;
1420         }
1421         
1422         return level;
1423 }
1424
1425 void ntreeGetDependencyList(struct bNodeTree *ntree, struct bNode ***deplist, int *totnodes)
1426 {
1427         bNode *node, **nsort;
1428         
1429         *totnodes=0;
1430         
1431         /* first clear data */
1432         for(node= ntree->nodes.first; node; node= node->next) {
1433                 node->done= 0;
1434                 (*totnodes)++;
1435         }
1436         if(*totnodes==0) {
1437                 *deplist = NULL;
1438                 return;
1439         }
1440         
1441         nsort= *deplist= MEM_callocN((*totnodes)*sizeof(bNode*), "sorted node array");
1442         
1443         /* recursive check */
1444         for(node= ntree->nodes.first; node; node= node->next) {
1445                 if(node->done==0) {
1446                         node->level= node_get_deplist_recurs(node, &nsort);
1447                 }
1448         }
1449 }
1450
1451 static void ntree_update_link_pointers(bNodeTree *ntree)
1452 {
1453         bNode *node;
1454         bNodeSocket *sock;
1455         bNodeLink *link;
1456         
1457         /* first clear data */
1458         for(node= ntree->nodes.first; node; node= node->next) {
1459                 for(sock= node->inputs.first; sock; sock= sock->next) {
1460                         sock->link= NULL;
1461                         sock->flag &= ~SOCK_IN_USE;
1462                 }
1463                 for(sock= node->outputs.first; sock; sock= sock->next) {
1464                         sock->flag &= ~SOCK_IN_USE;
1465                 }
1466         }
1467         for(sock= ntree->inputs.first; sock; sock= sock->next) {
1468                 sock->flag &= ~SOCK_IN_USE;
1469         }
1470         for(sock= ntree->outputs.first; sock; sock= sock->next) {
1471                 sock->link= NULL;
1472                 sock->flag &= ~SOCK_IN_USE;
1473         }
1474
1475         for(link= ntree->links.first; link; link= link->next) {
1476                 link->tosock->link= link;
1477                 
1478                 link->fromsock->flag |= SOCK_IN_USE;
1479                 link->tosock->flag |= SOCK_IN_USE;
1480         }
1481 }
1482
1483 static void ntree_validate_links(bNodeTree *ntree)
1484 {
1485         bNodeTreeType *ntreetype = ntreeGetType(ntree->type);
1486         bNodeLink *link;
1487         
1488         for (link = ntree->links.first; link; link = link->next) {
1489                 link->flag |= NODE_LINK_VALID;
1490                 if (link->fromnode && link->tonode && link->fromnode->level <= link->tonode->level)
1491                         link->flag &= ~NODE_LINK_VALID;
1492                 else if (ntreetype->validate_link) {
1493                         if (!ntreetype->validate_link(ntree, link))
1494                                 link->flag &= ~NODE_LINK_VALID;
1495                 }
1496         }
1497 }
1498
1499 static void ntree_verify_nodes_cb(void *calldata, struct ID *UNUSED(owner_id), struct bNodeTree *ntree)
1500 {
1501         ID *id= (ID*)calldata;
1502         bNode *node;
1503         
1504         for (node=ntree->nodes.first; node; node=node->next)
1505                 if (node->typeinfo->verifyfunc)
1506                         node->typeinfo->verifyfunc(ntree, node, id);
1507 }
1508
1509 void ntreeVerifyNodes(struct Main *main, struct ID *id)
1510 {
1511         bNodeTreeType *ntreetype;
1512         bNodeTree *ntree;
1513         int n;
1514         
1515         for (n=0; n < NUM_NTREE_TYPES; ++n) {
1516                 ntreetype= ntreeGetType(n);
1517                 if (ntreetype && ntreetype->foreach_nodetree)
1518                         ntreetype->foreach_nodetree(main, id, ntree_verify_nodes_cb);
1519         }
1520         for (ntree=main->nodetree.first; ntree; ntree=ntree->id.next)
1521                 ntree_verify_nodes_cb(id, NULL, ntree);
1522 }
1523
1524 void ntreeUpdateTree(bNodeTree *ntree)
1525 {
1526         bNodeTreeType *ntreetype= ntreeGetType(ntree->type);
1527         bNode *node;
1528         bNode **deplist;
1529         int totnodes, n;
1530         
1531         ntree_update_link_pointers(ntree);
1532         
1533         /* also updates the node level! */
1534         ntreeGetDependencyList(ntree, &deplist, &totnodes);
1535         
1536         if (deplist) {
1537                 /* update individual nodes */
1538                 for (n=0; n < totnodes; ++n) {
1539                         node = deplist[n];
1540                         
1541                         /* node tree update tags override individual node update flags */
1542                         if ((node->update & NODE_UPDATE) || (ntree->update & NTREE_UPDATE)) {
1543                                 if (ntreetype->update_node)
1544                                         ntreetype->update_node(ntree, node);
1545                                 else if (node->typeinfo->updatefunc)
1546                                         node->typeinfo->updatefunc(ntree, node);
1547                         }
1548                         /* clear update flag */
1549                         node->update = 0;
1550                 }
1551                 
1552                 MEM_freeN(deplist);
1553         }
1554         
1555         /* general tree updates */
1556         if (ntree->update & (NTREE_UPDATE_LINKS|NTREE_UPDATE_NODES)) {
1557                 ntree_validate_links(ntree);
1558         }
1559         
1560         /* update tree */
1561         if (ntreetype->update)
1562                 ntreetype->update(ntree);
1563         else {
1564                 /* Trees can be associated with a specific node type (i.e. group nodes),
1565                  * in that case a tree update function may be defined by that node type.
1566                  */
1567                 bNodeType *ntype= node_get_type(ntree, ntree->nodetype);
1568                 if (ntype && ntype->updatetreefunc)
1569                         ntype->updatetreefunc(ntree);
1570         }
1571         
1572         /* XXX hack, should be done by depsgraph!! */
1573         ntreeVerifyNodes(G.main, &ntree->id);
1574         
1575         /* clear the update flag */
1576         ntree->update = 0;
1577 }
1578
1579 void nodeUpdate(bNodeTree *ntree, bNode *node)
1580 {
1581         bNodeTreeType *ntreetype= ntreeGetType(ntree->type);
1582         
1583         if (ntreetype->update_node)
1584                 ntreetype->update_node(ntree, node);
1585         else if (node->typeinfo->updatefunc)
1586                 node->typeinfo->updatefunc(ntree, node);
1587         /* clear update flag */
1588         node->update = 0;
1589 }
1590
1591 int nodeUpdateID(bNodeTree *ntree, ID *id)
1592 {
1593         bNodeTreeType *ntreetype;
1594         bNode *node;
1595         int change = FALSE;
1596         
1597         if(ELEM(NULL, id, ntree))
1598                 return change;
1599         
1600         ntreetype = ntreeGetType(ntree->type);
1601         
1602         if (ntreetype->update_node) {
1603                 for(node= ntree->nodes.first; node; node= node->next) {
1604                         if(node->id==id) {
1605                                 change = TRUE;
1606                                 ntreetype->update_node(ntree, node);
1607                                 /* clear update flag */
1608                                 node->update = 0;
1609                         }
1610                 }
1611         }
1612         else {
1613                 for(node= ntree->nodes.first; node; node= node->next) {
1614                         if(node->id==id) {
1615                                 change = TRUE;
1616                                 if (node->typeinfo->updatefunc)
1617                                         node->typeinfo->updatefunc(ntree, node);
1618                                 /* clear update flag */
1619                                 node->update = 0;
1620                         }
1621                 }
1622         }
1623         
1624         return change;
1625 }
1626
1627
1628 /* ************* node type access ********** */
1629
1630 int nodeValid(bNodeTree *ntree, bNodeTemplate *ntemp)
1631 {
1632         bNodeType *ntype= node_get_type(ntree, ntemp->type);
1633         if (ntype) {
1634                 if (ntype->validfunc)
1635                         return ntype->validfunc(ntree, ntemp);
1636                 else
1637                         return 1;
1638         }
1639         else
1640                 return 0;
1641 }
1642
1643 const char* nodeLabel(bNode *node)
1644 {
1645         if (node->label[0]!='\0')
1646                 return node->label;
1647         else if (node->typeinfo->labelfunc)
1648                 return node->typeinfo->labelfunc(node);
1649         else
1650                 return node->typeinfo->name;
1651 }
1652
1653 struct bNodeTree *nodeGroupEditGet(struct bNode *node)
1654 {
1655         if (node->typeinfo->group_edit_get)
1656                 return node->typeinfo->group_edit_get(node);
1657         else
1658                 return NULL;
1659 }
1660
1661 struct bNodeTree *nodeGroupEditSet(struct bNode *node, int edit)
1662 {
1663         if (node->typeinfo->group_edit_set)
1664                 return node->typeinfo->group_edit_set(node, edit);
1665         else if (node->typeinfo->group_edit_get)
1666                 return node->typeinfo->group_edit_get(node);
1667         else
1668                 return NULL;
1669 }
1670
1671 void nodeGroupEditClear(struct bNode *node)
1672 {
1673         if (node->typeinfo->group_edit_clear)
1674                 node->typeinfo->group_edit_clear(node);
1675 }
1676
1677 struct bNodeTemplate nodeMakeTemplate(struct bNode *node)
1678 {
1679         bNodeTemplate ntemp;
1680         if (node->typeinfo->templatefunc)
1681                 return node->typeinfo->templatefunc(node);
1682         else {
1683                 ntemp.type = node->type;
1684                 return ntemp;
1685         }
1686 }
1687
1688 void node_type_base(bNodeTreeType *ttype, bNodeType *ntype, int type, const char *name, short nclass, short flag)
1689 {
1690         memset(ntype, 0, sizeof(bNodeType));
1691
1692         ntype->type = type;
1693         BLI_strncpy(ntype->name, name, sizeof(ntype->name));
1694         ntype->nclass = nclass;
1695         ntype->flag = flag;
1696
1697         /* Default muting stuff. */
1698         if(ttype)
1699                 ntype->internal_connect = ttype->internal_connect;
1700
1701         /* default size values */
1702         ntype->width = 140;
1703         ntype->minwidth = 100;
1704         ntype->maxwidth = 320;
1705         ntype->height = 100;
1706         ntype->minheight = 30;
1707         ntype->maxheight = FLT_MAX;
1708 }
1709
1710 void node_type_socket_templates(struct bNodeType *ntype, struct bNodeSocketTemplate *inputs, struct bNodeSocketTemplate *outputs)
1711 {
1712         ntype->inputs = inputs;
1713         ntype->outputs = outputs;
1714 }
1715
1716 void node_type_init(struct bNodeType *ntype, void (*initfunc)(struct bNodeTree *ntree, struct bNode *node, struct bNodeTemplate *ntemp))
1717 {
1718         ntype->initfunc = initfunc;
1719 }
1720
1721 void node_type_valid(struct bNodeType *ntype, int (*validfunc)(struct bNodeTree *ntree, struct bNodeTemplate *ntemp))
1722 {
1723         ntype->validfunc = validfunc;
1724 }
1725
1726 void node_type_size(struct bNodeType *ntype, int width, int minwidth, int maxwidth)
1727 {
1728         ntype->width = width;
1729         ntype->minwidth = minwidth;
1730         if (maxwidth <= minwidth)
1731                 ntype->maxwidth = FLT_MAX;
1732         else
1733                 ntype->maxwidth = maxwidth;
1734 }
1735
1736 void node_type_storage(bNodeType *ntype, const char *storagename, void (*freestoragefunc)(struct bNode *), void (*copystoragefunc)(struct bNode *, struct bNode *))
1737 {
1738         if (storagename)
1739                 BLI_strncpy(ntype->storagename, storagename, sizeof(ntype->storagename));
1740         else
1741                 ntype->storagename[0] = '\0';
1742         ntype->copystoragefunc = copystoragefunc;
1743         ntype->freestoragefunc = freestoragefunc;
1744 }
1745
1746 void node_type_label(struct bNodeType *ntype, const char *(*labelfunc)(struct bNode *))
1747 {
1748         ntype->labelfunc = labelfunc;
1749 }
1750
1751 void node_type_template(struct bNodeType *ntype, struct bNodeTemplate (*templatefunc)(struct bNode *))
1752 {
1753         ntype->templatefunc = templatefunc;
1754 }
1755
1756 void node_type_update(struct bNodeType *ntype,
1757                                           void (*updatefunc)(struct bNodeTree *ntree, struct bNode *node),
1758                                           void (*verifyfunc)(struct bNodeTree *ntree, struct bNode *node, struct ID *id))
1759 {
1760         ntype->updatefunc = updatefunc;
1761         ntype->verifyfunc = verifyfunc;
1762 }
1763
1764 void node_type_tree(struct bNodeType *ntype, void (*inittreefunc)(struct bNodeTree *), void (*updatetreefunc)(struct bNodeTree *))
1765 {
1766         ntype->inittreefunc = inittreefunc;
1767         ntype->updatetreefunc = updatetreefunc;
1768 }
1769
1770 void node_type_group_edit(struct bNodeType *ntype,
1771                                                   struct bNodeTree *(*group_edit_get)(struct bNode *node),
1772                                                   struct bNodeTree *(*group_edit_set)(struct bNode *node, int edit),
1773                                                   void (*group_edit_clear)(struct bNode *node))
1774 {
1775         ntype->group_edit_get = group_edit_get;
1776         ntype->group_edit_set = group_edit_set;
1777         ntype->group_edit_clear = group_edit_clear;
1778 }
1779
1780 void node_type_exec(struct bNodeType *ntype, void (*execfunc)(void *data, struct bNode *, struct bNodeStack **, struct bNodeStack **))
1781 {
1782         ntype->execfunc = execfunc;
1783 }
1784
1785 void node_type_exec_new(struct bNodeType *ntype,
1786                                                 void *(*initexecfunc)(struct bNode *node),
1787                                                 void (*freeexecfunc)(struct bNode *node, void *nodedata),
1788                                                 void (*newexecfunc)(void *data, int thread, struct bNode *, void *nodedata, struct bNodeStack **, struct bNodeStack **))
1789 {
1790         ntype->initexecfunc = initexecfunc;
1791         ntype->freeexecfunc = freeexecfunc;
1792         ntype->newexecfunc = newexecfunc;
1793 }
1794
1795 void node_type_internal_connect(bNodeType *ntype, ListBase (*internal_connect)(bNodeTree *, bNode *))
1796 {
1797         ntype->internal_connect = internal_connect;
1798 }
1799
1800 void node_type_gpu(struct bNodeType *ntype, int (*gpufunc)(struct GPUMaterial *mat, struct bNode *node, struct GPUNodeStack *in, struct GPUNodeStack *out))
1801 {
1802         ntype->gpufunc = gpufunc;
1803 }
1804
1805 void node_type_gpu_ext(struct bNodeType *ntype, int (*gpuextfunc)(struct GPUMaterial *mat, struct bNode *node, void *nodedata, struct GPUNodeStack *in, struct GPUNodeStack *out))
1806 {
1807         ntype->gpuextfunc = gpuextfunc;
1808 }
1809
1810 void node_type_compatibility(struct bNodeType *ntype, short compatibility)
1811 {
1812         ntype->compatibility = compatibility;
1813 }
1814
1815 static bNodeType *is_nodetype_registered(ListBase *typelist, int type) 
1816 {
1817         bNodeType *ntype= typelist->first;
1818         
1819         for(;ntype; ntype= ntype->next )
1820                 if(ntype->type==type)
1821                         return ntype;
1822         
1823         return NULL;
1824 }
1825
1826 void nodeRegisterType(bNodeTreeType *ttype, bNodeType *ntype) 
1827 {
1828         ListBase *typelist = &(ttype->node_types);
1829         bNodeType *found= is_nodetype_registered(typelist, ntype->type);
1830         
1831         if(found==NULL)
1832                 BLI_addtail(typelist, ntype);
1833 }
1834
1835 static void registerCompositNodes(bNodeTreeType *ttype)
1836 {
1837         register_node_type_frame(ttype);
1838         
1839         register_node_type_cmp_group(ttype);
1840 //      register_node_type_cmp_forloop(ttype);
1841 //      register_node_type_cmp_whileloop(ttype);
1842         
1843         register_node_type_cmp_rlayers(ttype);
1844         register_node_type_cmp_image(ttype);
1845         register_node_type_cmp_texture(ttype);
1846         register_node_type_cmp_value(ttype);
1847         register_node_type_cmp_rgb(ttype);
1848         register_node_type_cmp_curve_time(ttype);
1849         register_node_type_cmp_movieclip(ttype);
1850         
1851         register_node_type_cmp_composite(ttype);
1852         register_node_type_cmp_viewer(ttype);
1853         register_node_type_cmp_splitviewer(ttype);
1854         register_node_type_cmp_output_file(ttype);
1855         register_node_type_cmp_view_levels(ttype);
1856         
1857         register_node_type_cmp_curve_rgb(ttype);
1858         register_node_type_cmp_mix_rgb(ttype);
1859         register_node_type_cmp_hue_sat(ttype);
1860         register_node_type_cmp_brightcontrast(ttype);
1861         register_node_type_cmp_gamma(ttype);
1862         register_node_type_cmp_invert(ttype);
1863         register_node_type_cmp_alphaover(ttype);
1864         register_node_type_cmp_zcombine(ttype);
1865         register_node_type_cmp_colorbalance(ttype);
1866         register_node_type_cmp_huecorrect(ttype);
1867         
1868         register_node_type_cmp_normal(ttype);
1869         register_node_type_cmp_curve_vec(ttype);
1870         register_node_type_cmp_map_value(ttype);
1871         register_node_type_cmp_normalize(ttype);
1872         
1873         register_node_type_cmp_filter(ttype);
1874         register_node_type_cmp_blur(ttype);
1875         register_node_type_cmp_dblur(ttype);
1876         register_node_type_cmp_bilateralblur(ttype);
1877         register_node_type_cmp_vecblur(ttype);
1878         register_node_type_cmp_dilateerode(ttype);
1879         register_node_type_cmp_defocus(ttype);
1880         
1881         register_node_type_cmp_valtorgb(ttype);
1882         register_node_type_cmp_rgbtobw(ttype);
1883         register_node_type_cmp_setalpha(ttype);
1884         register_node_type_cmp_idmask(ttype);
1885         register_node_type_cmp_math(ttype);
1886         register_node_type_cmp_seprgba(ttype);
1887         register_node_type_cmp_combrgba(ttype);
1888         register_node_type_cmp_sephsva(ttype);
1889         register_node_type_cmp_combhsva(ttype);
1890         register_node_type_cmp_sepyuva(ttype);
1891         register_node_type_cmp_combyuva(ttype);
1892         register_node_type_cmp_sepycca(ttype);
1893         register_node_type_cmp_combycca(ttype);
1894         register_node_type_cmp_premulkey(ttype);
1895         
1896         register_node_type_cmp_diff_matte(ttype);
1897         register_node_type_cmp_distance_matte(ttype);
1898         register_node_type_cmp_chroma_matte(ttype);
1899         register_node_type_cmp_color_matte(ttype);
1900         register_node_type_cmp_channel_matte(ttype);
1901         register_node_type_cmp_color_spill(ttype);
1902         register_node_type_cmp_luma_matte(ttype);
1903     register_node_type_cmp_doubleedgemask(ttype);
1904
1905         register_node_type_cmp_translate(ttype);
1906         register_node_type_cmp_rotate(ttype);
1907         register_node_type_cmp_scale(ttype);
1908         register_node_type_cmp_flip(ttype);
1909         register_node_type_cmp_crop(ttype);
1910         register_node_type_cmp_displace(ttype);
1911         register_node_type_cmp_mapuv(ttype);
1912         register_node_type_cmp_glare(ttype);
1913         register_node_type_cmp_tonemap(ttype);
1914         register_node_type_cmp_lensdist(ttype);
1915         register_node_type_cmp_transform(ttype);
1916         register_node_type_cmp_stabilize2d(ttype);
1917         register_node_type_cmp_moviedistortion(ttype);
1918 }
1919
1920 static void registerShaderNodes(bNodeTreeType *ttype) 
1921 {
1922         register_node_type_frame(ttype);
1923         
1924         register_node_type_sh_group(ttype);
1925         //register_node_type_sh_forloop(ttype);
1926         //register_node_type_sh_whileloop(ttype);
1927
1928         register_node_type_sh_output(ttype);
1929         register_node_type_sh_material(ttype);
1930         register_node_type_sh_camera(ttype);
1931         register_node_type_sh_gamma(ttype);
1932         register_node_type_sh_brightcontrast(ttype);
1933         register_node_type_sh_value(ttype);
1934         register_node_type_sh_rgb(ttype);
1935         register_node_type_sh_mix_rgb(ttype);
1936         register_node_type_sh_valtorgb(ttype);
1937         register_node_type_sh_rgbtobw(ttype);
1938         register_node_type_sh_texture(ttype);
1939         register_node_type_sh_normal(ttype);
1940         register_node_type_sh_geom(ttype);
1941         register_node_type_sh_mapping(ttype);
1942         register_node_type_sh_curve_vec(ttype);
1943         register_node_type_sh_curve_rgb(ttype);
1944         register_node_type_sh_math(ttype);
1945         register_node_type_sh_vect_math(ttype);
1946         register_node_type_sh_squeeze(ttype);
1947         //register_node_type_sh_dynamic(ttype);
1948         register_node_type_sh_material_ext(ttype);
1949         register_node_type_sh_invert(ttype);
1950         register_node_type_sh_seprgb(ttype);
1951         register_node_type_sh_combrgb(ttype);
1952         register_node_type_sh_hue_sat(ttype);
1953
1954         register_node_type_sh_attribute(ttype);
1955         register_node_type_sh_geometry(ttype);
1956         register_node_type_sh_light_path(ttype);
1957         register_node_type_sh_fresnel(ttype);
1958         register_node_type_sh_layer_weight(ttype);
1959         register_node_type_sh_tex_coord(ttype);
1960
1961         register_node_type_sh_background(ttype);
1962         register_node_type_sh_bsdf_diffuse(ttype);
1963         register_node_type_sh_bsdf_glossy(ttype);
1964         register_node_type_sh_bsdf_glass(ttype);
1965         register_node_type_sh_bsdf_translucent(ttype);
1966         register_node_type_sh_bsdf_transparent(ttype);
1967         register_node_type_sh_bsdf_velvet(ttype);
1968         register_node_type_sh_emission(ttype);
1969         register_node_type_sh_holdout(ttype);
1970         //register_node_type_sh_volume_transparent(ttype);
1971         //register_node_type_sh_volume_isotropic(ttype);
1972         register_node_type_sh_mix_shader(ttype);
1973         register_node_type_sh_add_shader(ttype);
1974
1975         register_node_type_sh_output_lamp(ttype);
1976         register_node_type_sh_output_material(ttype);
1977         register_node_type_sh_output_world(ttype);
1978
1979         register_node_type_sh_tex_image(ttype);
1980         register_node_type_sh_tex_environment(ttype);
1981         register_node_type_sh_tex_sky(ttype);
1982         register_node_type_sh_tex_noise(ttype);
1983         register_node_type_sh_tex_wave(ttype);
1984         register_node_type_sh_tex_voronoi(ttype);
1985         register_node_type_sh_tex_musgrave(ttype);
1986         register_node_type_sh_tex_gradient(ttype);
1987         register_node_type_sh_tex_magic(ttype);
1988         register_node_type_sh_tex_checker(ttype);
1989 }
1990
1991 static void registerTextureNodes(bNodeTreeType *ttype)
1992 {
1993         register_node_type_frame(ttype);
1994         
1995         register_node_type_tex_group(ttype);
1996 //      register_node_type_tex_forloop(ttype);
1997 //      register_node_type_tex_whileloop(ttype);
1998         
1999         register_node_type_tex_math(ttype);
2000         register_node_type_tex_mix_rgb(ttype);
2001         register_node_type_tex_valtorgb(ttype);
2002         register_node_type_tex_rgbtobw(ttype);
2003         register_node_type_tex_valtonor(ttype);
2004         register_node_type_tex_curve_rgb(ttype);
2005         register_node_type_tex_curve_time(ttype);
2006         register_node_type_tex_invert(ttype);
2007         register_node_type_tex_hue_sat(ttype);
2008         register_node_type_tex_coord(ttype);
2009         register_node_type_tex_distance(ttype);
2010         register_node_type_tex_compose(ttype);
2011         register_node_type_tex_decompose(ttype);
2012         
2013         register_node_type_tex_output(ttype);
2014         register_node_type_tex_viewer(ttype);
2015         
2016         register_node_type_tex_checker(ttype);
2017         register_node_type_tex_texture(ttype);
2018         register_node_type_tex_bricks(ttype);
2019         register_node_type_tex_image(ttype);
2020         
2021         register_node_type_tex_rotate(ttype);
2022         register_node_type_tex_translate(ttype);
2023         register_node_type_tex_scale(ttype);
2024         register_node_type_tex_at(ttype);
2025         
2026         register_node_type_tex_proc_voronoi(ttype);
2027         register_node_type_tex_proc_blend(ttype);
2028         register_node_type_tex_proc_magic(ttype);
2029         register_node_type_tex_proc_marble(ttype);
2030         register_node_type_tex_proc_clouds(ttype);
2031         register_node_type_tex_proc_wood(ttype);
2032         register_node_type_tex_proc_musgrave(ttype);
2033         register_node_type_tex_proc_noise(ttype);
2034         register_node_type_tex_proc_stucci(ttype);
2035         register_node_type_tex_proc_distnoise(ttype);
2036 }
2037
2038 static void free_dynamic_typeinfo(bNodeType *ntype)
2039 {
2040         if(ntype->type==NODE_DYNAMIC) {
2041                 if(ntype->inputs) {
2042                         MEM_freeN(ntype->inputs);
2043                 }
2044                 if(ntype->outputs) {
2045                         MEM_freeN(ntype->outputs);
2046                 }
2047                 if(ntype->name) {
2048                         MEM_freeN((void *)ntype->name);
2049                 }
2050         }
2051 }
2052
2053 static void free_typeinfos(ListBase *list)
2054 {
2055         bNodeType *ntype, *next;
2056         for(ntype=list->first; ntype; ntype=next) {
2057                 next = ntype->next;
2058                 
2059                 if(ntype->type==NODE_DYNAMIC)
2060                         free_dynamic_typeinfo(ntype);
2061                 
2062                 if(ntype->needs_free)
2063                         MEM_freeN(ntype);
2064         }
2065 }
2066
2067 void init_nodesystem(void) 
2068 {
2069         registerCompositNodes(ntreeGetType(NTREE_COMPOSIT));
2070         registerShaderNodes(ntreeGetType(NTREE_SHADER));
2071         registerTextureNodes(ntreeGetType(NTREE_TEXTURE));
2072 }
2073
2074 void free_nodesystem(void) 
2075 {
2076         free_typeinfos(&ntreeGetType(NTREE_COMPOSIT)->node_types);
2077         free_typeinfos(&ntreeGetType(NTREE_SHADER)->node_types);
2078         free_typeinfos(&ntreeGetType(NTREE_TEXTURE)->node_types);
2079 }
2080
2081 /* called from unlink_scene, when deleting a scene goes over all scenes
2082  * other than the input, checks if they have render layer nodes referencing
2083  * the to-be-deleted scene, and resets them to NULL. */
2084
2085 /* XXX needs to get current scene then! */
2086 void clear_scene_in_nodes(Main *bmain, Scene *sce)
2087 {
2088         Scene *sce1;
2089         bNode *node;
2090
2091         for(sce1= bmain->scene.first; sce1; sce1=sce1->id.next) {
2092                 if(sce1!=sce) {
2093                         if(sce1->nodetree) {
2094                                 for(node= sce1->nodetree->nodes.first; node; node= node->next) {
2095                                         if(node->type==CMP_NODE_R_LAYERS) {
2096                                                 Scene *nodesce= (Scene *)node->id;
2097                                                 
2098                                                 if (nodesce==sce) node->id = NULL;
2099                                         }
2100                                 }
2101                         }
2102                 }
2103         }
2104 }
2105