Implements a new operator for detaching nodes. In the process i overhauled the node...
[blender-staging.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 /* ************** dependency stuff *********** */
1373
1374 /* node is guaranteed to be not checked before */
1375 static int node_get_deplist_recurs(bNode *node, bNode ***nsort)
1376 {
1377         bNode *fromnode;
1378         bNodeSocket *sock;
1379         int level = 0xFFF;
1380         
1381         node->done= 1;
1382         
1383         /* check linked nodes */
1384         for(sock= node->inputs.first; sock; sock= sock->next) {
1385                 if(sock->link) {
1386                         fromnode= sock->link->fromnode;
1387                         if(fromnode) {
1388                                 if (fromnode->done==0)
1389                                         fromnode->level= node_get_deplist_recurs(fromnode, nsort);
1390                                 if (fromnode->level <= level)
1391                                         level = fromnode->level - 1;
1392                         }
1393                 }
1394         }
1395         
1396         /* check parent node */
1397         if (node->parent) {
1398                 if (node->parent->done==0)
1399                         node->parent->level= node_get_deplist_recurs(node->parent, nsort);
1400                 if (node->parent->level <= level)
1401                         level = node->parent->level - 1;
1402         }
1403         
1404         if (nsort) {
1405                 **nsort= node;
1406                 (*nsort)++;
1407         }
1408         
1409         return level;
1410 }
1411
1412 void ntreeGetDependencyList(struct bNodeTree *ntree, struct bNode ***deplist, int *totnodes)
1413 {
1414         bNode *node, **nsort;
1415         
1416         *totnodes=0;
1417         
1418         /* first clear data */
1419         for(node= ntree->nodes.first; node; node= node->next) {
1420                 node->done= 0;
1421                 (*totnodes)++;
1422         }
1423         if(*totnodes==0) {
1424                 *deplist = NULL;
1425                 return;
1426         }
1427         
1428         nsort= *deplist= MEM_callocN((*totnodes)*sizeof(bNode*), "sorted node array");
1429         
1430         /* recursive check */
1431         for(node= ntree->nodes.first; node; node= node->next) {
1432                 if(node->done==0) {
1433                         node->level= node_get_deplist_recurs(node, &nsort);
1434                 }
1435         }
1436 }
1437
1438 static void ntree_update_link_pointers(bNodeTree *ntree)
1439 {
1440         bNode *node;
1441         bNodeSocket *sock;
1442         bNodeLink *link;
1443         
1444         /* first clear data */
1445         for(node= ntree->nodes.first; node; node= node->next) {
1446                 for(sock= node->inputs.first; sock; sock= sock->next) {
1447                         sock->link= NULL;
1448                         sock->flag &= ~SOCK_IN_USE;
1449                 }
1450                 for(sock= node->outputs.first; sock; sock= sock->next) {
1451                         sock->flag &= ~SOCK_IN_USE;
1452                 }
1453         }
1454         for(sock= ntree->inputs.first; sock; sock= sock->next) {
1455                 sock->flag &= ~SOCK_IN_USE;
1456         }
1457         for(sock= ntree->outputs.first; sock; sock= sock->next) {
1458                 sock->link= NULL;
1459                 sock->flag &= ~SOCK_IN_USE;
1460         }
1461
1462         for(link= ntree->links.first; link; link= link->next) {
1463                 link->tosock->link= link;
1464                 
1465                 link->fromsock->flag |= SOCK_IN_USE;
1466                 link->tosock->flag |= SOCK_IN_USE;
1467         }
1468 }
1469
1470 static void ntree_validate_links(bNodeTree *ntree)
1471 {
1472         bNodeTreeType *ntreetype = ntreeGetType(ntree->type);
1473         bNodeLink *link;
1474         
1475         for (link = ntree->links.first; link; link = link->next) {
1476                 link->flag |= NODE_LINK_VALID;
1477                 if (link->fromnode && link->tonode && link->fromnode->level <= link->tonode->level)
1478                         link->flag &= ~NODE_LINK_VALID;
1479                 else if (ntreetype->validate_link) {
1480                         if (!ntreetype->validate_link(ntree, link))
1481                                 link->flag &= ~NODE_LINK_VALID;
1482                 }
1483         }
1484 }
1485
1486 static void ntree_verify_nodes_cb(void *calldata, struct ID *UNUSED(owner_id), struct bNodeTree *ntree)
1487 {
1488         ID *id= (ID*)calldata;
1489         bNode *node;
1490         
1491         for (node=ntree->nodes.first; node; node=node->next)
1492                 if (node->typeinfo->verifyfunc)
1493                         node->typeinfo->verifyfunc(ntree, node, id);
1494 }
1495
1496 void ntreeVerifyNodes(struct Main *main, struct ID *id)
1497 {
1498         bNodeTreeType *ntreetype;
1499         bNodeTree *ntree;
1500         int n;
1501         
1502         for (n=0; n < NUM_NTREE_TYPES; ++n) {
1503                 ntreetype= ntreeGetType(n);
1504                 if (ntreetype && ntreetype->foreach_nodetree)
1505                         ntreetype->foreach_nodetree(main, id, ntree_verify_nodes_cb);
1506         }
1507         for (ntree=main->nodetree.first; ntree; ntree=ntree->id.next)
1508                 ntree_verify_nodes_cb(id, NULL, ntree);
1509 }
1510
1511 void ntreeUpdateTree(bNodeTree *ntree)
1512 {
1513         bNodeTreeType *ntreetype= ntreeGetType(ntree->type);
1514         bNode *node;
1515         bNode **deplist;
1516         int totnodes, n;
1517         
1518         ntree_update_link_pointers(ntree);
1519         
1520         /* also updates the node level! */
1521         ntreeGetDependencyList(ntree, &deplist, &totnodes);
1522         
1523         if (deplist) {
1524                 /* update individual nodes */
1525                 for (n=0; n < totnodes; ++n) {
1526                         node = deplist[n];
1527                         
1528                         /* node tree update tags override individual node update flags */
1529                         if ((node->update & NODE_UPDATE) || (ntree->update & NTREE_UPDATE)) {
1530                                 if (ntreetype->update_node)
1531                                         ntreetype->update_node(ntree, node);
1532                                 else if (node->typeinfo->updatefunc)
1533                                         node->typeinfo->updatefunc(ntree, node);
1534                         }
1535                         /* clear update flag */
1536                         node->update = 0;
1537                 }
1538                 
1539                 MEM_freeN(deplist);
1540         }
1541         
1542         /* general tree updates */
1543         if (ntree->update & (NTREE_UPDATE_LINKS|NTREE_UPDATE_NODES)) {
1544                 ntree_validate_links(ntree);
1545         }
1546         
1547         /* update tree */
1548         if (ntreetype->update)
1549                 ntreetype->update(ntree);
1550         else {
1551                 /* Trees can be associated with a specific node type (i.e. group nodes),
1552                  * in that case a tree update function may be defined by that node type.
1553                  */
1554                 bNodeType *ntype= node_get_type(ntree, ntree->nodetype);
1555                 if (ntype && ntype->updatetreefunc)
1556                         ntype->updatetreefunc(ntree);
1557         }
1558         
1559         /* XXX hack, should be done by depsgraph!! */
1560         ntreeVerifyNodes(G.main, &ntree->id);
1561         
1562         /* clear the update flag */
1563         ntree->update = 0;
1564 }
1565
1566 void nodeUpdate(bNodeTree *ntree, bNode *node)
1567 {
1568         bNodeTreeType *ntreetype= ntreeGetType(ntree->type);
1569         
1570         if (ntreetype->update_node)
1571                 ntreetype->update_node(ntree, node);
1572         else if (node->typeinfo->updatefunc)
1573                 node->typeinfo->updatefunc(ntree, node);
1574         /* clear update flag */
1575         node->update = 0;
1576 }
1577
1578 int nodeUpdateID(bNodeTree *ntree, ID *id)
1579 {
1580         bNodeTreeType *ntreetype;
1581         bNode *node;
1582         int change = FALSE;
1583         
1584         if(ELEM(NULL, id, ntree))
1585                 return change;
1586         
1587         ntreetype = ntreeGetType(ntree->type);
1588         
1589         if (ntreetype->update_node) {
1590                 for(node= ntree->nodes.first; node; node= node->next) {
1591                         if(node->id==id) {
1592                                 change = TRUE;
1593                                 ntreetype->update_node(ntree, node);
1594                                 /* clear update flag */
1595                                 node->update = 0;
1596                         }
1597                 }
1598         }
1599         else {
1600                 for(node= ntree->nodes.first; node; node= node->next) {
1601                         if(node->id==id) {
1602                                 change = TRUE;
1603                                 if (node->typeinfo->updatefunc)
1604                                         node->typeinfo->updatefunc(ntree, node);
1605                                 /* clear update flag */
1606                                 node->update = 0;
1607                         }
1608                 }
1609         }
1610         
1611         return change;
1612 }
1613
1614
1615 /* ************* node type access ********** */
1616
1617 int nodeValid(bNodeTree *ntree, bNodeTemplate *ntemp)
1618 {
1619         bNodeType *ntype= node_get_type(ntree, ntemp->type);
1620         if (ntype) {
1621                 if (ntype->validfunc)
1622                         return ntype->validfunc(ntree, ntemp);
1623                 else
1624                         return 1;
1625         }
1626         else
1627                 return 0;
1628 }
1629
1630 const char* nodeLabel(bNode *node)
1631 {
1632         if (node->label[0]!='\0')
1633                 return node->label;
1634         else if (node->typeinfo->labelfunc)
1635                 return node->typeinfo->labelfunc(node);
1636         else
1637                 return node->typeinfo->name;
1638 }
1639
1640 struct bNodeTree *nodeGroupEditGet(struct bNode *node)
1641 {
1642         if (node->typeinfo->group_edit_get)
1643                 return node->typeinfo->group_edit_get(node);
1644         else
1645                 return NULL;
1646 }
1647
1648 struct bNodeTree *nodeGroupEditSet(struct bNode *node, int edit)
1649 {
1650         if (node->typeinfo->group_edit_set)
1651                 return node->typeinfo->group_edit_set(node, edit);
1652         else if (node->typeinfo->group_edit_get)
1653                 return node->typeinfo->group_edit_get(node);
1654         else
1655                 return NULL;
1656 }
1657
1658 void nodeGroupEditClear(struct bNode *node)
1659 {
1660         if (node->typeinfo->group_edit_clear)
1661                 node->typeinfo->group_edit_clear(node);
1662 }
1663
1664 struct bNodeTemplate nodeMakeTemplate(struct bNode *node)
1665 {
1666         bNodeTemplate ntemp;
1667         if (node->typeinfo->templatefunc)
1668                 return node->typeinfo->templatefunc(node);
1669         else {
1670                 ntemp.type = node->type;
1671                 return ntemp;
1672         }
1673 }
1674
1675 void node_type_base(bNodeTreeType *ttype, bNodeType *ntype, int type, const char *name, short nclass, short flag)
1676 {
1677         memset(ntype, 0, sizeof(bNodeType));
1678
1679         ntype->type = type;
1680         BLI_strncpy(ntype->name, name, sizeof(ntype->name));
1681         ntype->nclass = nclass;
1682         ntype->flag = flag;
1683
1684         /* Default muting stuff. */
1685         if(ttype)
1686                 ntype->internal_connect = ttype->internal_connect;
1687
1688         /* default size values */
1689         ntype->width = 140;
1690         ntype->minwidth = 100;
1691         ntype->maxwidth = 320;
1692         ntype->height = 100;
1693         ntype->minheight = 30;
1694         ntype->maxheight = FLT_MAX;
1695 }
1696
1697 void node_type_socket_templates(struct bNodeType *ntype, struct bNodeSocketTemplate *inputs, struct bNodeSocketTemplate *outputs)
1698 {
1699         ntype->inputs = inputs;
1700         ntype->outputs = outputs;
1701 }
1702
1703 void node_type_init(struct bNodeType *ntype, void (*initfunc)(struct bNodeTree *ntree, struct bNode *node, struct bNodeTemplate *ntemp))
1704 {
1705         ntype->initfunc = initfunc;
1706 }
1707
1708 void node_type_valid(struct bNodeType *ntype, int (*validfunc)(struct bNodeTree *ntree, struct bNodeTemplate *ntemp))
1709 {
1710         ntype->validfunc = validfunc;
1711 }
1712
1713 void node_type_size(struct bNodeType *ntype, int width, int minwidth, int maxwidth)
1714 {
1715         ntype->width = width;
1716         ntype->minwidth = minwidth;
1717         if (maxwidth <= minwidth)
1718                 ntype->maxwidth = FLT_MAX;
1719         else
1720                 ntype->maxwidth = maxwidth;
1721 }
1722
1723 void node_type_storage(bNodeType *ntype, const char *storagename, void (*freestoragefunc)(struct bNode *), void (*copystoragefunc)(struct bNode *, struct bNode *))
1724 {
1725         if (storagename)
1726                 BLI_strncpy(ntype->storagename, storagename, sizeof(ntype->storagename));
1727         else
1728                 ntype->storagename[0] = '\0';
1729         ntype->copystoragefunc = copystoragefunc;
1730         ntype->freestoragefunc = freestoragefunc;
1731 }
1732
1733 void node_type_label(struct bNodeType *ntype, const char *(*labelfunc)(struct bNode *))
1734 {
1735         ntype->labelfunc = labelfunc;
1736 }
1737
1738 void node_type_template(struct bNodeType *ntype, struct bNodeTemplate (*templatefunc)(struct bNode *))
1739 {
1740         ntype->templatefunc = templatefunc;
1741 }
1742
1743 void node_type_update(struct bNodeType *ntype,
1744                                           void (*updatefunc)(struct bNodeTree *ntree, struct bNode *node),
1745                                           void (*verifyfunc)(struct bNodeTree *ntree, struct bNode *node, struct ID *id))
1746 {
1747         ntype->updatefunc = updatefunc;
1748         ntype->verifyfunc = verifyfunc;
1749 }
1750
1751 void node_type_tree(struct bNodeType *ntype, void (*inittreefunc)(struct bNodeTree *), void (*updatetreefunc)(struct bNodeTree *))
1752 {
1753         ntype->inittreefunc = inittreefunc;
1754         ntype->updatetreefunc = updatetreefunc;
1755 }
1756
1757 void node_type_group_edit(struct bNodeType *ntype,
1758                                                   struct bNodeTree *(*group_edit_get)(struct bNode *node),
1759                                                   struct bNodeTree *(*group_edit_set)(struct bNode *node, int edit),
1760                                                   void (*group_edit_clear)(struct bNode *node))
1761 {
1762         ntype->group_edit_get = group_edit_get;
1763         ntype->group_edit_set = group_edit_set;
1764         ntype->group_edit_clear = group_edit_clear;
1765 }
1766
1767 void node_type_exec(struct bNodeType *ntype, void (*execfunc)(void *data, struct bNode *, struct bNodeStack **, struct bNodeStack **))
1768 {
1769         ntype->execfunc = execfunc;
1770 }
1771
1772 void node_type_exec_new(struct bNodeType *ntype,
1773                                                 void *(*initexecfunc)(struct bNode *node),
1774                                                 void (*freeexecfunc)(struct bNode *node, void *nodedata),
1775                                                 void (*newexecfunc)(void *data, int thread, struct bNode *, void *nodedata, struct bNodeStack **, struct bNodeStack **))
1776 {
1777         ntype->initexecfunc = initexecfunc;
1778         ntype->freeexecfunc = freeexecfunc;
1779         ntype->newexecfunc = newexecfunc;
1780 }
1781
1782 void node_type_internal_connect(bNodeType *ntype, ListBase (*internal_connect)(bNodeTree *, bNode *))
1783 {
1784         ntype->internal_connect = internal_connect;
1785 }
1786
1787 void node_type_gpu(struct bNodeType *ntype, int (*gpufunc)(struct GPUMaterial *mat, struct bNode *node, struct GPUNodeStack *in, struct GPUNodeStack *out))
1788 {
1789         ntype->gpufunc = gpufunc;
1790 }
1791
1792 void node_type_gpu_ext(struct bNodeType *ntype, int (*gpuextfunc)(struct GPUMaterial *mat, struct bNode *node, void *nodedata, struct GPUNodeStack *in, struct GPUNodeStack *out))
1793 {
1794         ntype->gpuextfunc = gpuextfunc;
1795 }
1796
1797 void node_type_compatibility(struct bNodeType *ntype, short compatibility)
1798 {
1799         ntype->compatibility = compatibility;
1800 }
1801
1802 static bNodeType *is_nodetype_registered(ListBase *typelist, int type) 
1803 {
1804         bNodeType *ntype= typelist->first;
1805         
1806         for(;ntype; ntype= ntype->next )
1807                 if(ntype->type==type)
1808                         return ntype;
1809         
1810         return NULL;
1811 }
1812
1813 void nodeRegisterType(bNodeTreeType *ttype, bNodeType *ntype) 
1814 {
1815         ListBase *typelist = &(ttype->node_types);
1816         bNodeType *found= is_nodetype_registered(typelist, ntype->type);
1817         
1818         if(found==NULL)
1819                 BLI_addtail(typelist, ntype);
1820 }
1821
1822 static void registerCompositNodes(bNodeTreeType *ttype)
1823 {
1824         register_node_type_frame(ttype);
1825         
1826         register_node_type_cmp_group(ttype);
1827 //      register_node_type_cmp_forloop(ttype);
1828 //      register_node_type_cmp_whileloop(ttype);
1829         
1830         register_node_type_cmp_rlayers(ttype);
1831         register_node_type_cmp_image(ttype);
1832         register_node_type_cmp_texture(ttype);
1833         register_node_type_cmp_value(ttype);
1834         register_node_type_cmp_rgb(ttype);
1835         register_node_type_cmp_curve_time(ttype);
1836         register_node_type_cmp_movieclip(ttype);
1837         
1838         register_node_type_cmp_composite(ttype);
1839         register_node_type_cmp_viewer(ttype);
1840         register_node_type_cmp_splitviewer(ttype);
1841         register_node_type_cmp_output_file(ttype);
1842         register_node_type_cmp_output_multi_file(ttype);
1843         register_node_type_cmp_view_levels(ttype);
1844         
1845         register_node_type_cmp_curve_rgb(ttype);
1846         register_node_type_cmp_mix_rgb(ttype);
1847         register_node_type_cmp_hue_sat(ttype);
1848         register_node_type_cmp_brightcontrast(ttype);
1849         register_node_type_cmp_gamma(ttype);
1850         register_node_type_cmp_invert(ttype);
1851         register_node_type_cmp_alphaover(ttype);
1852         register_node_type_cmp_zcombine(ttype);
1853         register_node_type_cmp_colorbalance(ttype);
1854         register_node_type_cmp_huecorrect(ttype);
1855         
1856         register_node_type_cmp_normal(ttype);
1857         register_node_type_cmp_curve_vec(ttype);
1858         register_node_type_cmp_map_value(ttype);
1859         register_node_type_cmp_normalize(ttype);
1860         
1861         register_node_type_cmp_filter(ttype);
1862         register_node_type_cmp_blur(ttype);
1863         register_node_type_cmp_dblur(ttype);
1864         register_node_type_cmp_bilateralblur(ttype);
1865         register_node_type_cmp_vecblur(ttype);
1866         register_node_type_cmp_dilateerode(ttype);
1867         register_node_type_cmp_defocus(ttype);
1868         
1869         register_node_type_cmp_valtorgb(ttype);
1870         register_node_type_cmp_rgbtobw(ttype);
1871         register_node_type_cmp_setalpha(ttype);
1872         register_node_type_cmp_idmask(ttype);
1873         register_node_type_cmp_math(ttype);
1874         register_node_type_cmp_seprgba(ttype);
1875         register_node_type_cmp_combrgba(ttype);
1876         register_node_type_cmp_sephsva(ttype);
1877         register_node_type_cmp_combhsva(ttype);
1878         register_node_type_cmp_sepyuva(ttype);
1879         register_node_type_cmp_combyuva(ttype);
1880         register_node_type_cmp_sepycca(ttype);
1881         register_node_type_cmp_combycca(ttype);
1882         register_node_type_cmp_premulkey(ttype);
1883         
1884         register_node_type_cmp_diff_matte(ttype);
1885         register_node_type_cmp_distance_matte(ttype);
1886         register_node_type_cmp_chroma_matte(ttype);
1887         register_node_type_cmp_color_matte(ttype);
1888         register_node_type_cmp_channel_matte(ttype);
1889         register_node_type_cmp_color_spill(ttype);
1890         register_node_type_cmp_luma_matte(ttype);
1891     register_node_type_cmp_doubleedgemask(ttype);
1892
1893         register_node_type_cmp_translate(ttype);
1894         register_node_type_cmp_rotate(ttype);
1895         register_node_type_cmp_scale(ttype);
1896         register_node_type_cmp_flip(ttype);
1897         register_node_type_cmp_crop(ttype);
1898         register_node_type_cmp_displace(ttype);
1899         register_node_type_cmp_mapuv(ttype);
1900         register_node_type_cmp_glare(ttype);
1901         register_node_type_cmp_tonemap(ttype);
1902         register_node_type_cmp_lensdist(ttype);
1903         register_node_type_cmp_transform(ttype);
1904         register_node_type_cmp_stabilize2d(ttype);
1905         register_node_type_cmp_moviedistortion(ttype);
1906 }
1907
1908 static void registerShaderNodes(bNodeTreeType *ttype) 
1909 {
1910         register_node_type_frame(ttype);
1911         
1912         register_node_type_sh_group(ttype);
1913         //register_node_type_sh_forloop(ttype);
1914         //register_node_type_sh_whileloop(ttype);
1915
1916         register_node_type_sh_output(ttype);
1917         register_node_type_sh_material(ttype);
1918         register_node_type_sh_camera(ttype);
1919         register_node_type_sh_gamma(ttype);
1920         register_node_type_sh_brightcontrast(ttype);
1921         register_node_type_sh_value(ttype);
1922         register_node_type_sh_rgb(ttype);
1923         register_node_type_sh_mix_rgb(ttype);
1924         register_node_type_sh_valtorgb(ttype);
1925         register_node_type_sh_rgbtobw(ttype);
1926         register_node_type_sh_texture(ttype);
1927         register_node_type_sh_normal(ttype);
1928         register_node_type_sh_geom(ttype);
1929         register_node_type_sh_mapping(ttype);
1930         register_node_type_sh_curve_vec(ttype);
1931         register_node_type_sh_curve_rgb(ttype);
1932         register_node_type_sh_math(ttype);
1933         register_node_type_sh_vect_math(ttype);
1934         register_node_type_sh_squeeze(ttype);
1935         //register_node_type_sh_dynamic(ttype);
1936         register_node_type_sh_material_ext(ttype);
1937         register_node_type_sh_invert(ttype);
1938         register_node_type_sh_seprgb(ttype);
1939         register_node_type_sh_combrgb(ttype);
1940         register_node_type_sh_hue_sat(ttype);
1941
1942         register_node_type_sh_attribute(ttype);
1943         register_node_type_sh_geometry(ttype);
1944         register_node_type_sh_light_path(ttype);
1945         register_node_type_sh_fresnel(ttype);
1946         register_node_type_sh_layer_weight(ttype);
1947         register_node_type_sh_tex_coord(ttype);
1948
1949         register_node_type_sh_background(ttype);
1950         register_node_type_sh_bsdf_diffuse(ttype);
1951         register_node_type_sh_bsdf_glossy(ttype);
1952         register_node_type_sh_bsdf_glass(ttype);
1953         register_node_type_sh_bsdf_translucent(ttype);
1954         register_node_type_sh_bsdf_transparent(ttype);
1955         register_node_type_sh_bsdf_velvet(ttype);
1956         register_node_type_sh_emission(ttype);
1957         register_node_type_sh_holdout(ttype);
1958         //register_node_type_sh_volume_transparent(ttype);
1959         //register_node_type_sh_volume_isotropic(ttype);
1960         register_node_type_sh_mix_shader(ttype);
1961         register_node_type_sh_add_shader(ttype);
1962
1963         register_node_type_sh_output_lamp(ttype);
1964         register_node_type_sh_output_material(ttype);
1965         register_node_type_sh_output_world(ttype);
1966
1967         register_node_type_sh_tex_image(ttype);
1968         register_node_type_sh_tex_environment(ttype);
1969         register_node_type_sh_tex_sky(ttype);
1970         register_node_type_sh_tex_noise(ttype);
1971         register_node_type_sh_tex_wave(ttype);
1972         register_node_type_sh_tex_voronoi(ttype);
1973         register_node_type_sh_tex_musgrave(ttype);
1974         register_node_type_sh_tex_gradient(ttype);
1975         register_node_type_sh_tex_magic(ttype);
1976         register_node_type_sh_tex_checker(ttype);
1977 }
1978
1979 static void registerTextureNodes(bNodeTreeType *ttype)
1980 {
1981         register_node_type_frame(ttype);
1982         
1983         register_node_type_tex_group(ttype);
1984 //      register_node_type_tex_forloop(ttype);
1985 //      register_node_type_tex_whileloop(ttype);
1986         
1987         register_node_type_tex_math(ttype);
1988         register_node_type_tex_mix_rgb(ttype);
1989         register_node_type_tex_valtorgb(ttype);
1990         register_node_type_tex_rgbtobw(ttype);
1991         register_node_type_tex_valtonor(ttype);
1992         register_node_type_tex_curve_rgb(ttype);
1993         register_node_type_tex_curve_time(ttype);
1994         register_node_type_tex_invert(ttype);
1995         register_node_type_tex_hue_sat(ttype);
1996         register_node_type_tex_coord(ttype);
1997         register_node_type_tex_distance(ttype);
1998         register_node_type_tex_compose(ttype);
1999         register_node_type_tex_decompose(ttype);
2000         
2001         register_node_type_tex_output(ttype);
2002         register_node_type_tex_viewer(ttype);
2003         
2004         register_node_type_tex_checker(ttype);
2005         register_node_type_tex_texture(ttype);
2006         register_node_type_tex_bricks(ttype);
2007         register_node_type_tex_image(ttype);
2008         
2009         register_node_type_tex_rotate(ttype);
2010         register_node_type_tex_translate(ttype);
2011         register_node_type_tex_scale(ttype);
2012         register_node_type_tex_at(ttype);
2013         
2014         register_node_type_tex_proc_voronoi(ttype);
2015         register_node_type_tex_proc_blend(ttype);
2016         register_node_type_tex_proc_magic(ttype);
2017         register_node_type_tex_proc_marble(ttype);
2018         register_node_type_tex_proc_clouds(ttype);
2019         register_node_type_tex_proc_wood(ttype);
2020         register_node_type_tex_proc_musgrave(ttype);
2021         register_node_type_tex_proc_noise(ttype);
2022         register_node_type_tex_proc_stucci(ttype);
2023         register_node_type_tex_proc_distnoise(ttype);
2024 }
2025
2026 static void free_dynamic_typeinfo(bNodeType *ntype)
2027 {
2028         if(ntype->type==NODE_DYNAMIC) {
2029                 if(ntype->inputs) {
2030                         MEM_freeN(ntype->inputs);
2031                 }
2032                 if(ntype->outputs) {
2033                         MEM_freeN(ntype->outputs);
2034                 }
2035                 if(ntype->name) {
2036                         MEM_freeN((void *)ntype->name);
2037                 }
2038         }
2039 }
2040
2041 static void free_typeinfos(ListBase *list)
2042 {
2043         bNodeType *ntype, *next;
2044         for(ntype=list->first; ntype; ntype=next) {
2045                 next = ntype->next;
2046                 
2047                 if(ntype->type==NODE_DYNAMIC)
2048                         free_dynamic_typeinfo(ntype);
2049                 
2050                 if(ntype->needs_free)
2051                         MEM_freeN(ntype);
2052         }
2053 }
2054
2055 void init_nodesystem(void) 
2056 {
2057         registerCompositNodes(ntreeGetType(NTREE_COMPOSIT));
2058         registerShaderNodes(ntreeGetType(NTREE_SHADER));
2059         registerTextureNodes(ntreeGetType(NTREE_TEXTURE));
2060 }
2061
2062 void free_nodesystem(void) 
2063 {
2064         free_typeinfos(&ntreeGetType(NTREE_COMPOSIT)->node_types);
2065         free_typeinfos(&ntreeGetType(NTREE_SHADER)->node_types);
2066         free_typeinfos(&ntreeGetType(NTREE_TEXTURE)->node_types);
2067 }
2068
2069 /* called from unlink_scene, when deleting a scene goes over all scenes
2070  * other than the input, checks if they have render layer nodes referencing
2071  * the to-be-deleted scene, and resets them to NULL. */
2072
2073 /* XXX needs to get current scene then! */
2074 void clear_scene_in_nodes(Main *bmain, Scene *sce)
2075 {
2076         Scene *sce1;
2077         bNode *node;
2078
2079         for(sce1= bmain->scene.first; sce1; sce1=sce1->id.next) {
2080                 if(sce1!=sce) {
2081                         if(sce1->nodetree) {
2082                                 for(node= sce1->nodetree->nodes.first; node; node= node->next) {
2083                                         if(node->type==CMP_NODE_R_LAYERS) {
2084                                                 Scene *nodesce= (Scene *)node->id;
2085                                                 
2086                                                 if (nodesce==sce) node->id = NULL;
2087                                         }
2088                                 }
2089                         }
2090                 }
2091         }
2092 }
2093