Call the node freestorage callback _before_ actually freeing sockets, since this...
[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         if(node->typeinfo && node->typeinfo->freestoragefunc)
913                 node->typeinfo->freestoragefunc(node);
914         
915         for (sock=node->inputs.first; sock; sock = nextsock) {
916                 nextsock = sock->next;
917                 node_socket_free_default_value(sock->type, sock->default_value);
918                 MEM_freeN(sock);
919         }
920         for (sock=node->outputs.first; sock; sock = nextsock) {
921                 nextsock = sock->next;
922                 node_socket_free_default_value(sock->type, sock->default_value);
923                 MEM_freeN(sock);
924         }
925
926         nodeFreePreview(node);
927
928         MEM_freeN(node);
929         
930         ntree->update |= NTREE_UPDATE_NODES;
931 }
932
933 /* do not free ntree itself here, free_libblock calls this function too */
934 void ntreeFreeTree(bNodeTree *ntree)
935 {
936         bNode *node, *next;
937         bNodeSocket *sock;
938         
939         if(ntree==NULL) return;
940         
941         /* XXX hack! node trees should not store execution graphs at all.
942          * This should be removed when old tree types no longer require it.
943          * Currently the execution data for texture nodes remains in the tree
944          * after execution, until the node tree is updated or freed.
945          */
946         if (ntree->execdata) {
947                 switch (ntree->type) {
948                 case NTREE_COMPOSIT:
949                         ntreeCompositEndExecTree(ntree->execdata, 1);
950                         break;
951                 case NTREE_SHADER:
952                         ntreeShaderEndExecTree(ntree->execdata, 1);
953                         break;
954                 case NTREE_TEXTURE:
955                         ntreeTexEndExecTree(ntree->execdata, 1);
956                         break;
957                 }
958         }
959         
960         BKE_free_animdata((ID *)ntree);
961         
962         id_us_min((ID *)ntree->gpd);
963
964         BLI_freelistN(&ntree->links);   /* do first, then unlink_node goes fast */
965         
966         for(node= ntree->nodes.first; node; node= next) {
967                 next= node->next;
968                 nodeFreeNode(ntree, node);
969         }
970         
971         for (sock=ntree->inputs.first; sock; sock=sock->next)
972                 node_socket_free_default_value(sock->type, sock->default_value);
973         BLI_freelistN(&ntree->inputs);
974         for (sock=ntree->outputs.first; sock; sock=sock->next)
975                 node_socket_free_default_value(sock->type, sock->default_value);
976         BLI_freelistN(&ntree->outputs);
977 }
978
979 void ntreeFreeCache(bNodeTree *ntree)
980 {
981         bNodeTreeType *treetype;
982         
983         if(ntree==NULL) return;
984         
985         treetype= ntreeGetType(ntree->type);
986         if (treetype->free_cache)
987                 treetype->free_cache(ntree);
988 }
989
990 void ntreeSetOutput(bNodeTree *ntree)
991 {
992         bNode *node;
993
994         /* find the active outputs, might become tree type dependant handler */
995         for(node= ntree->nodes.first; node; node= node->next) {
996                 if(node->typeinfo->nclass==NODE_CLASS_OUTPUT) {
997                         bNode *tnode;
998                         int output= 0;
999                         
1000                         /* we need a check for which output node should be tagged like this, below an exception */
1001                         if(node->type==CMP_NODE_OUTPUT_FILE)
1002                                 continue;
1003
1004                         /* there is more types having output class, each one is checked */
1005                         for(tnode= ntree->nodes.first; tnode; tnode= tnode->next) {
1006                                 if(tnode->typeinfo->nclass==NODE_CLASS_OUTPUT) {
1007                                         
1008                                         if(ntree->type==NTREE_COMPOSIT) {
1009                                                         
1010                                                 /* same type, exception for viewer */
1011                                                 if(tnode->type==node->type ||
1012                                                    (ELEM(tnode->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER) &&
1013                                                         ELEM(node->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER))) {
1014                                                         if(tnode->flag & NODE_DO_OUTPUT) {
1015                                                                 output++;
1016                                                                 if(output>1)
1017                                                                         tnode->flag &= ~NODE_DO_OUTPUT;
1018                                                         }
1019                                                 }
1020                                         }
1021                                         else {
1022                                                 /* same type */
1023                                                 if(tnode->type==node->type) {
1024                                                         if(tnode->flag & NODE_DO_OUTPUT) {
1025                                                                 output++;
1026                                                                 if(output>1)
1027                                                                         tnode->flag &= ~NODE_DO_OUTPUT;
1028                                                         }
1029                                                 }
1030                                         }
1031                                 }
1032                         }
1033                         if(output==0)
1034                                 node->flag |= NODE_DO_OUTPUT;
1035                 }
1036         }
1037         
1038         /* here we could recursively set which nodes have to be done,
1039                 might be different for editor or for "real" use... */
1040 }
1041
1042 typedef struct MakeLocalCallData {
1043         ID *group_id;
1044         ID *new_id;
1045         int lib, local;
1046 } MakeLocalCallData;
1047
1048 static void ntreeMakeLocal_CheckLocal(void *calldata, ID *owner_id, bNodeTree *ntree)
1049 {
1050         MakeLocalCallData *cd= (MakeLocalCallData*)calldata;
1051         bNode *node;
1052         
1053         /* find if group is in tree */
1054         for(node= ntree->nodes.first; node; node= node->next) {
1055                 if(node->id == cd->group_id) {
1056                         if(owner_id->lib) cd->lib= 1;
1057                         else cd->local= 1;
1058                 }
1059         }
1060 }
1061
1062 static void ntreeMakeLocal_LinkNew(void *calldata, ID *owner_id, bNodeTree *ntree)
1063 {
1064         MakeLocalCallData *cd= (MakeLocalCallData*)calldata;
1065         bNode *node;
1066         
1067         /* find if group is in tree */
1068         for(node= ntree->nodes.first; node; node= node->next) {
1069                 if(node->id == cd->group_id) {
1070                         if(owner_id->lib==NULL) {
1071                                 node->id= cd->new_id;
1072                                 cd->new_id->us++;
1073                                 cd->group_id->us--;
1074                         }
1075                 }
1076         }
1077 }
1078
1079 void ntreeMakeLocal(bNodeTree *ntree)
1080 {
1081         Main *bmain= G.main;
1082         bNodeTreeType *treetype= ntreeGetType(ntree->type);
1083         MakeLocalCallData cd;
1084         
1085         /* - only lib users: do nothing
1086                 * - only local users: set flag
1087                 * - mixed: make copy
1088                 */
1089         
1090         if(ntree->id.lib==NULL) return;
1091         if(ntree->id.us==1) {
1092                 id_clear_lib_data(bmain, (ID *)ntree);
1093                 return;
1094         }
1095         
1096         /* now check users of groups... again typedepending, callback... */
1097         cd.group_id = &ntree->id;
1098         cd.new_id = NULL;
1099         cd.local = 0;
1100         cd.lib = 0;
1101         
1102         treetype->foreach_nodetree(G.main, &cd, &ntreeMakeLocal_CheckLocal);
1103         
1104         /* if all users are local, we simply make tree local */
1105         if(cd.local && cd.lib==0) {
1106                 id_clear_lib_data(bmain, (ID *)ntree);
1107         }
1108         else if(cd.local && cd.lib) {
1109                 /* this is the mixed case, we copy the tree and assign it to local users */
1110                 bNodeTree *newtree= ntreeCopyTree(ntree);
1111                 
1112                 newtree->id.us= 0;
1113                 
1114
1115                 cd.new_id = &newtree->id;
1116                 treetype->foreach_nodetree(G.main, &cd, &ntreeMakeLocal_LinkNew);
1117         }
1118 }
1119
1120 int ntreeNodeExists(bNodeTree *ntree, bNode *testnode)
1121 {
1122         bNode *node= ntree->nodes.first;
1123         for(; node; node= node->next)
1124                 if(node==testnode)
1125                         return 1;
1126         return 0;
1127 }
1128
1129 int ntreeOutputExists(bNode *node, bNodeSocket *testsock)
1130 {
1131         bNodeSocket *sock= node->outputs.first;
1132         for(; sock; sock= sock->next)
1133                 if(sock==testsock)
1134                         return 1;
1135         return 0;
1136 }
1137
1138 /* returns localized tree for execution in threads */
1139 bNodeTree *ntreeLocalize(bNodeTree *ntree)
1140 {
1141         bNodeTreeType *ntreetype= ntreeGetType(ntree->type);
1142
1143         bNodeTree *ltree;
1144         bNode *node;
1145         
1146         bAction *action_backup= NULL, *tmpact_backup= NULL;
1147         
1148         /* Workaround for copying an action on each render!
1149          * set action to NULL so animdata actions dont get copied */
1150         AnimData *adt= BKE_animdata_from_id(&ntree->id);
1151
1152         if(adt) {
1153                 action_backup= adt->action;
1154                 tmpact_backup= adt->tmpact;
1155
1156                 adt->action= NULL;
1157                 adt->tmpact= NULL;
1158         }
1159
1160         /* node copy func */
1161         ltree= ntreeCopyTree(ntree);
1162
1163         if(adt) {
1164                 AnimData *ladt= BKE_animdata_from_id(&ltree->id);
1165
1166                 adt->action= ladt->action= action_backup;
1167                 adt->tmpact= ladt->tmpact= tmpact_backup;
1168
1169                 if(action_backup) action_backup->id.us++;
1170                 if(tmpact_backup) tmpact_backup->id.us++;
1171                 
1172         }
1173         /* end animdata uglyness */
1174
1175         /* ensures only a single output node is enabled */
1176         ntreeSetOutput(ntree);
1177
1178         for(node= ntree->nodes.first; node; node= node->next) {
1179                 /* store new_node pointer to original */
1180                 node->new_node->new_node= node;
1181         }
1182
1183         if (ntreetype->localize)
1184                 ntreetype->localize(ltree, ntree);
1185
1186         return ltree;
1187 }
1188
1189 /* sync local composite with real tree */
1190 /* local tree is supposed to be running, be careful moving previews! */
1191 /* is called by jobs manager, outside threads, so it doesnt happen during draw */
1192 void ntreeLocalSync(bNodeTree *localtree, bNodeTree *ntree)
1193 {
1194         bNodeTreeType *ntreetype= ntreeGetType(ntree->type);
1195
1196         if (ntreetype->local_sync)
1197                 ntreetype->local_sync(localtree, ntree);
1198 }
1199
1200 /* merge local tree results back, and free local tree */
1201 /* we have to assume the editor already changed completely */
1202 void ntreeLocalMerge(bNodeTree *localtree, bNodeTree *ntree)
1203 {
1204         bNodeTreeType *ntreetype= ntreeGetType(ntree->type);
1205         bNode *lnode;
1206         
1207         /* move over the compbufs and previews */
1208         for(lnode= localtree->nodes.first; lnode; lnode= lnode->next) {
1209                 if(ntreeNodeExists(ntree, lnode->new_node)) {
1210                         if(lnode->preview && lnode->preview->rect) {
1211                                 nodeFreePreview(lnode->new_node);
1212                                 lnode->new_node->preview= lnode->preview;
1213                                 lnode->preview= NULL;
1214                         }
1215                 }
1216         }
1217
1218         if (ntreetype->local_merge)
1219                 ntreetype->local_merge(localtree, ntree);
1220
1221         ntreeFreeTree(localtree);
1222         MEM_freeN(localtree);
1223 }
1224
1225 /* ************ find stuff *************** */
1226
1227 int ntreeHasType(bNodeTree *ntree, int type)
1228 {
1229         bNode *node;
1230         
1231         if(ntree)
1232                 for(node= ntree->nodes.first; node; node= node->next)
1233                         if(node->type == type)
1234                                 return 1;
1235         return 0;
1236 }
1237
1238 bNodeLink *nodeFindLink(bNodeTree *ntree, bNodeSocket *from, bNodeSocket *to)
1239 {
1240         bNodeLink *link;
1241         
1242         for(link= ntree->links.first; link; link= link->next) {
1243                 if(link->fromsock==from && link->tosock==to)
1244                         return link;
1245                 if(link->fromsock==to && link->tosock==from)    /* hrms? */
1246                         return link;
1247         }
1248         return NULL;
1249 }
1250
1251 int nodeCountSocketLinks(bNodeTree *ntree, bNodeSocket *sock)
1252 {
1253         bNodeLink *link;
1254         int tot= 0;
1255         
1256         for(link= ntree->links.first; link; link= link->next) {
1257                 if(link->fromsock==sock || link->tosock==sock)
1258                         tot++;
1259         }
1260         return tot;
1261 }
1262
1263 bNode *nodeGetActive(bNodeTree *ntree)
1264 {
1265         bNode *node;
1266         
1267         if(ntree==NULL) return NULL;
1268         
1269         for(node= ntree->nodes.first; node; node= node->next)
1270                 if(node->flag & NODE_ACTIVE)
1271                         break;
1272         return node;
1273 }
1274
1275 /* two active flags, ID nodes have special flag for buttons display */
1276 bNode *nodeGetActiveID(bNodeTree *ntree, short idtype)
1277 {
1278         bNode *node;
1279         
1280         if(ntree==NULL) return NULL;
1281
1282         /* check for group edit */
1283         for(node= ntree->nodes.first; node; node= node->next)
1284                 if(node->flag & NODE_GROUP_EDIT)
1285                         break;
1286
1287         if(node)
1288                 ntree= (bNodeTree*)node->id;
1289         
1290         /* now find active node with this id */
1291         for(node= ntree->nodes.first; node; node= node->next)
1292                 if(node->id && GS(node->id->name)==idtype)
1293                         if(node->flag & NODE_ACTIVE_ID)
1294                                 break;
1295
1296         return node;
1297 }
1298
1299 int nodeSetActiveID(bNodeTree *ntree, short idtype, ID *id)
1300 {
1301         bNode *node;
1302         int ok= FALSE;
1303
1304         if(ntree==NULL) return ok;
1305
1306         /* check for group edit */
1307         for(node= ntree->nodes.first; node; node= node->next)
1308                 if(node->flag & NODE_GROUP_EDIT)
1309                         break;
1310
1311         if(node)
1312                 ntree= (bNodeTree*)node->id;
1313
1314         /* now find active node with this id */
1315         for(node= ntree->nodes.first; node; node= node->next) {
1316                 if(node->id && GS(node->id->name)==idtype) {
1317                         if(id && ok==FALSE && node->id==id) {
1318                                 node->flag |= NODE_ACTIVE_ID;
1319                                 ok= TRUE;
1320                         } else {
1321                                 node->flag &= ~NODE_ACTIVE_ID;
1322                         }
1323                 }
1324         }
1325
1326         return ok;
1327 }
1328
1329
1330 /* two active flags, ID nodes have special flag for buttons display */
1331 void nodeClearActiveID(bNodeTree *ntree, short idtype)
1332 {
1333         bNode *node;
1334         
1335         if(ntree==NULL) return;
1336         
1337         for(node= ntree->nodes.first; node; node= node->next)
1338                 if(node->id && GS(node->id->name)==idtype)
1339                         node->flag &= ~NODE_ACTIVE_ID;
1340 }
1341
1342 /* two active flags, ID nodes have special flag for buttons display */
1343 void nodeSetActive(bNodeTree *ntree, bNode *node)
1344 {
1345         bNode *tnode;
1346         
1347         /* make sure only one node is active, and only one per ID type */
1348         for(tnode= ntree->nodes.first; tnode; tnode= tnode->next) {
1349                 tnode->flag &= ~NODE_ACTIVE;
1350                 
1351                 if(node->id && tnode->id) {
1352                         if(GS(node->id->name) == GS(tnode->id->name))
1353                                 tnode->flag &= ~NODE_ACTIVE_ID;
1354                 }
1355                 if(node->typeinfo->nclass == NODE_CLASS_TEXTURE)
1356                         tnode->flag &= ~NODE_ACTIVE_TEXTURE;
1357         }
1358         
1359         node->flag |= NODE_ACTIVE;
1360         if(node->id)
1361                 node->flag |= NODE_ACTIVE_ID;
1362         if(node->typeinfo->nclass == NODE_CLASS_TEXTURE)
1363                 node->flag |= NODE_ACTIVE_TEXTURE;
1364 }
1365
1366 int nodeSocketIsHidden(bNodeSocket *sock)
1367 {
1368         return ((sock->flag & (SOCK_HIDDEN | SOCK_AUTO_HIDDEN | SOCK_UNAVAIL)) != 0);
1369 }
1370
1371 void nodeSocketSetType(bNodeSocket *sock, int type)
1372 {
1373         int old_type = sock->type;
1374         void *old_default_value = sock->default_value;
1375         
1376         sock->type = type;
1377         
1378         sock->default_value = node_socket_make_default_value(sock->type);
1379         node_socket_init_default_value(type, sock->default_value);
1380         node_socket_convert_default_value(sock->type, sock->default_value, old_type, old_default_value);
1381         node_socket_free_default_value(old_type, old_default_value);
1382 }
1383
1384 /* ************** dependency stuff *********** */
1385
1386 /* node is guaranteed to be not checked before */
1387 static int node_get_deplist_recurs(bNode *node, bNode ***nsort)
1388 {
1389         bNode *fromnode;
1390         bNodeSocket *sock;
1391         int level = 0xFFF;
1392         
1393         node->done= 1;
1394         
1395         /* check linked nodes */
1396         for(sock= node->inputs.first; sock; sock= sock->next) {
1397                 if(sock->link) {
1398                         fromnode= sock->link->fromnode;
1399                         if(fromnode) {
1400                                 if (fromnode->done==0)
1401                                         fromnode->level= node_get_deplist_recurs(fromnode, nsort);
1402                                 if (fromnode->level <= level)
1403                                         level = fromnode->level - 1;
1404                         }
1405                 }
1406         }
1407         
1408         /* check parent node */
1409         if (node->parent) {
1410                 if (node->parent->done==0)
1411                         node->parent->level= node_get_deplist_recurs(node->parent, nsort);
1412                 if (node->parent->level <= level)
1413                         level = node->parent->level - 1;
1414         }
1415         
1416         if (nsort) {
1417                 **nsort= node;
1418                 (*nsort)++;
1419         }
1420         
1421         return level;
1422 }
1423
1424 void ntreeGetDependencyList(struct bNodeTree *ntree, struct bNode ***deplist, int *totnodes)
1425 {
1426         bNode *node, **nsort;
1427         
1428         *totnodes=0;
1429         
1430         /* first clear data */
1431         for(node= ntree->nodes.first; node; node= node->next) {
1432                 node->done= 0;
1433                 (*totnodes)++;
1434         }
1435         if(*totnodes==0) {
1436                 *deplist = NULL;
1437                 return;
1438         }
1439         
1440         nsort= *deplist= MEM_callocN((*totnodes)*sizeof(bNode*), "sorted node array");
1441         
1442         /* recursive check */
1443         for(node= ntree->nodes.first; node; node= node->next) {
1444                 if(node->done==0) {
1445                         node->level= node_get_deplist_recurs(node, &nsort);
1446                 }
1447         }
1448 }
1449
1450 static void ntree_update_link_pointers(bNodeTree *ntree)
1451 {
1452         bNode *node;
1453         bNodeSocket *sock;
1454         bNodeLink *link;
1455         
1456         /* first clear data */
1457         for(node= ntree->nodes.first; node; node= node->next) {
1458                 for(sock= node->inputs.first; sock; sock= sock->next) {
1459                         sock->link= NULL;
1460                         sock->flag &= ~SOCK_IN_USE;
1461                 }
1462                 for(sock= node->outputs.first; sock; sock= sock->next) {
1463                         sock->flag &= ~SOCK_IN_USE;
1464                 }
1465         }
1466         for(sock= ntree->inputs.first; sock; sock= sock->next) {
1467                 sock->flag &= ~SOCK_IN_USE;
1468         }
1469         for(sock= ntree->outputs.first; sock; sock= sock->next) {
1470                 sock->link= NULL;
1471                 sock->flag &= ~SOCK_IN_USE;
1472         }
1473
1474         for(link= ntree->links.first; link; link= link->next) {
1475                 link->tosock->link= link;
1476                 
1477                 link->fromsock->flag |= SOCK_IN_USE;
1478                 link->tosock->flag |= SOCK_IN_USE;
1479         }
1480 }
1481
1482 static void ntree_validate_links(bNodeTree *ntree)
1483 {
1484         bNodeTreeType *ntreetype = ntreeGetType(ntree->type);
1485         bNodeLink *link;
1486         
1487         for (link = ntree->links.first; link; link = link->next) {
1488                 link->flag |= NODE_LINK_VALID;
1489                 if (link->fromnode && link->tonode && link->fromnode->level <= link->tonode->level)
1490                         link->flag &= ~NODE_LINK_VALID;
1491                 else if (ntreetype->validate_link) {
1492                         if (!ntreetype->validate_link(ntree, link))
1493                                 link->flag &= ~NODE_LINK_VALID;
1494                 }
1495         }
1496 }
1497
1498 static void ntree_verify_nodes_cb(void *calldata, struct ID *UNUSED(owner_id), struct bNodeTree *ntree)
1499 {
1500         ID *id= (ID*)calldata;
1501         bNode *node;
1502         
1503         for (node=ntree->nodes.first; node; node=node->next)
1504                 if (node->typeinfo->verifyfunc)
1505                         node->typeinfo->verifyfunc(ntree, node, id);
1506 }
1507
1508 void ntreeVerifyNodes(struct Main *main, struct ID *id)
1509 {
1510         bNodeTreeType *ntreetype;
1511         bNodeTree *ntree;
1512         int n;
1513         
1514         for (n=0; n < NUM_NTREE_TYPES; ++n) {
1515                 ntreetype= ntreeGetType(n);
1516                 if (ntreetype && ntreetype->foreach_nodetree)
1517                         ntreetype->foreach_nodetree(main, id, ntree_verify_nodes_cb);
1518         }
1519         for (ntree=main->nodetree.first; ntree; ntree=ntree->id.next)
1520                 ntree_verify_nodes_cb(id, NULL, ntree);
1521 }
1522
1523 void ntreeUpdateTree(bNodeTree *ntree)
1524 {
1525         bNodeTreeType *ntreetype= ntreeGetType(ntree->type);
1526         bNode *node;
1527         bNode **deplist;
1528         int totnodes, n;
1529         
1530         ntree_update_link_pointers(ntree);
1531         
1532         /* also updates the node level! */
1533         ntreeGetDependencyList(ntree, &deplist, &totnodes);
1534         
1535         if (deplist) {
1536                 /* update individual nodes */
1537                 for (n=0; n < totnodes; ++n) {
1538                         node = deplist[n];
1539                         
1540                         /* node tree update tags override individual node update flags */
1541                         if ((node->update & NODE_UPDATE) || (ntree->update & NTREE_UPDATE)) {
1542                                 if (ntreetype->update_node)
1543                                         ntreetype->update_node(ntree, node);
1544                                 else if (node->typeinfo->updatefunc)
1545                                         node->typeinfo->updatefunc(ntree, node);
1546                         }
1547                         /* clear update flag */
1548                         node->update = 0;
1549                 }
1550                 
1551                 MEM_freeN(deplist);
1552         }
1553         
1554         /* general tree updates */
1555         if (ntree->update & (NTREE_UPDATE_LINKS|NTREE_UPDATE_NODES)) {
1556                 ntree_validate_links(ntree);
1557         }
1558         
1559         /* update tree */
1560         if (ntreetype->update)
1561                 ntreetype->update(ntree);
1562         else {
1563                 /* Trees can be associated with a specific node type (i.e. group nodes),
1564                  * in that case a tree update function may be defined by that node type.
1565                  */
1566                 bNodeType *ntype= node_get_type(ntree, ntree->nodetype);
1567                 if (ntype && ntype->updatetreefunc)
1568                         ntype->updatetreefunc(ntree);
1569         }
1570         
1571         /* XXX hack, should be done by depsgraph!! */
1572         ntreeVerifyNodes(G.main, &ntree->id);
1573         
1574         /* clear the update flag */
1575         ntree->update = 0;
1576 }
1577
1578 void nodeUpdate(bNodeTree *ntree, bNode *node)
1579 {
1580         bNodeTreeType *ntreetype= ntreeGetType(ntree->type);
1581         
1582         if (ntreetype->update_node)
1583                 ntreetype->update_node(ntree, node);
1584         else if (node->typeinfo->updatefunc)
1585                 node->typeinfo->updatefunc(ntree, node);
1586         /* clear update flag */
1587         node->update = 0;
1588 }
1589
1590 int nodeUpdateID(bNodeTree *ntree, ID *id)
1591 {
1592         bNodeTreeType *ntreetype;
1593         bNode *node;
1594         int change = FALSE;
1595         
1596         if(ELEM(NULL, id, ntree))
1597                 return change;
1598         
1599         ntreetype = ntreeGetType(ntree->type);
1600         
1601         if (ntreetype->update_node) {
1602                 for(node= ntree->nodes.first; node; node= node->next) {
1603                         if(node->id==id) {
1604                                 change = TRUE;
1605                                 ntreetype->update_node(ntree, node);
1606                                 /* clear update flag */
1607                                 node->update = 0;
1608                         }
1609                 }
1610         }
1611         else {
1612                 for(node= ntree->nodes.first; node; node= node->next) {
1613                         if(node->id==id) {
1614                                 change = TRUE;
1615                                 if (node->typeinfo->updatefunc)
1616                                         node->typeinfo->updatefunc(ntree, node);
1617                                 /* clear update flag */
1618                                 node->update = 0;
1619                         }
1620                 }
1621         }
1622         
1623         return change;
1624 }
1625
1626
1627 /* ************* node type access ********** */
1628
1629 int nodeValid(bNodeTree *ntree, bNodeTemplate *ntemp)
1630 {
1631         bNodeType *ntype= node_get_type(ntree, ntemp->type);
1632         if (ntype) {
1633                 if (ntype->validfunc)
1634                         return ntype->validfunc(ntree, ntemp);
1635                 else
1636                         return 1;
1637         }
1638         else
1639                 return 0;
1640 }
1641
1642 const char* nodeLabel(bNode *node)
1643 {
1644         if (node->label[0]!='\0')
1645                 return node->label;
1646         else if (node->typeinfo->labelfunc)
1647                 return node->typeinfo->labelfunc(node);
1648         else
1649                 return node->typeinfo->name;
1650 }
1651
1652 struct bNodeTree *nodeGroupEditGet(struct bNode *node)
1653 {
1654         if (node->typeinfo->group_edit_get)
1655                 return node->typeinfo->group_edit_get(node);
1656         else
1657                 return NULL;
1658 }
1659
1660 struct bNodeTree *nodeGroupEditSet(struct bNode *node, int edit)
1661 {
1662         if (node->typeinfo->group_edit_set)
1663                 return node->typeinfo->group_edit_set(node, edit);
1664         else if (node->typeinfo->group_edit_get)
1665                 return node->typeinfo->group_edit_get(node);
1666         else
1667                 return NULL;
1668 }
1669
1670 void nodeGroupEditClear(struct bNode *node)
1671 {
1672         if (node->typeinfo->group_edit_clear)
1673                 node->typeinfo->group_edit_clear(node);
1674 }
1675
1676 struct bNodeTemplate nodeMakeTemplate(struct bNode *node)
1677 {
1678         bNodeTemplate ntemp;
1679         if (node->typeinfo->templatefunc)
1680                 return node->typeinfo->templatefunc(node);
1681         else {
1682                 ntemp.type = node->type;
1683                 return ntemp;
1684         }
1685 }
1686
1687 void node_type_base(bNodeTreeType *ttype, bNodeType *ntype, int type, const char *name, short nclass, short flag)
1688 {
1689         memset(ntype, 0, sizeof(bNodeType));
1690
1691         ntype->type = type;
1692         BLI_strncpy(ntype->name, name, sizeof(ntype->name));
1693         ntype->nclass = nclass;
1694         ntype->flag = flag;
1695
1696         /* Default muting stuff. */
1697         if(ttype)
1698                 ntype->internal_connect = ttype->internal_connect;
1699
1700         /* default size values */
1701         ntype->width = 140;
1702         ntype->minwidth = 100;
1703         ntype->maxwidth = 320;
1704         ntype->height = 100;
1705         ntype->minheight = 30;
1706         ntype->maxheight = FLT_MAX;
1707 }
1708
1709 void node_type_socket_templates(struct bNodeType *ntype, struct bNodeSocketTemplate *inputs, struct bNodeSocketTemplate *outputs)
1710 {
1711         ntype->inputs = inputs;
1712         ntype->outputs = outputs;
1713 }
1714
1715 void node_type_init(struct bNodeType *ntype, void (*initfunc)(struct bNodeTree *ntree, struct bNode *node, struct bNodeTemplate *ntemp))
1716 {
1717         ntype->initfunc = initfunc;
1718 }
1719
1720 void node_type_valid(struct bNodeType *ntype, int (*validfunc)(struct bNodeTree *ntree, struct bNodeTemplate *ntemp))
1721 {
1722         ntype->validfunc = validfunc;
1723 }
1724
1725 void node_type_size(struct bNodeType *ntype, int width, int minwidth, int maxwidth)
1726 {
1727         ntype->width = width;
1728         ntype->minwidth = minwidth;
1729         if (maxwidth <= minwidth)
1730                 ntype->maxwidth = FLT_MAX;
1731         else
1732                 ntype->maxwidth = maxwidth;
1733 }
1734
1735 void node_type_storage(bNodeType *ntype, const char *storagename, void (*freestoragefunc)(struct bNode *), void (*copystoragefunc)(struct bNode *, struct bNode *))
1736 {
1737         if (storagename)
1738                 BLI_strncpy(ntype->storagename, storagename, sizeof(ntype->storagename));
1739         else
1740                 ntype->storagename[0] = '\0';
1741         ntype->copystoragefunc = copystoragefunc;
1742         ntype->freestoragefunc = freestoragefunc;
1743 }
1744
1745 void node_type_label(struct bNodeType *ntype, const char *(*labelfunc)(struct bNode *))
1746 {
1747         ntype->labelfunc = labelfunc;
1748 }
1749
1750 void node_type_template(struct bNodeType *ntype, struct bNodeTemplate (*templatefunc)(struct bNode *))
1751 {
1752         ntype->templatefunc = templatefunc;
1753 }
1754
1755 void node_type_update(struct bNodeType *ntype,
1756                                           void (*updatefunc)(struct bNodeTree *ntree, struct bNode *node),
1757                                           void (*verifyfunc)(struct bNodeTree *ntree, struct bNode *node, struct ID *id))
1758 {
1759         ntype->updatefunc = updatefunc;
1760         ntype->verifyfunc = verifyfunc;
1761 }
1762
1763 void node_type_tree(struct bNodeType *ntype, void (*inittreefunc)(struct bNodeTree *), void (*updatetreefunc)(struct bNodeTree *))
1764 {
1765         ntype->inittreefunc = inittreefunc;
1766         ntype->updatetreefunc = updatetreefunc;
1767 }
1768
1769 void node_type_group_edit(struct bNodeType *ntype,
1770                                                   struct bNodeTree *(*group_edit_get)(struct bNode *node),
1771                                                   struct bNodeTree *(*group_edit_set)(struct bNode *node, int edit),
1772                                                   void (*group_edit_clear)(struct bNode *node))
1773 {
1774         ntype->group_edit_get = group_edit_get;
1775         ntype->group_edit_set = group_edit_set;
1776         ntype->group_edit_clear = group_edit_clear;
1777 }
1778
1779 void node_type_exec(struct bNodeType *ntype, void (*execfunc)(void *data, struct bNode *, struct bNodeStack **, struct bNodeStack **))
1780 {
1781         ntype->execfunc = execfunc;
1782 }
1783
1784 void node_type_exec_new(struct bNodeType *ntype,
1785                                                 void *(*initexecfunc)(struct bNode *node),
1786                                                 void (*freeexecfunc)(struct bNode *node, void *nodedata),
1787                                                 void (*newexecfunc)(void *data, int thread, struct bNode *, void *nodedata, struct bNodeStack **, struct bNodeStack **))
1788 {
1789         ntype->initexecfunc = initexecfunc;
1790         ntype->freeexecfunc = freeexecfunc;
1791         ntype->newexecfunc = newexecfunc;
1792 }
1793
1794 void node_type_internal_connect(bNodeType *ntype, ListBase (*internal_connect)(bNodeTree *, bNode *))
1795 {
1796         ntype->internal_connect = internal_connect;
1797 }
1798
1799 void node_type_gpu(struct bNodeType *ntype, int (*gpufunc)(struct GPUMaterial *mat, struct bNode *node, struct GPUNodeStack *in, struct GPUNodeStack *out))
1800 {
1801         ntype->gpufunc = gpufunc;
1802 }
1803
1804 void node_type_gpu_ext(struct bNodeType *ntype, int (*gpuextfunc)(struct GPUMaterial *mat, struct bNode *node, void *nodedata, struct GPUNodeStack *in, struct GPUNodeStack *out))
1805 {
1806         ntype->gpuextfunc = gpuextfunc;
1807 }
1808
1809 void node_type_compatibility(struct bNodeType *ntype, short compatibility)
1810 {
1811         ntype->compatibility = compatibility;
1812 }
1813
1814 static bNodeType *is_nodetype_registered(ListBase *typelist, int type) 
1815 {
1816         bNodeType *ntype= typelist->first;
1817         
1818         for(;ntype; ntype= ntype->next )
1819                 if(ntype->type==type)
1820                         return ntype;
1821         
1822         return NULL;
1823 }
1824
1825 void nodeRegisterType(bNodeTreeType *ttype, bNodeType *ntype) 
1826 {
1827         ListBase *typelist = &(ttype->node_types);
1828         bNodeType *found= is_nodetype_registered(typelist, ntype->type);
1829         
1830         if(found==NULL)
1831                 BLI_addtail(typelist, ntype);
1832 }
1833
1834 static void registerCompositNodes(bNodeTreeType *ttype)
1835 {
1836         register_node_type_frame(ttype);
1837         
1838         register_node_type_cmp_group(ttype);
1839 //      register_node_type_cmp_forloop(ttype);
1840 //      register_node_type_cmp_whileloop(ttype);
1841         
1842         register_node_type_cmp_rlayers(ttype);
1843         register_node_type_cmp_image(ttype);
1844         register_node_type_cmp_texture(ttype);
1845         register_node_type_cmp_value(ttype);
1846         register_node_type_cmp_rgb(ttype);
1847         register_node_type_cmp_curve_time(ttype);
1848         register_node_type_cmp_movieclip(ttype);
1849         
1850         register_node_type_cmp_composite(ttype);
1851         register_node_type_cmp_viewer(ttype);
1852         register_node_type_cmp_splitviewer(ttype);
1853         register_node_type_cmp_output_file(ttype);
1854         register_node_type_cmp_view_levels(ttype);
1855         
1856         register_node_type_cmp_curve_rgb(ttype);
1857         register_node_type_cmp_mix_rgb(ttype);
1858         register_node_type_cmp_hue_sat(ttype);
1859         register_node_type_cmp_brightcontrast(ttype);
1860         register_node_type_cmp_gamma(ttype);
1861         register_node_type_cmp_invert(ttype);
1862         register_node_type_cmp_alphaover(ttype);
1863         register_node_type_cmp_zcombine(ttype);
1864         register_node_type_cmp_colorbalance(ttype);
1865         register_node_type_cmp_huecorrect(ttype);
1866         
1867         register_node_type_cmp_normal(ttype);
1868         register_node_type_cmp_curve_vec(ttype);
1869         register_node_type_cmp_map_value(ttype);
1870         register_node_type_cmp_normalize(ttype);
1871         
1872         register_node_type_cmp_filter(ttype);
1873         register_node_type_cmp_blur(ttype);
1874         register_node_type_cmp_dblur(ttype);
1875         register_node_type_cmp_bilateralblur(ttype);
1876         register_node_type_cmp_vecblur(ttype);
1877         register_node_type_cmp_dilateerode(ttype);
1878         register_node_type_cmp_defocus(ttype);
1879         
1880         register_node_type_cmp_valtorgb(ttype);
1881         register_node_type_cmp_rgbtobw(ttype);
1882         register_node_type_cmp_setalpha(ttype);
1883         register_node_type_cmp_idmask(ttype);
1884         register_node_type_cmp_math(ttype);
1885         register_node_type_cmp_seprgba(ttype);
1886         register_node_type_cmp_combrgba(ttype);
1887         register_node_type_cmp_sephsva(ttype);
1888         register_node_type_cmp_combhsva(ttype);
1889         register_node_type_cmp_sepyuva(ttype);
1890         register_node_type_cmp_combyuva(ttype);
1891         register_node_type_cmp_sepycca(ttype);
1892         register_node_type_cmp_combycca(ttype);
1893         register_node_type_cmp_premulkey(ttype);
1894         
1895         register_node_type_cmp_diff_matte(ttype);
1896         register_node_type_cmp_distance_matte(ttype);
1897         register_node_type_cmp_chroma_matte(ttype);
1898         register_node_type_cmp_color_matte(ttype);
1899         register_node_type_cmp_channel_matte(ttype);
1900         register_node_type_cmp_color_spill(ttype);
1901         register_node_type_cmp_luma_matte(ttype);
1902     register_node_type_cmp_doubleedgemask(ttype);
1903
1904         register_node_type_cmp_translate(ttype);
1905         register_node_type_cmp_rotate(ttype);
1906         register_node_type_cmp_scale(ttype);
1907         register_node_type_cmp_flip(ttype);
1908         register_node_type_cmp_crop(ttype);
1909         register_node_type_cmp_displace(ttype);
1910         register_node_type_cmp_mapuv(ttype);
1911         register_node_type_cmp_glare(ttype);
1912         register_node_type_cmp_tonemap(ttype);
1913         register_node_type_cmp_lensdist(ttype);
1914         register_node_type_cmp_transform(ttype);
1915         register_node_type_cmp_stabilize2d(ttype);
1916         register_node_type_cmp_moviedistortion(ttype);
1917 }
1918
1919 static void registerShaderNodes(bNodeTreeType *ttype) 
1920 {
1921         register_node_type_frame(ttype);
1922         
1923         register_node_type_sh_group(ttype);
1924         //register_node_type_sh_forloop(ttype);
1925         //register_node_type_sh_whileloop(ttype);
1926
1927         register_node_type_sh_output(ttype);
1928         register_node_type_sh_material(ttype);
1929         register_node_type_sh_camera(ttype);
1930         register_node_type_sh_gamma(ttype);
1931         register_node_type_sh_brightcontrast(ttype);
1932         register_node_type_sh_value(ttype);
1933         register_node_type_sh_rgb(ttype);
1934         register_node_type_sh_mix_rgb(ttype);
1935         register_node_type_sh_valtorgb(ttype);
1936         register_node_type_sh_rgbtobw(ttype);
1937         register_node_type_sh_texture(ttype);
1938         register_node_type_sh_normal(ttype);
1939         register_node_type_sh_geom(ttype);
1940         register_node_type_sh_mapping(ttype);
1941         register_node_type_sh_curve_vec(ttype);
1942         register_node_type_sh_curve_rgb(ttype);
1943         register_node_type_sh_math(ttype);
1944         register_node_type_sh_vect_math(ttype);
1945         register_node_type_sh_squeeze(ttype);
1946         //register_node_type_sh_dynamic(ttype);
1947         register_node_type_sh_material_ext(ttype);
1948         register_node_type_sh_invert(ttype);
1949         register_node_type_sh_seprgb(ttype);
1950         register_node_type_sh_combrgb(ttype);
1951         register_node_type_sh_hue_sat(ttype);
1952
1953         register_node_type_sh_attribute(ttype);
1954         register_node_type_sh_geometry(ttype);
1955         register_node_type_sh_light_path(ttype);
1956         register_node_type_sh_fresnel(ttype);
1957         register_node_type_sh_layer_weight(ttype);
1958         register_node_type_sh_tex_coord(ttype);
1959
1960         register_node_type_sh_background(ttype);
1961         register_node_type_sh_bsdf_diffuse(ttype);
1962         register_node_type_sh_bsdf_glossy(ttype);
1963         register_node_type_sh_bsdf_glass(ttype);
1964         register_node_type_sh_bsdf_translucent(ttype);
1965         register_node_type_sh_bsdf_transparent(ttype);
1966         register_node_type_sh_bsdf_velvet(ttype);
1967         register_node_type_sh_emission(ttype);
1968         register_node_type_sh_holdout(ttype);
1969         //register_node_type_sh_volume_transparent(ttype);
1970         //register_node_type_sh_volume_isotropic(ttype);
1971         register_node_type_sh_mix_shader(ttype);
1972         register_node_type_sh_add_shader(ttype);
1973
1974         register_node_type_sh_output_lamp(ttype);
1975         register_node_type_sh_output_material(ttype);
1976         register_node_type_sh_output_world(ttype);
1977
1978         register_node_type_sh_tex_image(ttype);
1979         register_node_type_sh_tex_environment(ttype);
1980         register_node_type_sh_tex_sky(ttype);
1981         register_node_type_sh_tex_noise(ttype);
1982         register_node_type_sh_tex_wave(ttype);
1983         register_node_type_sh_tex_voronoi(ttype);
1984         register_node_type_sh_tex_musgrave(ttype);
1985         register_node_type_sh_tex_gradient(ttype);
1986         register_node_type_sh_tex_magic(ttype);
1987         register_node_type_sh_tex_checker(ttype);
1988 }
1989
1990 static void registerTextureNodes(bNodeTreeType *ttype)
1991 {
1992         register_node_type_frame(ttype);
1993         
1994         register_node_type_tex_group(ttype);
1995 //      register_node_type_tex_forloop(ttype);
1996 //      register_node_type_tex_whileloop(ttype);
1997         
1998         register_node_type_tex_math(ttype);
1999         register_node_type_tex_mix_rgb(ttype);
2000         register_node_type_tex_valtorgb(ttype);
2001         register_node_type_tex_rgbtobw(ttype);
2002         register_node_type_tex_valtonor(ttype);
2003         register_node_type_tex_curve_rgb(ttype);
2004         register_node_type_tex_curve_time(ttype);
2005         register_node_type_tex_invert(ttype);
2006         register_node_type_tex_hue_sat(ttype);
2007         register_node_type_tex_coord(ttype);
2008         register_node_type_tex_distance(ttype);
2009         register_node_type_tex_compose(ttype);
2010         register_node_type_tex_decompose(ttype);
2011         
2012         register_node_type_tex_output(ttype);
2013         register_node_type_tex_viewer(ttype);
2014         
2015         register_node_type_tex_checker(ttype);
2016         register_node_type_tex_texture(ttype);
2017         register_node_type_tex_bricks(ttype);
2018         register_node_type_tex_image(ttype);
2019         
2020         register_node_type_tex_rotate(ttype);
2021         register_node_type_tex_translate(ttype);
2022         register_node_type_tex_scale(ttype);
2023         register_node_type_tex_at(ttype);
2024         
2025         register_node_type_tex_proc_voronoi(ttype);
2026         register_node_type_tex_proc_blend(ttype);
2027         register_node_type_tex_proc_magic(ttype);
2028         register_node_type_tex_proc_marble(ttype);
2029         register_node_type_tex_proc_clouds(ttype);
2030         register_node_type_tex_proc_wood(ttype);
2031         register_node_type_tex_proc_musgrave(ttype);
2032         register_node_type_tex_proc_noise(ttype);
2033         register_node_type_tex_proc_stucci(ttype);
2034         register_node_type_tex_proc_distnoise(ttype);
2035 }
2036
2037 static void free_dynamic_typeinfo(bNodeType *ntype)
2038 {
2039         if(ntype->type==NODE_DYNAMIC) {
2040                 if(ntype->inputs) {
2041                         MEM_freeN(ntype->inputs);
2042                 }
2043                 if(ntype->outputs) {
2044                         MEM_freeN(ntype->outputs);
2045                 }
2046                 if(ntype->name) {
2047                         MEM_freeN((void *)ntype->name);
2048                 }
2049         }
2050 }
2051
2052 static void free_typeinfos(ListBase *list)
2053 {
2054         bNodeType *ntype, *next;
2055         for(ntype=list->first; ntype; ntype=next) {
2056                 next = ntype->next;
2057                 
2058                 if(ntype->type==NODE_DYNAMIC)
2059                         free_dynamic_typeinfo(ntype);
2060                 
2061                 if(ntype->needs_free)
2062                         MEM_freeN(ntype);
2063         }
2064 }
2065
2066 void init_nodesystem(void) 
2067 {
2068         registerCompositNodes(ntreeGetType(NTREE_COMPOSIT));
2069         registerShaderNodes(ntreeGetType(NTREE_SHADER));
2070         registerTextureNodes(ntreeGetType(NTREE_TEXTURE));
2071 }
2072
2073 void free_nodesystem(void) 
2074 {
2075         free_typeinfos(&ntreeGetType(NTREE_COMPOSIT)->node_types);
2076         free_typeinfos(&ntreeGetType(NTREE_SHADER)->node_types);
2077         free_typeinfos(&ntreeGetType(NTREE_TEXTURE)->node_types);
2078 }
2079
2080 /* called from unlink_scene, when deleting a scene goes over all scenes
2081  * other than the input, checks if they have render layer nodes referencing
2082  * the to-be-deleted scene, and resets them to NULL. */
2083
2084 /* XXX needs to get current scene then! */
2085 void clear_scene_in_nodes(Main *bmain, Scene *sce)
2086 {
2087         Scene *sce1;
2088         bNode *node;
2089
2090         for(sce1= bmain->scene.first; sce1; sce1=sce1->id.next) {
2091                 if(sce1!=sce) {
2092                         if(sce1->nodetree) {
2093                                 for(node= sce1->nodetree->nodes.first; node; node= node->next) {
2094                                         if(node->type==CMP_NODE_R_LAYERS) {
2095                                                 Scene *nodesce= (Scene *)node->id;
2096                                                 
2097                                                 if (nodesce==sce) node->id = NULL;
2098                                         }
2099                                 }
2100                         }
2101                 }
2102         }
2103 }
2104